@performant-software/geospatial 3.1.28 → 3.1.30-beta.0

package/dist/index.cjs405.js.map

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

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function r(o){return{source:o.destination,destination:o.source}}function t(o){return o.destination}function i(o){return o.source}function e(o){return o.geo}function n(o){return o.resource}function a(o){return{resource:o.source,geo:o.destination,partialDerivativeX:o.partialDerivativeX,partialDerivativeY:o.partialDerivativeY,distortions:o.distortions,distortion:o.distortion}}function s(o){return{source:o.resource,destination:o.geo,partialDerivativeX:o.partialDerivativeX,partialDerivativeY:o.partialDerivativeY,distortions:o.distortions,distortion:o.distortion}}exports.gcpToGeneralGcp=s;exports.gcpToPointForToGeo=e;exports.gcpToPointForToResource=n;exports.generalGcpToGcp=a;exports.generalGcpToPointForBackward=i;exports.generalGcpToPointForForward=t;exports.invertGeneralGcp=r;
+//# sourceMappingURL=index.cjs406.js.map

package/dist/index.cjs406.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs406.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":"gFACO,SAASA,EAAiBC,EAAY,CACzC,MAAO,CAAE,OAAQA,EAAW,YAAa,YAAaA,EAAW,MAAA,CACrE,CAKO,SAASC,EAA4BD,EAAY,CACpD,OAAOA,EAAW,WACtB,CACO,SAASE,EAA6BF,EAAY,CACrD,OAAOA,EAAW,MACtB,CACO,SAASG,EAAmBC,EAAK,CACpC,OAAOA,EAAI,GACf,CACO,SAASC,EAAwBD,EAAK,CACzC,OAAOA,EAAI,QACf,CAEO,SAASE,EAAgBN,EAAY,CACxC,MAAO,CACH,SAAUA,EAAW,OACrB,IAAKA,EAAW,YAChB,mBAAoBA,EAAW,mBAC/B,mBAAoBA,EAAW,mBAC/B,YAAaA,EAAW,YACxB,WAAYA,EAAW,UAAA,CAE/B,CACO,SAASO,EAAgBH,EAAK,CACjC,MAAO,CACH,OAAQA,EAAI,SACZ,YAAaA,EAAI,IACjB,mBAAoBA,EAAI,mBACxB,mBAAoBA,EAAI,mBACxB,YAAaA,EAAI,YACjB,WAAYA,EAAI,UAAA,CAExB","x_google_ignoreList":[0]}

package/dist/index.cjs407.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("./index.cjs408.js");class o extends n.BaseLinearWeightsTransformation{constructor(e,r,t,s){super(e,r,t,s)}getCoefsArrayMatrices(){const e=this.getCoefsArrayMatrix();return[e,e]}getSourcePointCoefsArrays(e){const r=this.getSourcePointCoefsArray(e);return[r,r]}}exports.BaseIndependentLinearWeightsTransformation=o;
+//# sourceMappingURL=index.cjs407.js.map

package/dist/index.cjs407.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs407.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":"qHAKO,MAAMA,UAAmDC,EAAAA,+BAAgC,CAC5F,YAAYC,EAAcC,EAAmBC,EAAMC,EAAmB,CAClE,MAAMH,EAAcC,EAAmBC,EAAMC,CAAiB,CAClE,CACA,uBAAwB,CACpB,MAAMC,EAAmB,KAAK,oBAAA,EAC9B,MAAO,CAACA,EAAkBA,CAAgB,CAC9C,CACA,0BAA0BC,EAAa,CACnC,MAAMC,EAAwB,KAAK,yBAAyBD,CAAW,EACvE,MAAO,CAACC,EAAuBA,CAAqB,CACxD,CACJ","x_google_ignoreList":[0]}

package/dist/index.cjs408.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("./index.cjs409.js");class a extends n.BaseTransformation{destinationPointsArrays;constructor(s,t,r,e){super(s,t,r,e),this.destinationPointsArrays=this.getDestinationPointsArrays()}}exports.BaseLinearWeightsTransformation=a;
+//# sourceMappingURL=index.cjs408.js.map

package/dist/index.cjs408.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs408.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":"qHAOO,MAAMA,UAAwCC,EAAAA,kBAAmB,CACpE,wBACA,YAAYC,EAAcC,EAAmBC,EAAMC,EAAmB,CAClE,MAAMH,EAAcC,EAAmBC,EAAMC,CAAiB,EAC9D,KAAK,wBAA0B,KAAK,2BAAA,CACxC,CACJ","x_google_ignoreList":[0]}

package/dist/index.cjs409.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("./index.cjs274.js");class e{sourcePoints;destinationPoints;destinationTransformedSourcePoints;type;pointCount;pointCountMinimum;errors;destinationRmse;constructor(t,i,s,o){if(this.sourcePoints=t,this.destinationPoints=i,this.pointCount=this.sourcePoints.length,this.type=s,this.pointCountMinimum=o,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.")}setWeightsArrays(t){this.weightsArrays=t,this.processWeightsArrays()}processWeightsArrays(){}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)=>n.distance(i,t[s]))}return this.errors}getDestinationRmse(){if(!this.destinationRmse){const t=this.getDestinationTransformedSourcePoints();this.destinationTransformedSourcePoints||this.getDestinationTransformedSourcePoints(),this.destinationRmse=n.rms(this.destinationPoints,t)}return this.destinationRmse}}exports.BaseTransformation=e;
+//# sourceMappingURL=index.cjs409.js.map

package/dist/index.cjs409.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs409.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":"qHAIO,MAAMA,CAAmB,CAC5B,aACA,kBACA,mCACA,KACA,WACA,kBACA,OACA,gBASA,YAAYC,EAAcC,EAAmBC,EAAMC,EAAmB,CAMlE,GALA,KAAK,aAAeH,EACpB,KAAK,kBAAoBC,EACzB,KAAK,WAAa,KAAK,aAAa,OACpC,KAAK,KAAOC,EACZ,KAAK,kBAAoBC,EACrB,KAAK,WAAa,KAAK,kBACvB,MAAM,IAAI,MAAM,gCACZ,KAAK,KACL,yCACA,KAAK,kBACL,gBACA,KAAK,WACL,aAAa,CAEzB,CAQA,iBAAiBC,EAAe,CAC5B,KAAK,cAAgBA,EACrB,KAAK,qBAAA,CACT,CACA,sBAAuB,CAEvB,CAMA,uCAAwC,CACpC,OAAK,KAAK,qCACN,KAAK,mCAAqC,KAAK,aAAa,IAAKC,GAAgB,KAAK,iBAAiBA,CAAW,CAAC,GAEhH,KAAK,kCAChB,CACA,aAAc,CACV,MAAO,CAAA,CACX,CACA,WAAY,CACR,GAAI,CAAC,KAAK,OAAQ,CACd,MAAMC,EAAqC,KAAK,sCAAA,EAChD,KAAK,OAAS,KAAK,kBAAkB,IAAI,CAACC,EAAkBC,IAAUC,EAAAA,SAASF,EAAkBD,EAAmCE,CAAK,CAAC,CAAC,CAC/I,CACA,OAAO,KAAK,MAChB,CACA,oBAAqB,CACjB,GAAI,CAAC,KAAK,gBAAiB,CACvB,MAAMF,EAAqC,KAAK,sCAAA,EAC3C,KAAK,oCACN,KAAK,sCAAA,EAET,KAAK,gBAAkBI,EAAAA,IAAI,KAAK,kBAAmBJ,CAAkC,CACzF,CACA,OAAO,KAAK,eAChB,CACJ","x_google_ignoreList":[0]}

package/dist/index.cjs410.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const i=require("./index.cjs333.js"),o=require("./index.cjs407.js"),n=require("./index.cjs411.js");class y extends o.BaseIndependentLinearWeightsTransformation{coefsArrayMatrices;coefsArrayMatrix;coefsArrayMatricesSize;coefsArrayMatrixSize;order;weightsArrays;constructor(r,t,s){s=s||1;const e=(s+1)*(s+2)/2;if(super(r,t,"polynomial"+s,e),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(a=>i.arrayMatrixSize(a)),this.coefsArrayMatrixSize=i.arrayMatrixSize(this.coefsArrayMatrix)}getDestinationPointsArrays(){return[this.destinationPoints.map(r=>r[0]),this.destinationPoints.map(r=>r[1])]}getCoefsArrayMatrix(){let r=i.newArrayMatrix(this.pointCount,this.pointCountMinimum,0);for(let t=0;t<this.pointCount;t++)r=i.pasteArrayMatrix(r,t,0,[this.getSourcePointCoefsArray(this.sourcePoints[t])]);return r}solve(){this.weightsArrays=n.solveIndependentlyPseudoInverse(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)}}}exports.BasePolynomialTransformation=y;
+//# sourceMappingURL=index.cjs410.js.map

package/dist/index.cjs410.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs410.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":"mLAGO,MAAMA,UAAqCC,EAAAA,0CAA2C,CACzF,mBACA,iBACA,uBACA,qBACA,MACA,cACA,YAAYC,EAAcC,EAAmBC,EAAO,CAChDA,EAAQA,GAAS,EACjB,MAAMC,GAAuBD,EAAQ,IAAMA,EAAQ,GAAM,EAKzD,GAFA,MAAMF,EAAcC,EAAoB,aAAeC,EAAQC,CAAkB,EACjF,KAAK,MAAQD,EACT,KAAK,MAAQ,GAAK,KAAK,MAAQ,EAC/B,MAAM,IAAI,MAAM,kEAAkE,EAEtF,KAAK,mBAAqB,KAAK,sBAAA,EAC/B,KAAK,iBAAmB,KAAK,mBAAmB,CAAC,EACjD,KAAK,uBAAyB,KAAK,mBAAmB,IAAKE,GAAqBC,kBAAgBD,CAAgB,CAAC,EACjH,KAAK,qBAAuBC,kBAAgB,KAAK,gBAAgB,CACrE,CACA,4BAA6B,CACzB,MAAO,CACH,KAAK,kBAAkB,IAAKC,GAAUA,EAAM,CAAC,CAAC,EAC9C,KAAK,kBAAkB,IAAKA,GAAUA,EAAM,CAAC,CAAC,CAAA,CAEtD,CACA,qBAAsB,CAClB,IAAIC,EAAkBC,EAAAA,eAAe,KAAK,WAAY,KAAK,kBAAmB,CAAC,EAC/E,QAASC,EAAI,EAAGA,EAAI,KAAK,WAAYA,IACjCF,EAAkBG,EAAAA,iBAAiBH,EAAiBE,EAAG,EAAG,CACtD,KAAK,yBAAyB,KAAK,aAAaA,CAAC,CAAC,CAAA,CACrD,EAEL,OAAOF,CACX,CACA,OAAQ,CACJ,KAAK,cAAgBI,EAAAA,gCAAgC,KAAK,iBAAkB,KAAK,uBAAuB,CAC5G,CACA,qCAAsC,CAIlC,GAHK,KAAK,eACN,KAAK,MAAA,EAEL,CAAC,KAAK,cACN,MAAM,IAAI,MAAM,gDAAgD,EAGpE,MAAO,CACH,QAAS,IAAI,aAAa,CACtB,GAAG,KAAK,cAAc,CAAC,EACvB,GAAG,KAAK,cAAc,CAAC,CAAA,CAC1B,EACD,aAAc,IAAI,aAAa,CAAC,CAAA,CAExC,CACJ","x_google_ignoreList":[0]}

package/dist/index.cjs411.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./index.cjs420.js");function c(s,t){const o=new e.default([...s[0],...s[1]]),n=e.default.columnVector([...t[0],...t[1]]);return e.pseudoInverse(o).mmul(n).to1DArray()}function l(s,t){const o=new e.default(s),n=[e.default.columnVector(t[0]),e.default.columnVector(t[1])],r=e.pseudoInverse(o);return[r.mmul(n[0]),r.mmul(n[1])].map(a=>a.to1DArray())}function d(s,t){const o=new e.default(s),n=[e.default.columnVector(t[0]),e.default.columnVector(t[1])],r=e.inverse(o);return[r.mmul(n[0]),r.mmul(n[1])].map(a=>a.to1DArray())}function v(s,t){const o=[];for(let i=0;i<t;i++)o.push(s[0][i]),o.push(s[1][i]);const n=new e.SingularValueDecomposition(o);return e.default.from1DArray(3,3,n.rightSingularVectors.getColumn(8)).transpose().to2DArray()}exports.solveIndependentlyInverse=d;exports.solveIndependentlyPseudoInverse=l;exports.solveJointlyPseudoInverse=c;exports.solveJointlySvd=v;
+//# sourceMappingURL=index.cjs411.js.map

package/dist/index.cjs411.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs411.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":"qHAUO,SAASA,EAA0BC,EAAoBC,EAAyB,CACnF,MAAMC,EAAc,IAAIC,UAAO,CAC3B,GAAGH,EAAmB,CAAC,EACvB,GAAGA,EAAmB,CAAC,CAAA,CAC1B,EACKI,EAA0BD,EAAAA,QAAO,aAAa,CAChD,GAAGF,EAAwB,CAAC,EAC5B,GAAGA,EAAwB,CAAC,CAAA,CAC/B,EAID,OAHiCI,EAAAA,cAAcH,CAAW,EACX,KAAKE,CAAuB,EACxC,UAAA,CAEvC,CAeO,SAASE,EAAgCC,EAAkBN,EAAyB,CACvF,MAAMC,EAAc,IAAIC,EAAAA,QAAOI,CAAgB,EACzCC,EAA4B,CAC9BL,EAAAA,QAAO,aAAaF,EAAwB,CAAC,CAAC,EAC9CE,UAAO,aAAaF,EAAwB,CAAC,CAAC,CAAA,EAE5CQ,EAA2BJ,EAAAA,cAAcH,CAAW,EAM1D,MALwB,CACpBO,EAAyB,KAAKD,EAA0B,CAAC,CAAC,EAC1DC,EAAyB,KAAKD,EAA0B,CAAC,CAAC,CAAA,EAExB,IAAKE,GAAWA,EAAO,WAAW,CAE5E,CAUO,SAASC,EAA0BJ,EAAkBN,EAAyB,CACjF,MAAMC,EAAc,IAAIC,EAAAA,QAAOI,CAAgB,EACzCC,EAA4B,CAC9BL,EAAAA,QAAO,aAAaF,EAAwB,CAAC,CAAC,EAC9CE,UAAO,aAAaF,EAAwB,CAAC,CAAC,CAAA,EAE5CW,EAAqBC,EAAAA,QAAQX,CAAW,EAM9C,MALwB,CACpBU,EAAmB,KAAKJ,EAA0B,CAAC,CAAC,EACpDI,EAAmB,KAAKJ,EAA0B,CAAC,CAAC,CAAA,EAElB,IAAKE,GAAWA,EAAO,WAAW,CAE5E,CAWO,SAASI,EAAgBd,EAAoBe,EAAY,CAG5D,MAAMb,EAAc,CAAA,EACpB,QAAS,EAAI,EAAG,EAAIa,EAAY,IAC5Bb,EAAY,KAAKF,EAAmB,CAAC,EAAE,CAAC,CAAC,EACzCE,EAAY,KAAKF,EAAmB,CAAC,EAAE,CAAC,CAAC,EAE7C,MAAMgB,EAAiB,IAAIC,EAAAA,2BAA2Bf,CAAW,EAGjE,OAFsBC,EAAAA,QAAO,YAAY,EAAG,EAAGa,EAAe,qBAAqB,UAAU,CAAC,CAAC,EAAE,UAAA,EAC7D,UAAA,CAExC","x_google_ignoreList":[0]}

package/dist/index.cjs412.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("./index.cjs333.js"),a=require("./index.cjs408.js"),o=require("./index.cjs411.js");class h extends a.BaseLinearWeightsTransformation{coefsArrayMatrices;coefsArrayMatricesSize;weightsArray;weightsArrays;constructor(t,r){super(t,r,"helmert",2),this.coefsArrayMatrices=this.getCoefsArrayMatrices(),this.coefsArrayMatricesSize=this.coefsArrayMatrices.map(e=>s.arrayMatrixSize(e))}getDestinationPointsArrays(){return[this.destinationPoints.map(t=>t[0]),this.destinationPoints.map(t=>t[1])]}getCoefsArrayMatrices(){let t=s.newArrayMatrix(this.pointCount,4,0),r=s.newArrayMatrix(this.pointCount,4,0);for(let e=0;e<this.pointCount;e++){const i=this.getSourcePointCoefsArrays(this.sourcePoints[e]);t=s.pasteArrayMatrix(t,e,0,[i[0]]),r=s.pasteArrayMatrix(r,e,0,[i[1]])}return[t,r]}getSourcePointCoefsArrays(t){return[[1,0,t[0],-t[1]],[0,1,t[1],t[0]]]}solve(){this.weightsArray=o.solveJointlyPseudoInverse(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)}}}exports.Helmert=h;
+//# sourceMappingURL=index.cjs412.js.map

package/dist/index.cjs412.js.map

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

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("./index.cjs410.js");class h extends n.BasePolynomialTransformation{constructor(t,r){super(t,r,1)}getSourcePointCoefsArray(t){return h.getPolynomial1SourcePointCoefsArray(t)}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],o=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,o/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=[o/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}}exports.Polynomial1=h;
+//# sourceMappingURL=index.cjs413.js.map

package/dist/index.cjs413.js.map

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

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./index.cjs410.js");class i extends e.BasePolynomialTransformation{constructor(t,r){super(t,r,2)}getSourcePointCoefsArray(t){return i.getPolynomial2SourcePointCoefsArray(t)}static getPolynomial2SourcePointCoefsArray(t){return[1,t[0],t[1],t[0]**2,t[1]**2,t[0]*t[1]]}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}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}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}}exports.Polynomial2=i;
+//# sourceMappingURL=index.cjs414.js.map

package/dist/index.cjs414.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs414.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":"qHAIO,MAAMA,UAAoBC,EAAAA,4BAA6B,CAC1D,YAAYC,EAAcC,EAAmB,CACzC,MAAMD,EAAcC,EAAmB,CAAC,CAC5C,CACA,yBAAyBC,EAAa,CAClC,OAAOJ,EAAY,oCAAoCI,CAAW,CACtE,CAQA,OAAO,oCAAoCA,EAAa,CACpD,MAAO,CACH,EACAA,EAAY,CAAC,EACbA,EAAY,CAAC,EACbA,EAAY,CAAC,GAAK,EAClBA,EAAY,CAAC,GAAK,EAClBA,EAAY,CAAC,EAAIA,EAAY,CAAC,CAAA,CAEtC,CAEA,iBAAiBC,EAAgB,CAI7B,GAHK,KAAK,eACN,KAAK,MAAA,EAEL,CAAC,KAAK,cACN,MAAM,IAAI,MAAM,sBAAsB,EAG1C,MAAMC,EAAsB,CAAC,EAAG,CAAC,EACjC,QAASC,EAAI,EAAGA,EAAI,EAAGA,IACnBD,EAAoBC,CAAC,GACjB,KAAK,cAAcA,CAAC,EAAE,CAAC,EACnB,KAAK,cAAcA,CAAC,EAAE,CAAC,EAAIF,EAAe,CAAC,EAC3C,KAAK,cAAcE,CAAC,EAAE,CAAC,EAAIF,EAAe,CAAC,EAC3C,KAAK,cAAcE,CAAC,EAAE,CAAC,EAAIF,EAAe,CAAC,GAAK,EAChD,KAAK,cAAcE,CAAC,EAAE,CAAC,EAAIF,EAAe,CAAC,GAAK,EAChD,KAAK,cAAcE,CAAC,EAAE,CAAC,EAAIF,EAAe,CAAC,EAAIA,EAAe,CAAC,EAE3E,OAAOC,CACX,CAEA,2BAA2BD,EAAgB,CAIvC,GAHK,KAAK,eACN,KAAK,MAAA,EAEL,CAAC,KAAK,cACN,MAAM,IAAI,MAAM,sBAAsB,EAG1C,MAAMG,EAA8B,CAAC,EAAG,CAAC,EACzC,QAASD,EAAI,EAAGA,EAAI,EAAGA,IACnBC,EAA4BD,CAAC,GACzB,KAAK,cAAcA,CAAC,EAAE,CAAC,EACnB,EAAI,KAAK,cAAcA,CAAC,EAAE,CAAC,EAAIF,EAAe,CAAC,EAC/C,KAAK,cAAcE,CAAC,EAAE,CAAC,EAAIF,EAAe,CAAC,EAEvD,OAAOG,CACX,CAEA,2BAA2BH,EAAgB,CAIvC,GAHK,KAAK,eACN,KAAK,MAAA,EAEL,CAAC,KAAK,cACN,MAAM,IAAI,MAAM,sBAAsB,EAG1C,MAAMI,EAA8B,CAAC,EAAG,CAAC,EACzC,QAASF,EAAI,EAAGA,EAAI,EAAGA,IACnBE,EAA4BF,CAAC,GACzB,KAAK,cAAcA,CAAC,EAAE,CAAC,EACnB,EAAI,KAAK,cAAcA,CAAC,EAAE,CAAC,EAAIF,EAAe,CAAC,EAC/C,KAAK,cAAcE,CAAC,EAAE,CAAC,EAAIF,EAAe,CAAC,EAEvD,OAAOI,CACX,CACJ","x_google_ignoreList":[0]}

package/dist/index.cjs415.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const h=require("./index.cjs410.js");class i extends h.BasePolynomialTransformation{constructor(s,r){super(s,r,3)}getSourcePointCoefsArray(s){return i.getPolynomial3SourcePointCoefsArray(s)}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]}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}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}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}}exports.Polynomial3=i;
+//# sourceMappingURL=index.cjs415.js.map

package/dist/index.cjs415.js.map

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

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./index.cjs333.js"),h=require("./index.cjs409.js"),y=require("./index.cjs411.js");class A extends h.BaseTransformation{coefsArrayMatrices;weightsArrays;constructor(r,t){super(r,t,"projective",4),this.coefsArrayMatrices=[e.newArrayMatrix(this.pointCount,9,0),e.newArrayMatrix(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.solveJointlySvd(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)}}}exports.Projective=A;
+//# sourceMappingURL=index.cjs416.js.map

package/dist/index.cjs416.js.map

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

package/dist/index.cjs417.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const f=require("./index.cjs333.js"),c=require("./index.cjs413.js"),y=require("./index.cjs407.js"),u=require("./index.cjs411.js");class l extends y.BaseIndependentLinearWeightsTransformation{kernelFunction;normFunction;epsilon;coefsArrayMatrices;coefsArrayMatrix;coefsArrayMatricesSize;coefsArrayMatrixSize;weightsArrays;rbfWeightsArrays;affineWeightsArrays;constructor(i,r,e,s,n,t){super(i,r,n,3),this.kernelFunction=e,this.normFunction=s,this.epsilon=t,this.coefsArrayMatrices=this.getCoefsArrayMatrices(),this.coefsArrayMatrix=this.coefsArrayMatrices[0],this.coefsArrayMatricesSize=this.coefsArrayMatrices.map(o=>f.arrayMatrixSize(o)),this.coefsArrayMatrixSize=f.arrayMatrixSize(this.coefsArrayMatrix)}getDestinationPointsArrays(){return[[...this.destinationPoints,[0,0],[0,0],[0,0]].map(i=>i[0]),[...this.destinationPoints,[0,0],[0,0],[0,0]].map(i=>i[1])]}getCoefsArrayMatrix(){const i=f.newArrayMatrix(this.pointCount,this.pointCount,0);for(let t=0;t<this.pointCount;t++)for(let o=0;o<this.pointCount;o++)i[t][o]=this.normFunction(this.sourcePoints[t],this.sourcePoints[o]);if(this.epsilon===void 0){const t=i.map(o=>o.reduce((a,h)=>a+h,0)).reduce((o,a)=>o+a,0);this.epsilon=t/(Math.pow(this.pointCount,2)-this.pointCount)}const r=f.newArrayMatrix(this.pointCount,this.pointCount,0);for(let t=0;t<this.pointCount;t++)for(let o=0;o<this.pointCount;o++)r[t][o]=this.kernelFunction(i[t][o],{epsilon:this.epsilon});let e=f.newArrayMatrix(this.pointCount,3,0);for(let t=0;t<this.pointCount;t++)e=f.pasteArrayMatrix(e,t,0,[c.Polynomial1.getPolynomial1SourcePointCoefsArray(this.sourcePoints[t])]);const s=f.newArrayMatrix(3,3,0);return f.newBlockArrayMatrix([[r,e],[f.transposeArrayMatrix(e),s]])}getSourcePointCoefsArray(i){return[...this.getRbfKernelSourcePointCoefsArray(i),...c.Polynomial1.getPolynomial1SourcePointCoefsArray(i)]}getRbfKernelSourcePointCoefsArray(i){const r=[];for(let e=0;e<this.pointCount;e++)r.push(this.kernelFunction(this.normFunction(this.sourcePoints[e],i),{epsilon:this.epsilon}));return r}setWeightsArrays(i,r){r&&(this.epsilon=r),super.setWeightsArrays(i)}solve(){this.weightsArrays=u.solveIndependentlyInverse(this.coefsArrayMatrix,this.destinationPointsArrays),this.processWeightsArrays()}processWeightsArrays(){if(!this.weightsArrays)throw new Error("Weights not computed");this.rbfWeightsArrays=this.weightsArrays.map(i=>i.slice(0,this.pointCount)),this.affineWeightsArrays=this.weightsArrays.map(i=>i.slice(this.pointCount))}evaluateFunction(i){if(this.weightsArrays||this.solve(),!this.rbfWeightsArrays||!this.affineWeightsArrays)throw new Error("RBF weights not computed");const r=this.rbfWeightsArrays,e=this.affineWeightsArrays,s=this.sourcePoints.map(t=>this.normFunction(i,t)),n=[0,0];for(let t=0;t<2;t++)n[t]=s.reduce((o,a,h)=>o+this.kernelFunction(a,{epsilon:this.epsilon})*r[t][h],0),n[t]+=e[t][0]+e[t][1]*i[0]+e[t][2]*i[1];return n}evaluatePartialDerivativeX(i){if(this.weightsArrays||this.solve(),!this.rbfWeightsArrays||!this.affineWeightsArrays)throw new Error("RBF weights not computed");const r=this.rbfWeightsArrays,e=this.affineWeightsArrays,s=this.sourcePoints.map(t=>this.normFunction(i,t)),n=[0,0];for(let t=0;t<2;t++)n[t]=s.reduce((o,a,h)=>o+(a===0?0:this.kernelFunction(a,{derivative:1,epsilon:this.epsilon})*((i[0]-this.sourcePoints[h][0])/a)*r[t][h]),0),n[t]+=e[t][1];return n}evaluatePartialDerivativeY(i){if(this.weightsArrays||this.solve(),!this.rbfWeightsArrays||!this.affineWeightsArrays)throw new Error("RBF weights not computed");const r=this.rbfWeightsArrays,e=this.affineWeightsArrays,s=this.sourcePoints.map(t=>this.normFunction(i,t)),n=[0,0];for(let t=0;t<2;t++)n[t]=s.reduce((o,a,h)=>o+(a===0?0:this.kernelFunction(a,{derivative:1,epsilon:this.epsilon})*((i[1]-this.sourcePoints[h][1])/a)*r[t][h]),0),n[t]+=e[t][2];return n}getTransformationDataAsFloat64Array(){if(this.weightsArrays||this.solve(),!this.rbfWeightsArrays||!this.affineWeightsArrays)throw new Error("ThinPlateSpline transformation weights not computed");const i=this.sourcePoints.length,r=new Float64Array(1+2*i+6);r[0]=i;for(let s=0;s<i;s++)r[1+s]=this.rbfWeightsArrays[0][s];for(let s=0;s<i;s++)r[1+i+s]=this.rbfWeightsArrays[1][s];for(let s=0;s<3;s++)r[1+2*i+s]=this.affineWeightsArrays[0][s];for(let s=0;s<3;s++)r[1+2*i+3+s]=this.affineWeightsArrays[1][s];const e=new Float64Array(i*2);for(let s=0;s<i;s++)e[s*2]=this.sourcePoints[s][0],e[s*2+1]=this.sourcePoints[s][1];return{weights:r,sourcePoints:e}}}exports.RBF=l;
+//# sourceMappingURL=index.cjs417.js.map

package/dist/index.cjs417.js.map

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

package/dist/index.cjs418.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("./index.cjs412.js"),h=require("./index.cjs409.js");class w extends h.BaseTransformation{weightsArrays;constructor(s,r){super(s,r,"straight",2)}solve(){const r=new o.Helmert(this.sourcePoints,this.destinationPoints).getMeasures().scale,i=this.sourcePoints.reduce((t,e)=>[t[0]+e[0],t[1]+e[1]]).map(t=>t/this.pointCount),n=this.destinationPoints.reduce((t,e)=>[t[0]+e[0],t[1]+e[1]]).map(t=>t/this.pointCount),a=n.map((t,e)=>t-i[e]*r);this.weightsArrays={scale:r,sourcePointsCenter:i,destinationPointsCenter:n,translation:a}}evaluateFunction(s){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Weights not computed");return[this.weightsArrays.translation[0]+this.weightsArrays.scale*s[0],this.weightsArrays.translation[1]+this.weightsArrays.scale*s[1]]}evaluatePartialDerivativeX(s){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Weights not computed");return[this.weightsArrays.scale,0]}evaluatePartialDerivativeY(s){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Weights not computed");return[0,this.weightsArrays.scale]}getTransformationDataAsFloat64Array(){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Weights not computed");return{weights:new Float64Array([this.weightsArrays.translation[0],this.weightsArrays.translation[1],this.weightsArrays.scale]),sourcePoints:new Float64Array(0)}}}exports.Straight=w;
+//# sourceMappingURL=index.cjs418.js.map

package/dist/index.cjs418.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs418.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/Straight.js"],"sourcesContent":["import { Helmert } from './Helmert.js';\nimport { BaseTransformation } from './BaseTransformation.js';\nexport class Straight extends BaseTransformation {\n    weightsArrays;\n    constructor(sourcePoints, destinationPoints) {\n        super(sourcePoints, destinationPoints, 'straight', 2);\n    }\n    /** Solve the x and y components jointly.\n     *\n     * This computes the corresponding Helmert transform and get the scale from it.\n     */\n    solve() {\n        const helmertTransformation = new Helmert(this.sourcePoints, this.destinationPoints);\n        const scale = helmertTransformation.getMeasures().scale;\n        // Compute the centers of the source points and destination points\n        const sourcePointsCenter = this.sourcePoints\n            .reduce((center, point) => [center[0] + point[0], center[1] + point[1]])\n            .map((coordinate) => coordinate / this.pointCount);\n        const destinationPointsCenter = this.destinationPoints\n            .reduce((center, point) => [center[0] + point[0], center[1] + point[1]])\n            .map((coordinate) => coordinate / this.pointCount);\n        // Compute the translation vector from the (scaled) center of the source points to the center of the destination points\n        const translation = destinationPointsCenter.map((coord, i) => coord - sourcePointsCenter[i] * scale);\n        this.weightsArrays = {\n            scale,\n            sourcePointsCenter,\n            destinationPointsCenter,\n            translation\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        const newDestinationPoint = [\n            this.weightsArrays.translation[0] +\n                this.weightsArrays.scale * newSourcePoint[0],\n            this.weightsArrays.translation[1] +\n                this.weightsArrays.scale * 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        const newDestinationPointPartDerX = [this.weightsArrays.scale, 0];\n        return newDestinationPointPartDerX;\n    }\n    // Evaluate the transformation function's partial derivative to y 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        const newDestinationPointPartDerY = [0, this.weightsArrays.scale];\n        return newDestinationPointPartDerY;\n    }\n    getTransformationDataAsFloat64Array() {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Weights not computed');\n        }\n        // Straight: [tx, ty, scale]\n        return {\n            weights: new Float64Array([\n                this.weightsArrays.translation[0],\n                this.weightsArrays.translation[1],\n                this.weightsArrays.scale\n            ]),\n            sourcePoints: new Float64Array(0)\n        };\n    }\n}\n"],"names":["Straight","BaseTransformation","sourcePoints","destinationPoints","scale","Helmert","sourcePointsCenter","center","point","coordinate","destinationPointsCenter","translation","coord","i","newSourcePoint","_newSourcePoint"],"mappings":"oJAEO,MAAMA,UAAiBC,EAAAA,kBAAmB,CAC7C,cACA,YAAYC,EAAcC,EAAmB,CACzC,MAAMD,EAAcC,EAAmB,WAAY,CAAC,CACxD,CAKA,OAAQ,CAEJ,MAAMC,EADwB,IAAIC,EAAAA,QAAQ,KAAK,aAAc,KAAK,iBAAiB,EAC/C,YAAA,EAAc,MAE5CC,EAAqB,KAAK,aAC3B,OAAO,CAACC,EAAQC,IAAU,CAACD,EAAO,CAAC,EAAIC,EAAM,CAAC,EAAGD,EAAO,CAAC,EAAIC,EAAM,CAAC,CAAC,CAAC,EACtE,IAAKC,GAAeA,EAAa,KAAK,UAAU,EAC/CC,EAA0B,KAAK,kBAChC,OAAO,CAACH,EAAQC,IAAU,CAACD,EAAO,CAAC,EAAIC,EAAM,CAAC,EAAGD,EAAO,CAAC,EAAIC,EAAM,CAAC,CAAC,CAAC,EACtE,IAAKC,GAAeA,EAAa,KAAK,UAAU,EAE/CE,EAAcD,EAAwB,IAAI,CAACE,EAAOC,IAAMD,EAAQN,EAAmBO,CAAC,EAAIT,CAAK,EACnG,KAAK,cAAgB,CACjB,MAAAA,EACA,mBAAAE,EACA,wBAAAI,EACA,YAAAC,CAAA,CAER,CAEA,iBAAiBG,EAAgB,CAI7B,GAHK,KAAK,eACN,KAAK,MAAA,EAEL,CAAC,KAAK,cACN,MAAM,IAAI,MAAM,sBAAsB,EAQ1C,MAN4B,CACxB,KAAK,cAAc,YAAY,CAAC,EAC5B,KAAK,cAAc,MAAQA,EAAe,CAAC,EAC/C,KAAK,cAAc,YAAY,CAAC,EAC5B,KAAK,cAAc,MAAQA,EAAe,CAAC,CAAA,CAGvD,CAEA,2BAA2BC,EAAiB,CAIxC,GAHK,KAAK,eACN,KAAK,MAAA,EAEL,CAAC,KAAK,cACN,MAAM,IAAI,MAAM,sBAAsB,EAG1C,MADoC,CAAC,KAAK,cAAc,MAAO,CAAC,CAEpE,CAEA,2BAA2BA,EAAiB,CAIxC,GAHK,KAAK,eACN,KAAK,MAAA,EAEL,CAAC,KAAK,cACN,MAAM,IAAI,MAAM,sBAAsB,EAG1C,MADoC,CAAC,EAAG,KAAK,cAAc,KAAK,CAEpE,CACA,qCAAsC,CAIlC,GAHK,KAAK,eACN,KAAK,MAAA,EAEL,CAAC,KAAK,cACN,MAAM,IAAI,MAAM,sBAAsB,EAG1C,MAAO,CACH,QAAS,IAAI,aAAa,CACtB,KAAK,cAAc,YAAY,CAAC,EAChC,KAAK,cAAc,YAAY,CAAC,EAChC,KAAK,cAAc,KAAA,CACtB,EACD,aAAc,IAAI,aAAa,CAAC,CAAA,CAExC,CACJ","x_google_ignoreList":[0]}

package/dist/index.cjs419.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const G=require("./index.cjs215.js"),u=require("./index.cjs274.js"),C={maxDepth:0,minSourceDistance:0,minDestinationDistance:0,minOffsetRatio:0,minOffsetDistance:1/0,sourceMidPointFunction:u.midPoint,destinationMidPointFunction:u.midPoint};function R(n,o,t){n=u.conformLineString(n);const i=n.map(s=>({source:s,destination:o(s)})),c=f(i,!1).map(s=>d(s,o,t,0)).flat(1);return M(c,!0)}function T(n,o,t){n=u.conformRing(n);const i=n.map(s=>({source:s,destination:o(s)})),c=f(i,!0).map(s=>d(s,o,t,0)).flat(1);return M(c,!1)}function d(n,o,t,i){const e=m(n,o,t,i);return e?[d([n[0],e],o,t,i+1),d([e,n[1]],o,t,i+1)].flat(1):[n]}function m(n,o,t,i){if(i>=t.maxDepth||t.maxDepth<=0||u.distance(n[0].source,n[1].source)<t.minSourceDistance||u.distance(n[0].destination,n[1].destination)<t.minDestinationDistance)return;const{sourceMidPoint:e,destinationMidPointFromRefinementFunction:c,destinationMidPointsDistance:s,destinationLineDistance:r}=F(n,o,t);return b({destinationMidPointsDistance:s,destinationLineDistance:r},t)?{source:e,destination:c}:void 0}function F(n,o,t){const i=t.sourceMidPointFunction(n[0].source,n[1].source),e=t.destinationMidPointFunction(n[0].destination,n[1].destination),c=o(i),s=u.distance(e,c),r=u.distance(n[0].destination,n[1].destination);return{sourceMidPoint:i,destinationMidPointFromRefinementFunction:c,destinationMidPointsDistance:s,destinationLineDistance:r}}function b({destinationMidPointsDistance:n,destinationLineDistance:o},t){return n/o>t.minOffsetRatio||n>t.minOffsetDistance}function v(n,o,t){const i=G.bboxToRectangle(n),e=i[2],c=i[3],s=i[1],r=i[0],P=t.sourceMidPointFunction(e,s),S=t.sourceMidPointFunction(c,r),h=t.sourceMidPointFunction(e,c),p=t.sourceMidPointFunction(s,r),L=[[P,S],[h,p]].map(a=>R(a,o,t).map(l=>l.source));if(L.every(a=>a.length==2))return;const g=L.map(a=>a.slice(0,-1).map((l,D)=>u.squaredDistance(l,a[D+1])));return Math.sqrt(Math.min(...g.flat()))}function f(n,o=!1){const t=n.length-(o?0:1),i=[];for(let e=0;e<t;e++)i.push([n[e],n[(e+1)%n.length]]);return i}function M(n,o=!1){const t=n.map(i=>i[0]);return o&&t.push(n[n.length-1][1]),t}exports.defaultRefinementOptions=C;exports.gcpLinesToGcps=M;exports.gcpsToGcpLines=f;exports.getSourceRefinementResolution=v;exports.newMidGcpIfShouldSplitGcpLine=m;exports.refineLineString=R;exports.refineRing=T;
+//# sourceMappingURL=index.cjs419.js.map

package/dist/index.cjs419.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs419.js","sources":["../../../node_modules/@allmaps/transform/dist/shared/refinement-functions.js"],"sourcesContent":["import { midPoint, distance, squaredDistance, conformLineString, conformRing, bboxToRectangle } from '@allmaps/stdlib';\n// About Refinement Functions:\n//\n// Refinement function are used both in forward and backward transformation\n// and are the generalised approach to refine lineStrings, rings etc.\n// when they are transformed using a (forward or backward) 'refinement function'.\n//\n// See the way refinement methods are called:\n// with a different refinementFunction and refinementOptions for the forward and backward case.\n//\n// The concepts of 'source' and 'destination' for refinement methods\n// might therefore differ from the from the transform methods that called them.\n// For forward transform methods, 'source' and 'destination' in the refinement context\n// are the same as in their original transform context.\n// For backward transform methods, they are inversed.\n// Hence, in the refinement contect we always act source > destination.\nexport const defaultRefinementOptions = {\n    maxDepth: 0,\n    minSourceDistance: 0,\n    minDestinationDistance: 0,\n    minOffsetRatio: 0,\n    minOffsetDistance: Infinity,\n    sourceMidPointFunction: midPoint,\n    destinationMidPointFunction: midPoint\n};\n// Refine Geometries\nexport function refineLineString(lineString, refinementFunction, refinementOptions) {\n    lineString = conformLineString(lineString);\n    const gcps = lineString.map((point) => ({\n        source: point,\n        destination: refinementFunction(point)\n    }));\n    const gcpLines = gcpsToGcpLines(gcps, false);\n    const refinedGcpLines = gcpLines\n        .map((gcpLine) => splitGcpLineRecursively(gcpLine, refinementFunction, refinementOptions, 0))\n        .flat(1);\n    return gcpLinesToGcps(refinedGcpLines, true);\n}\nexport function refineRing(ring, refinementFunction, refinementOptions) {\n    ring = conformRing(ring);\n    const gcps = ring.map((point) => ({\n        source: point,\n        destination: refinementFunction(point)\n    }));\n    const gcpLines = gcpsToGcpLines(gcps, true);\n    const refinedGcpLines = gcpLines\n        .map((line) => splitGcpLineRecursively(line, refinementFunction, refinementOptions, 0))\n        .flat(1);\n    return gcpLinesToGcps(refinedGcpLines, false);\n}\nfunction splitGcpLineRecursively(gcpLine, refinementFunction, refinementOptions, depth) {\n    const newMidGcp = newMidGcpIfShouldSplitGcpLine(gcpLine, refinementFunction, refinementOptions, depth);\n    if (newMidGcp) {\n        return [\n            splitGcpLineRecursively([gcpLine[0], newMidGcp], refinementFunction, refinementOptions, depth + 1),\n            splitGcpLineRecursively([newMidGcp, gcpLine[1]], refinementFunction, refinementOptions, depth + 1)\n        ].flat(1);\n    }\n    else {\n        return [gcpLine];\n    }\n}\n// Should split line\n// This function checks if a GcpLine should be splits\n// and returns the new midGcp if so, or undefined otherwise\nexport function newMidGcpIfShouldSplitGcpLine(gcpLine, refinementFunction, refinementOptions, depth) {\n    if (depth >= refinementOptions.maxDepth ||\n        refinementOptions.maxDepth <= 0 ||\n        distance(gcpLine[0].source, gcpLine[1].source) <\n            refinementOptions.minSourceDistance ||\n        distance(gcpLine[0].destination, gcpLine[1].destination) <\n            refinementOptions.minDestinationDistance) {\n        return undefined;\n    }\n    const { sourceMidPoint, destinationMidPointFromRefinementFunction, destinationMidPointsDistance, destinationLineDistance } = splitGcpLinePointInfo(gcpLine, refinementFunction, refinementOptions);\n    const shouldSplit = shouldSplitGcpLine({\n        destinationMidPointsDistance,\n        destinationLineDistance\n    }, refinementOptions);\n    return shouldSplit\n        ? {\n            source: sourceMidPoint,\n            destination: destinationMidPointFromRefinementFunction\n        }\n        : undefined;\n}\nfunction splitGcpLinePointInfo(gcpLine, refinementFunction, refinementOptions) {\n    const sourceMidPoint = refinementOptions.sourceMidPointFunction(gcpLine[0].source, gcpLine[1].source);\n    const destinationMidPoint = refinementOptions.destinationMidPointFunction(gcpLine[0].destination, gcpLine[1].destination);\n    const destinationMidPointFromRefinementFunction = refinementFunction(sourceMidPoint);\n    const destinationMidPointsDistance = distance(destinationMidPoint, destinationMidPointFromRefinementFunction);\n    const destinationLineDistance = distance(gcpLine[0].destination, gcpLine[1].destination);\n    return {\n        sourceMidPoint,\n        destinationMidPointFromRefinementFunction,\n        destinationMidPointsDistance,\n        destinationLineDistance\n    };\n}\nfunction shouldSplitGcpLine({ destinationMidPointsDistance, destinationLineDistance }, refinementOptions) {\n    return (destinationMidPointsDistance / destinationLineDistance >\n        refinementOptions.minOffsetRatio ||\n        destinationMidPointsDistance > refinementOptions.minOffsetDistance);\n}\n// Get source refinement resolution\nexport function getSourceRefinementResolution(sourceBbox, refinementFunction, refinementOptions) {\n    const sourceRectangle = bboxToRectangle(sourceBbox);\n    const sourceTRPoint = sourceRectangle[2];\n    const sourceTLPoint = sourceRectangle[3];\n    const sourceBRPoint = sourceRectangle[1];\n    const sourceBLPoint = sourceRectangle[0];\n    const sourceCRPoint = refinementOptions.sourceMidPointFunction(sourceTRPoint, sourceBRPoint);\n    const sourceCLPoint = refinementOptions.sourceMidPointFunction(sourceTLPoint, sourceBLPoint);\n    const sourceTCPoint = refinementOptions.sourceMidPointFunction(sourceTRPoint, sourceTLPoint);\n    const sourceBCPoint = refinementOptions.sourceMidPointFunction(sourceBRPoint, sourceBLPoint);\n    // Get horizontal and vertical lines from points\n    // Note: Could also add sourceHTLine, sourceHBLine, sourceVLLine, sourceVRLine\n    // to get a more accurate resolution (at the expense of more refinement computations),\n    // but testing showed this was not needed\n    const sourceHCLine = [sourceCRPoint, sourceCLPoint];\n    const sourceVCLine = [sourceTCPoint, sourceBCPoint];\n    const sourceMultiLine = [sourceHCLine, sourceVCLine];\n    // Refine lines\n    const sourceRefinedMultiLineString = sourceMultiLine.map((sourceLine) => refineLineString(sourceLine, refinementFunction, refinementOptions).map((generalGcp) => generalGcp.source));\n    if (sourceRefinedMultiLineString.every((sourceRefinedLineString) => sourceRefinedLineString.length == 2)) {\n        return undefined;\n    }\n    // Compute minimal line length of refinement\n    // Note: Tried to acchieve this by working with unflattened refined line and computing depth\n    // but that proved difficult for TypeScript\n    const sourceRefinedMultiLineStringSquaredLengths = sourceRefinedMultiLineString.map((sourceRefinedLineString) => sourceRefinedLineString\n        .slice(0, -1)\n        .map((sourcePoint, index) => squaredDistance(sourcePoint, sourceRefinedLineString[index + 1])));\n    const sourceRefinedMultiLineStringMinLength = Math.sqrt(Math.min(...sourceRefinedMultiLineStringSquaredLengths.flat()));\n    return sourceRefinedMultiLineStringMinLength;\n}\n// Convert\nexport function gcpsToGcpLines(gcps, close = false) {\n    const lineCount = gcps.length - (close ? 0 : 1);\n    const lines = [];\n    for (let index = 0; index < lineCount; index++) {\n        lines.push([gcps[index], gcps[(index + 1) % gcps.length]]);\n    }\n    return lines;\n}\nexport function gcpLinesToGcps(lines, close = false) {\n    const gcps = lines.map((line) => line[0]);\n    if (close) {\n        gcps.push(lines[lines.length - 1][1]);\n    }\n    return gcps;\n}\n"],"names":["defaultRefinementOptions","midPoint","refineLineString","lineString","refinementFunction","refinementOptions","conformLineString","gcps","point","refinedGcpLines","gcpsToGcpLines","gcpLine","splitGcpLineRecursively","gcpLinesToGcps","refineRing","ring","conformRing","line","depth","newMidGcp","newMidGcpIfShouldSplitGcpLine","distance","sourceMidPoint","destinationMidPointFromRefinementFunction","destinationMidPointsDistance","destinationLineDistance","splitGcpLinePointInfo","shouldSplitGcpLine","destinationMidPoint","getSourceRefinementResolution","sourceBbox","sourceRectangle","bboxToRectangle","sourceTRPoint","sourceTLPoint","sourceBRPoint","sourceBLPoint","sourceCRPoint","sourceCLPoint","sourceTCPoint","sourceBCPoint","sourceRefinedMultiLineString","sourceLine","generalGcp","sourceRefinedLineString","sourceRefinedMultiLineStringSquaredLengths","sourcePoint","index","squaredDistance","close","lineCount","lines"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.cjs42.js

@@ -1,2 +1,2 @@
-"use strict";const r=require("./index.cjs218.js"),t=require("./index.cjs39.js"),e=require("./index.cjs224.js"),i=t.isIE11?e.ie11fingerprint(e.mapMethods):r("Map");module.exports=i;
+"use strict";const r=require("./index.cjs235.js"),t=require("./index.cjs39.js"),e=require("./index.cjs241.js"),i=t.isIE11?e.ie11fingerprint(e.mapMethods):r("Map");module.exports=i;
 //# sourceMappingURL=index.cjs42.js.map

package/dist/index.cjs420.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const e=require("./index.cjs517.js"),t=e.matrixExports.SingularValueDecomposition,r=e.default.Matrix?e.default.Matrix:e.matrixExports.Matrix,i=e.matrixExports.inverse,o=e.matrixExports.pseudoInverse;exports.SingularValueDecomposition=t;exports.default=r;exports.inverse=i;exports.pseudoInverse=o;
+//# sourceMappingURL=index.cjs420.js.map

package/dist/index.cjs420.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs420.js","sources":["../../../node_modules/ml-matrix/matrix.mjs"],"sourcesContent":["import * as matrix from './matrix.js';\n\nexport const AbstractMatrix = matrix.AbstractMatrix;\nexport const CHO = matrix.CHO;\nexport const CholeskyDecomposition = matrix.CholeskyDecomposition;\nexport const DistanceMatrix = matrix.DistanceMatrix;\nexport const EVD = matrix.EVD;\nexport const EigenvalueDecomposition = matrix.EigenvalueDecomposition;\nexport const LU = matrix.LU;\nexport const LuDecomposition = matrix.LuDecomposition;\nexport const Matrix = matrix.Matrix;\nexport const MatrixColumnSelectionView = matrix.MatrixColumnSelectionView;\nexport const MatrixColumnView = matrix.MatrixColumnView;\nexport const MatrixFlipColumnView = matrix.MatrixFlipColumnView;\nexport const MatrixFlipRowView = matrix.MatrixFlipRowView;\nexport const MatrixRowSelectionView = matrix.MatrixRowSelectionView;\nexport const MatrixRowView = matrix.MatrixRowView;\nexport const MatrixSelectionView = matrix.MatrixSelectionView;\nexport const MatrixSubView = matrix.MatrixSubView;\nexport const MatrixTransposeView = matrix.MatrixTransposeView;\nexport const NIPALS = matrix.NIPALS;\nexport const Nipals = matrix.Nipals;\nexport const QR = matrix.QR;\nexport const QrDecomposition = matrix.QrDecomposition;\nexport const SVD = matrix.SVD;\nexport const SingularValueDecomposition = matrix.SingularValueDecomposition;\nexport const SymmetricMatrix = matrix.SymmetricMatrix;\nexport const WrapperMatrix1D = matrix.WrapperMatrix1D;\nexport const WrapperMatrix2D = matrix.WrapperMatrix2D;\nexport const correlation = matrix.correlation;\nexport const covariance = matrix.covariance;\nexport default matrix.default.Matrix ? matrix.default.Matrix : matrix.Matrix;\nexport const determinant = matrix.determinant;\nexport const inverse = matrix.inverse;\nexport const linearDependencies = matrix.linearDependencies;\nexport const pseudoInverse = matrix.pseudoInverse;\nexport const solve = matrix.solve;\nexport const wrap = matrix.wrap;\n"],"names":["SingularValueDecomposition","matrix.SingularValueDecomposition","Matrix","matrix.default","matrix.Matrix","inverse","matrix.inverse","pseudoInverse","matrix.pseudoInverse"],"mappings":"iJAyBaA,EAA6BC,EAAAA,cAAAA,2BAM1CC,EAAeC,EAAAA,QAAe,OAASA,UAAe,OAASC,EAAAA,cAAAA,OAElDC,EAAUC,EAAAA,cAAAA,QAEVC,EAAgBC,EAAAA,cAAAA","x_google_ignoreList":[0]}

package/dist/index.cjs421.js

@@ -0,0 +1,2 @@
+"use strict";const N=require("./index.cjs271.js"),C=Math.pow(2,-52),j=new Uint32Array(512);class Y{static from(t,i=Q,h=V){const o=t.length,l=new Float64Array(o*2);for(let n=0;n<o;n++){const r=t[n];l[2*n]=i(r),l[2*n+1]=h(r)}return new Y(l)}constructor(t){const i=t.length>>1;if(i>0&&typeof t[0]!="number")throw new Error("Expected coords to contain numbers.");this.coords=t;const h=Math.max(2*i-5,0);this._triangles=new Uint32Array(h*3),this._halfedges=new Int32Array(h*3),this._hashSize=Math.ceil(Math.sqrt(i)),this._hullPrev=new Uint32Array(i),this._hullNext=new Uint32Array(i),this._hullTri=new Uint32Array(i),this._hullHash=new Int32Array(this._hashSize),this._ids=new Uint32Array(i),this._dists=new Float64Array(i),this.trianglesLen=0,this._cx=0,this._cy=0,this._hullStart=0,this.hull=this._triangles,this.triangles=this._triangles,this.halfedges=this._halfedges,this.update()}update(){const{coords:t,_hullPrev:i,_hullNext:h,_hullTri:o,_hullHash:l}=this,n=t.length>>1;let r=1/0,f=1/0,g=-1/0,b=-1/0;for(let e=0;e<n;e++){const u=t[2*e],a=t[2*e+1];u<r&&(r=u),a<f&&(f=a),u>g&&(g=u),a>b&&(b=a),this._ids[e]=e}const x=(r+g)/2,m=(f+b)/2;let c=0,y=0,d=0;for(let e=0,u=1/0;e<n;e++){const a=X(x,m,t[2*e],t[2*e+1]);a<u&&(c=e,u=a)}const T=t[2*c],M=t[2*c+1];for(let e=0,u=1/0;e<n;e++){if(e===c)continue;const a=X(T,M,t[2*e],t[2*e+1]);a<u&&a>0&&(y=e,u=a)}let U=t[2*y],k=t[2*y+1],G=1/0;for(let e=0;e<n;e++){if(e===c||e===y)continue;const u=B(T,M,U,k,t[2*e],t[2*e+1]);u<G&&(d=e,G=u)}let D=t[2*d],E=t[2*d+1];if(G===1/0){for(let a=0;a<n;a++)this._dists[a]=t[2*a]-t[0]||t[2*a+1]-t[1];L(this._ids,this._dists,0,n-1);const e=new Uint32Array(n);let u=0;for(let a=0,w=-1/0;a<n;a++){const A=this._ids[a],S=this._dists[A];S>w&&(e[u++]=A,w=S)}this.hull=e.subarray(0,u),this.triangles=new Uint32Array(0),this.halfedges=new Int32Array(0);return}if(N.orient2d(T,M,U,k,D,E)<0){const e=y,u=U,a=k;y=d,U=D,k=E,d=e,D=u,E=a}const v=J(T,M,U,k,D,E);this._cx=v.x,this._cy=v.y;for(let e=0;e<n;e++)this._dists[e]=X(t[2*e],t[2*e+1],v.x,v.y);L(this._ids,this._dists,0,n-1),this._hullStart=c;let P=3;h[c]=i[d]=y,h[y]=i[c]=d,h[d]=i[y]=c,o[c]=0,o[y]=1,o[d]=2,l.fill(-1),l[this._hashKey(T,M)]=c,l[this._hashKey(U,k)]=y,l[this._hashKey(D,E)]=d,this.trianglesLen=0,this._addTriangle(c,y,d,-1,-1,-1);for(let e=0,u=0,a=0;e<this._ids.length;e++){const w=this._ids[e],A=t[2*w],S=t[2*w+1];if(e>0&&Math.abs(A-u)<=C&&Math.abs(S-a)<=C||(u=A,a=S,w===c||w===y||w===d))continue;let z=0;for(let H=0,F=this._hashKey(A,S);H<this._hashSize&&(z=l[(F+H)%this._hashSize],!(z!==-1&&z!==h[z]));H++);z=i[z];let _=z,p;for(;p=h[_],N.orient2d(A,S,t[2*_],t[2*_+1],t[2*p],t[2*p+1])>=0;)if(_=p,_===z){_=-1;break}if(_===-1)continue;let K=this._addTriangle(_,w,h[_],-1,-1,o[_]);o[w]=this._legalize(K+2),o[_]=K,P++;let I=h[_];for(;p=h[I],N.orient2d(A,S,t[2*I],t[2*I+1],t[2*p],t[2*p+1])<0;)K=this._addTriangle(I,w,p,o[w],-1,o[I]),o[w]=this._legalize(K+2),h[I]=I,P--,I=p;if(_===z)for(;p=i[_],N.orient2d(A,S,t[2*p],t[2*p+1],t[2*_],t[2*_+1])<0;)K=this._addTriangle(p,w,_,-1,o[_],o[p]),this._legalize(K+2),o[p]=K,h[_]=_,P--,_=p;this._hullStart=i[w]=_,h[_]=i[I]=w,h[w]=I,l[this._hashKey(A,S)]=w,l[this._hashKey(t[2*_],t[2*_+1])]=_}this.hull=new Uint32Array(P);for(let e=0,u=this._hullStart;e<P;e++)this.hull[e]=u,u=h[u];this.triangles=this._triangles.subarray(0,this.trianglesLen),this.halfedges=this._halfedges.subarray(0,this.trianglesLen)}_hashKey(t,i){return Math.floor(O(t-this._cx,i-this._cy)*this._hashSize)%this._hashSize}_legalize(t){const{_triangles:i,_halfedges:h,coords:o}=this;let l=0,n=0;for(;;){const r=h[t],f=t-t%3;if(n=f+(t+2)%3,r===-1){if(l===0)break;t=j[--l];continue}const g=r-r%3,b=f+(t+1)%3,x=g+(r+2)%3,m=i[n],c=i[t],y=i[b],d=i[x];if(R(o[2*m],o[2*m+1],o[2*c],o[2*c+1],o[2*y],o[2*y+1],o[2*d],o[2*d+1])){i[t]=d,i[r]=m;const M=h[x];if(M===-1){let k=this._hullStart;do{if(this._hullTri[k]===x){this._hullTri[k]=t;break}k=this._hullPrev[k]}while(k!==this._hullStart)}this._link(t,M),this._link(r,h[n]),this._link(n,x);const U=g+(r+1)%3;l<j.length&&(j[l++]=U)}else{if(l===0)break;t=j[--l]}}return n}_link(t,i){this._halfedges[t]=i,i!==-1&&(this._halfedges[i]=t)}_addTriangle(t,i,h,o,l,n){const r=this.trianglesLen;return this._triangles[r]=t,this._triangles[r+1]=i,this._triangles[r+2]=h,this._link(r,o),this._link(r+1,l),this._link(r+2,n),this.trianglesLen+=3,r}}function O(s,t){const i=s/(Math.abs(s)+Math.abs(t));return(t>0?3-i:1+i)/4}function X(s,t,i,h){const o=s-i,l=t-h;return o*o+l*l}function R(s,t,i,h,o,l,n,r){const f=s-n,g=t-r,b=i-n,x=h-r,m=o-n,c=l-r,y=f*f+g*g,d=b*b+x*x,T=m*m+c*c;return f*(x*T-d*c)-g*(b*T-d*m)+y*(b*c-x*m)<0}function B(s,t,i,h,o,l){const n=i-s,r=h-t,f=o-s,g=l-t,b=n*n+r*r,x=f*f+g*g,m=.5/(n*g-r*f),c=(g*b-r*x)*m,y=(n*x-f*b)*m;return c*c+y*y}function J(s,t,i,h,o,l){const n=i-s,r=h-t,f=o-s,g=l-t,b=n*n+r*r,x=f*f+g*g,m=.5/(n*g-r*f),c=s+(g*b-r*x)*m,y=t+(n*x-f*b)*m;return{x:c,y}}function L(s,t,i,h){if(h-i<=20)for(let o=i+1;o<=h;o++){const l=s[o],n=t[l];let r=o-1;for(;r>=i&&t[s[r]]>n;)s[r+1]=s[r--];s[r+1]=l}else{const o=i+h>>1;let l=i+1,n=h;q(s,o,l),t[s[i]]>t[s[h]]&&q(s,i,h),t[s[l]]>t[s[h]]&&q(s,l,h),t[s[i]]>t[s[l]]&&q(s,i,l);const r=s[l],f=t[r];for(;;){do l++;while(t[s[l]]<f);do n--;while(t[s[n]]>f);if(n<l)break;q(s,l,n)}s[i+1]=s[n],s[n]=r,h-l+1>=n-i?(L(s,t,l,h),L(s,t,i,n-1)):(L(s,t,i,n-1),L(s,t,l,h))}}function q(s,t,i){const h=s[t];s[t]=s[i],s[i]=h}function Q(s){return s[0]}function V(s){return s[1]}module.exports=Y;
+//# sourceMappingURL=index.cjs421.js.map

package/dist/index.cjs421.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs421.js","sources":["../../../node_modules/delaunator/index.js"],"sourcesContent":["\nconst EPSILON = Math.pow(2, -52);\nconst EDGE_STACK = new Uint32Array(512);\n\nimport {orient2d} from 'robust-predicates';\n\n/** @template {ArrayLike<number>} T */\nexport default class Delaunator {\n\n    /**\n     * Constructs a delaunay triangulation object given an array of points (`[x, y]` by default).\n     * `getX` and `getY` are optional functions of the form `(point) => value` for custom point formats.\n     *\n     * @template P\n     * @param {P[]} points\n     * @param {(p: P) => number} [getX]\n     * @param {(p: P) => number} [getY]\n     */\n    // @ts-expect-error TS2322\n    static from(points, getX = defaultGetX, getY = defaultGetY) {\n        const n = points.length;\n        const coords = new Float64Array(n * 2);\n\n        for (let i = 0; i < n; i++) {\n            const p = points[i];\n            coords[2 * i] = getX(p);\n            coords[2 * i + 1] = getY(p);\n        }\n\n        return new Delaunator(coords);\n    }\n\n    /**\n     * Constructs a delaunay triangulation object given an array of point coordinates of the form:\n     * `[x0, y0, x1, y1, ...]` (use a typed array for best performance). Duplicate points are skipped.\n     *\n     * @param {T} coords\n     */\n    constructor(coords) {\n        const n = coords.length >> 1;\n        if (n > 0 && typeof coords[0] !== 'number') throw new Error('Expected coords to contain numbers.');\n\n        this.coords = coords;\n\n        // arrays that will store the triangulation graph\n        const maxTriangles = Math.max(2 * n - 5, 0);\n        /** @private */ this._triangles = new Uint32Array(maxTriangles * 3);\n        /** @private */ this._halfedges = new Int32Array(maxTriangles * 3);\n\n        // temporary arrays for tracking the edges of the advancing convex hull\n        /** @private */ this._hashSize = Math.ceil(Math.sqrt(n));\n        /** @private */ this._hullPrev = new Uint32Array(n); // edge to prev edge\n        /** @private */ this._hullNext = new Uint32Array(n); // edge to next edge\n        /** @private */ this._hullTri = new Uint32Array(n); // edge to adjacent triangle\n        /** @private */ this._hullHash = new Int32Array(this._hashSize); // angular edge hash\n\n        // temporary arrays for sorting points\n        /** @private */ this._ids = new Uint32Array(n);\n        /** @private */ this._dists = new Float64Array(n);\n\n        /** @private */ this.trianglesLen = 0;\n        /** @private */ this._cx = 0;\n        /** @private */ this._cy = 0;\n        /** @private */ this._hullStart = 0;\n\n\n        /** A `Uint32Array` array of indices that reference points on the convex hull of the input data, counter-clockwise. */\n        this.hull = this._triangles;\n        /** A `Uint32Array` array of triangle vertex indices (each group of three numbers forms a triangle). All triangles are directed counterclockwise. */\n        this.triangles = this._triangles;\n        /**\n         * A `Int32Array` array of triangle half-edge indices that allows you to traverse the triangulation.\n         * `i`-th half-edge in the array corresponds to vertex `triangles[i]` the half-edge is coming from.\n         * `halfedges[i]` is the index of a twin half-edge in an adjacent triangle (or `-1` for outer half-edges on the convex hull).\n         */\n        this.halfedges = this._halfedges;\n\n        this.update();\n    }\n\n    /**\n     * Updates the triangulation if you modified `delaunay.coords` values in place, avoiding expensive memory allocations.\n     * Useful for iterative relaxation algorithms such as Lloyd's.\n     */\n    update() {\n        const {coords, _hullPrev: hullPrev, _hullNext: hullNext, _hullTri: hullTri, _hullHash: hullHash} =  this;\n        const n = coords.length >> 1;\n\n        // populate an array of point indices; calculate input data bbox\n        let minX = Infinity;\n        let minY = Infinity;\n        let maxX = -Infinity;\n        let maxY = -Infinity;\n\n        for (let i = 0; i < n; i++) {\n            const x = coords[2 * i];\n            const y = coords[2 * i + 1];\n            if (x < minX) minX = x;\n            if (y < minY) minY = y;\n            if (x > maxX) maxX = x;\n            if (y > maxY) maxY = y;\n            this._ids[i] = i;\n        }\n        const cx = (minX + maxX) / 2;\n        const cy = (minY + maxY) / 2;\n\n        let i0 = 0, i1 = 0, i2 = 0;\n\n        // pick a seed point close to the center\n        for (let i = 0, minDist = Infinity; i < n; i++) {\n            const d = dist(cx, cy, coords[2 * i], coords[2 * i + 1]);\n            if (d < minDist) {\n                i0 = i;\n                minDist = d;\n            }\n        }\n        const i0x = coords[2 * i0];\n        const i0y = coords[2 * i0 + 1];\n\n        // find the point closest to the seed\n        for (let i = 0, minDist = Infinity; i < n; i++) {\n            if (i === i0) continue;\n            const d = dist(i0x, i0y, coords[2 * i], coords[2 * i + 1]);\n            if (d < minDist && d > 0) {\n                i1 = i;\n                minDist = d;\n            }\n        }\n        let i1x = coords[2 * i1];\n        let i1y = coords[2 * i1 + 1];\n\n        let minRadius = Infinity;\n\n        // find the third point which forms the smallest circumcircle with the first two\n        for (let i = 0; i < n; i++) {\n            if (i === i0 || i === i1) continue;\n            const r = circumradius(i0x, i0y, i1x, i1y, coords[2 * i], coords[2 * i + 1]);\n            if (r < minRadius) {\n                i2 = i;\n                minRadius = r;\n            }\n        }\n        let i2x = coords[2 * i2];\n        let i2y = coords[2 * i2 + 1];\n\n        if (minRadius === Infinity) {\n            // order collinear points by dx (or dy if all x are identical)\n            // and return the list as a hull\n            for (let i = 0; i < n; i++) {\n                this._dists[i] = (coords[2 * i] - coords[0]) || (coords[2 * i + 1] - coords[1]);\n            }\n            quicksort(this._ids, this._dists, 0, n - 1);\n            const hull = new Uint32Array(n);\n            let j = 0;\n            for (let i = 0, d0 = -Infinity; i < n; i++) {\n                const id = this._ids[i];\n                const d = this._dists[id];\n                if (d > d0) {\n                    hull[j++] = id;\n                    d0 = d;\n                }\n            }\n            this.hull = hull.subarray(0, j);\n            this.triangles = new Uint32Array(0);\n            this.halfedges = new Int32Array(0);\n            return;\n        }\n\n        // swap the order of the seed points for counter-clockwise orientation\n        if (orient2d(i0x, i0y, i1x, i1y, i2x, i2y) < 0) {\n            const i = i1;\n            const x = i1x;\n            const y = i1y;\n            i1 = i2;\n            i1x = i2x;\n            i1y = i2y;\n            i2 = i;\n            i2x = x;\n            i2y = y;\n        }\n\n        const center = circumcenter(i0x, i0y, i1x, i1y, i2x, i2y);\n        this._cx = center.x;\n        this._cy = center.y;\n\n        for (let i = 0; i < n; i++) {\n            this._dists[i] = dist(coords[2 * i], coords[2 * i + 1], center.x, center.y);\n        }\n\n        // sort the points by distance from the seed triangle circumcenter\n        quicksort(this._ids, this._dists, 0, n - 1);\n\n        // set up the seed triangle as the starting hull\n        this._hullStart = i0;\n        let hullSize = 3;\n\n        hullNext[i0] = hullPrev[i2] = i1;\n        hullNext[i1] = hullPrev[i0] = i2;\n        hullNext[i2] = hullPrev[i1] = i0;\n\n        hullTri[i0] = 0;\n        hullTri[i1] = 1;\n        hullTri[i2] = 2;\n\n        hullHash.fill(-1);\n        hullHash[this._hashKey(i0x, i0y)] = i0;\n        hullHash[this._hashKey(i1x, i1y)] = i1;\n        hullHash[this._hashKey(i2x, i2y)] = i2;\n\n        this.trianglesLen = 0;\n        this._addTriangle(i0, i1, i2, -1, -1, -1);\n\n        for (let k = 0, xp = 0, yp = 0; k < this._ids.length; k++) {\n            const i = this._ids[k];\n            const x = coords[2 * i];\n            const y = coords[2 * i + 1];\n\n            // skip near-duplicate points\n            if (k > 0 && Math.abs(x - xp) <= EPSILON && Math.abs(y - yp) <= EPSILON) continue;\n            xp = x;\n            yp = y;\n\n            // skip seed triangle points\n            if (i === i0 || i === i1 || i === i2) continue;\n\n            // find a visible edge on the convex hull using edge hash\n            let start = 0;\n            for (let j = 0, key = this._hashKey(x, y); j < this._hashSize; j++) {\n                start = hullHash[(key + j) % this._hashSize];\n                if (start !== -1 && start !== hullNext[start]) break;\n            }\n\n            start = hullPrev[start];\n            let e = start, q;\n            while (q = hullNext[e], orient2d(x, y, coords[2 * e], coords[2 * e + 1], coords[2 * q], coords[2 * q + 1]) >= 0) {\n                e = q;\n                if (e === start) {\n                    e = -1;\n                    break;\n                }\n            }\n            if (e === -1) continue; // likely a near-duplicate point; skip it\n\n            // add the first triangle from the point\n            let t = this._addTriangle(e, i, hullNext[e], -1, -1, hullTri[e]);\n\n            // recursively flip triangles from the point until they satisfy the Delaunay condition\n            hullTri[i] = this._legalize(t + 2);\n            hullTri[e] = t; // keep track of boundary triangles on the hull\n            hullSize++;\n\n            // walk forward through the hull, adding more triangles and flipping recursively\n            let n = hullNext[e];\n            while (q = hullNext[n], orient2d(x, y, coords[2 * n], coords[2 * n + 1], coords[2 * q], coords[2 * q + 1]) < 0) {\n                t = this._addTriangle(n, i, q, hullTri[i], -1, hullTri[n]);\n                hullTri[i] = this._legalize(t + 2);\n                hullNext[n] = n; // mark as removed\n                hullSize--;\n                n = q;\n            }\n\n            // walk backward from the other side, adding more triangles and flipping\n            if (e === start) {\n                while (q = hullPrev[e], orient2d(x, y, coords[2 * q], coords[2 * q + 1], coords[2 * e], coords[2 * e + 1]) < 0) {\n                    t = this._addTriangle(q, i, e, -1, hullTri[e], hullTri[q]);\n                    this._legalize(t + 2);\n                    hullTri[q] = t;\n                    hullNext[e] = e; // mark as removed\n                    hullSize--;\n                    e = q;\n                }\n            }\n\n            // update the hull indices\n            this._hullStart = hullPrev[i] = e;\n            hullNext[e] = hullPrev[n] = i;\n            hullNext[i] = n;\n\n            // save the two new edges in the hash table\n            hullHash[this._hashKey(x, y)] = i;\n            hullHash[this._hashKey(coords[2 * e], coords[2 * e + 1])] = e;\n        }\n\n        this.hull = new Uint32Array(hullSize);\n        for (let i = 0, e = this._hullStart; i < hullSize; i++) {\n            this.hull[i] = e;\n            e = hullNext[e];\n        }\n\n        // trim typed triangle mesh arrays\n        this.triangles = this._triangles.subarray(0, this.trianglesLen);\n        this.halfedges = this._halfedges.subarray(0, this.trianglesLen);\n    }\n\n    /**\n     * Calculate an angle-based key for the edge hash used for advancing convex hull.\n     *\n     * @param {number} x\n     * @param {number} y\n     * @private\n     */\n    _hashKey(x, y) {\n        return Math.floor(pseudoAngle(x - this._cx, y - this._cy) * this._hashSize) % this._hashSize;\n    }\n\n    /**\n     * Flip an edge in a pair of triangles if it doesn't satisfy the Delaunay condition.\n     *\n     * @param {number} a\n     * @private\n     */\n    _legalize(a) {\n        const {_triangles: triangles, _halfedges: halfedges, coords} = this;\n\n        let i = 0;\n        let ar = 0;\n\n        // recursion eliminated with a fixed-size stack\n        while (true) {\n            const b = halfedges[a];\n\n            /* if the pair of triangles doesn't satisfy the Delaunay condition\n             * (p1 is inside the circumcircle of [p0, pl, pr]), flip them,\n             * then do the same check/flip recursively for the new pair of triangles\n             *\n             *           pl                    pl\n             *          /||\\                  /  \\\n             *       al/ || \\bl            al/    \\a\n             *        /  ||  \\              /      \\\n             *       /  a||b  \\    flip    /___ar___\\\n             *     p0\\   ||   /p1   =>   p0\\---bl---/p1\n             *        \\  ||  /              \\      /\n             *       ar\\ || /br             b\\    /br\n             *          \\||/                  \\  /\n             *           pr                    pr\n             */\n            const a0 = a - a % 3;\n            ar = a0 + (a + 2) % 3;\n\n            if (b === -1) { // convex hull edge\n                if (i === 0) break;\n                a = EDGE_STACK[--i];\n                continue;\n            }\n\n            const b0 = b - b % 3;\n            const al = a0 + (a + 1) % 3;\n            const bl = b0 + (b + 2) % 3;\n\n            const p0 = triangles[ar];\n            const pr = triangles[a];\n            const pl = triangles[al];\n            const p1 = triangles[bl];\n\n            const illegal = inCircle(\n                coords[2 * p0], coords[2 * p0 + 1],\n                coords[2 * pr], coords[2 * pr + 1],\n                coords[2 * pl], coords[2 * pl + 1],\n                coords[2 * p1], coords[2 * p1 + 1]);\n\n            if (illegal) {\n                triangles[a] = p1;\n                triangles[b] = p0;\n\n                const hbl = halfedges[bl];\n\n                // edge swapped on the other side of the hull (rare); fix the half-edge reference\n                if (hbl === -1) {\n                    let e = this._hullStart;\n                    do {\n                        if (this._hullTri[e] === bl) {\n                            this._hullTri[e] = a;\n                            break;\n                        }\n                        e = this._hullPrev[e];\n                    } while (e !== this._hullStart);\n                }\n                this._link(a, hbl);\n                this._link(b, halfedges[ar]);\n                this._link(ar, bl);\n\n                const br = b0 + (b + 1) % 3;\n\n                // don't worry about hitting the cap: it can only happen on extremely degenerate input\n                if (i < EDGE_STACK.length) {\n                    EDGE_STACK[i++] = br;\n                }\n            } else {\n                if (i === 0) break;\n                a = EDGE_STACK[--i];\n            }\n        }\n\n        return ar;\n    }\n\n    /**\n     * Link two half-edges to each other.\n     * @param {number} a\n     * @param {number} b\n     * @private\n     */\n    _link(a, b) {\n        this._halfedges[a] = b;\n        if (b !== -1) this._halfedges[b] = a;\n    }\n\n    /**\n     * Add a new triangle given vertex indices and adjacent half-edge ids.\n     *\n     * @param {number} i0\n     * @param {number} i1\n     * @param {number} i2\n     * @param {number} a\n     * @param {number} b\n     * @param {number} c\n     * @private\n     */\n    _addTriangle(i0, i1, i2, a, b, c) {\n        const t = this.trianglesLen;\n\n        this._triangles[t] = i0;\n        this._triangles[t + 1] = i1;\n        this._triangles[t + 2] = i2;\n\n        this._link(t, a);\n        this._link(t + 1, b);\n        this._link(t + 2, c);\n\n        this.trianglesLen += 3;\n\n        return t;\n    }\n}\n\n/**\n * Monotonically increases with real angle, but doesn't need expensive trigonometry.\n *\n * @param {number} dx\n * @param {number} dy\n */\nfunction pseudoAngle(dx, dy) {\n    const p = dx / (Math.abs(dx) + Math.abs(dy));\n    return (dy > 0 ? 3 - p : 1 + p) / 4; // [0..1]\n}\n\n/**\n * Squared distance between two points.\n *\n * @param {number} ax\n * @param {number} ay\n * @param {number} bx\n * @param {number} by\n */\nfunction dist(ax, ay, bx, by) {\n    const dx = ax - bx;\n    const dy = ay - by;\n    return dx * dx + dy * dy;\n}\n\n/**\n * Check whether point P is inside a circle formed by points A, B, C.\n *\n * @param {number} ax\n * @param {number} ay\n * @param {number} bx\n * @param {number} by\n * @param {number} cx\n * @param {number} cy\n * @param {number} px\n * @param {number} py\n */\nfunction inCircle(ax, ay, bx, by, cx, cy, px, py) {\n    const dx = ax - px;\n    const dy = ay - py;\n    const ex = bx - px;\n    const ey = by - py;\n    const fx = cx - px;\n    const fy = cy - py;\n\n    const ap = dx * dx + dy * dy;\n    const bp = ex * ex + ey * ey;\n    const cp = fx * fx + fy * fy;\n\n    return dx * (ey * cp - bp * fy) -\n           dy * (ex * cp - bp * fx) +\n           ap * (ex * fy - ey * fx) < 0;\n}\n\n/**\n * Squared radius of the circle formed by points A, B, C.\n *\n * @param {number} ax\n * @param {number} ay\n * @param {number} bx\n * @param {number} by\n * @param {number} cx\n * @param {number} cy\n */\nfunction circumradius(ax, ay, bx, by, cx, cy) {\n    const dx = bx - ax;\n    const dy = by - ay;\n    const ex = cx - ax;\n    const ey = cy - ay;\n\n    const bl = dx * dx + dy * dy;\n    const cl = ex * ex + ey * ey;\n    const d = 0.5 / (dx * ey - dy * ex);\n\n    const x = (ey * bl - dy * cl) * d;\n    const y = (dx * cl - ex * bl) * d;\n\n    return x * x + y * y;\n}\n\n/**\n * Get coordinates of a circumcenter for points A, B, C.\n *\n * @param {number} ax\n * @param {number} ay\n * @param {number} bx\n * @param {number} by\n * @param {number} cx\n * @param {number} cy\n */\nfunction circumcenter(ax, ay, bx, by, cx, cy) {\n    const dx = bx - ax;\n    const dy = by - ay;\n    const ex = cx - ax;\n    const ey = cy - ay;\n\n    const bl = dx * dx + dy * dy;\n    const cl = ex * ex + ey * ey;\n    const d = 0.5 / (dx * ey - dy * ex);\n\n    const x = ax + (ey * bl - dy * cl) * d;\n    const y = ay + (dx * cl - ex * bl) * d;\n\n    return {x, y};\n}\n\n/**\n * Sort points by distance via an array of point indices and an array of calculated distances.\n *\n * @param {Uint32Array} ids\n * @param {Float64Array} dists\n * @param {number} left\n * @param {number} right\n */\nfunction quicksort(ids, dists, left, right) {\n    if (right - left <= 20) {\n        for (let i = left + 1; i <= right; i++) {\n            const temp = ids[i];\n            const tempDist = dists[temp];\n            let j = i - 1;\n            while (j >= left && dists[ids[j]] > tempDist) ids[j + 1] = ids[j--];\n            ids[j + 1] = temp;\n        }\n    } else {\n        const median = (left + right) >> 1;\n        let i = left + 1;\n        let j = right;\n        swap(ids, median, i);\n        if (dists[ids[left]] > dists[ids[right]]) swap(ids, left, right);\n        if (dists[ids[i]] > dists[ids[right]]) swap(ids, i, right);\n        if (dists[ids[left]] > dists[ids[i]]) swap(ids, left, i);\n\n        const temp = ids[i];\n        const tempDist = dists[temp];\n        while (true) {\n            do i++; while (dists[ids[i]] < tempDist);\n            do j--; while (dists[ids[j]] > tempDist);\n            if (j < i) break;\n            swap(ids, i, j);\n        }\n        ids[left + 1] = ids[j];\n        ids[j] = temp;\n\n        if (right - i + 1 >= j - left) {\n            quicksort(ids, dists, i, right);\n            quicksort(ids, dists, left, j - 1);\n        } else {\n            quicksort(ids, dists, left, j - 1);\n            quicksort(ids, dists, i, right);\n        }\n    }\n}\n\n/**\n * @param {Uint32Array} arr\n * @param {number} i\n * @param {number} j\n */\nfunction swap(arr, i, j) {\n    const tmp = arr[i];\n    arr[i] = arr[j];\n    arr[j] = tmp;\n}\n\n/** @param {[number, number]} p */\nfunction defaultGetX(p) {\n    return p[0];\n}\n/** @param {[number, number]} p */\nfunction defaultGetY(p) {\n    return p[1];\n}\n"],"names":["EPSILON","EDGE_STACK","Delaunator","points","getX","defaultGetX","getY","defaultGetY","n","coords","i","p","maxTriangles","hullPrev","hullNext","hullTri","hullHash","minX","minY","maxX","maxY","x","y","cx","cy","i0","i1","i2","minDist","d","dist","i0x","i0y","i1x","i1y","minRadius","r","circumradius","i2x","i2y","quicksort","hull","j","d0","id","orient2d","center","circumcenter","hullSize","k","xp","yp","start","key","e","q","t","pseudoAngle","a","triangles","halfedges","ar","b","a0","b0","al","bl","p0","pr","pl","p1","inCircle","hbl","br","c","dx","dy","ax","ay","bx","by","px","py","ex","ey","fx","fy","ap","bp","cp","cl","ids","dists","left","right","temp","tempDist","median","swap","arr","tmp"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.cjs422.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const x=require("./index.cjs513.js"),M=require("./index.cjs514.js"),q=require("./index.cjs215.js"),p=require("./index.cjs274.js");function P(n,e,o=!0){const[t,s]=n,[[r,i],[c,l]]=e;return o&&(t===r&&s===i||t===c&&s===l)||(t-r)*(t-c)>0||(s-i)*(s-l)>0?!1:x.orient2d(r,i,c,l,t,s)===0}function y(n){const e=new M(n.length);for(const[o,t]of n)e.add(o,t);return e.finish(),{tree:e,points:n}}function m(n,{tree:e,points:o}){const t=[];for(let s=0;s<n.length;s++){const r=n[s],i=n[(s+1)%n.length],[c,l]=r,[a,g]=i;t.push(r);const d=e.range(Math.min(c,a),Math.min(l,g),Math.max(c,a),Math.max(l,g));if(d.length===0)continue;const f=[];for(const u of d){const[h,b]=o[u];P([h,b],[r,i])&&f.push(o[u])}f.length===1?t.push(f[0]):f.length>1&&(f.sort(([u,h],[b,L])=>(u-c)**2+(h-l)**2-((b-c)**2+(L-l)**2)),t.push(...f))}return t}function D(n,e,o=y(e)){return n.map(t=>m(t,o))}function k(n,e){const o=p.distance(...n),t=Math.ceil(o/e)-1,s=p.lineAngle(n);let r=n[0];const i=[r];for(let c=1;c<=t;c++)r=p.stepDistanceAngle(r,e,s),i.push(r);return i}function R(n,e){n=p.closeRing(n);let o=[];for(let t=0;t<n.length-1;t++)o=o.concat(k([n[t],n[t+1]],e));return o}function v(n,e){return n.map(o=>R(o,e))}function A(n,e){const o=[];for(let t=n[0]+e,s=0;t<=n[2];s++,t+=e)for(let r=n[1]+e,i=0;r<=n[3];i++,r+=e)o.push([t,r]);return o}function B(n){const e=n.map(t=>{const s=p.closeRing(t),r=s.length-1,i=new Float64Array(s.length*2);for(let c=0;c<s.length;c++)i[c*2]=s[c][0],i[c*2+1]=s[c][1];return{coords:i,length:r}}),o=q.computeBbox(n);return{closedRings:e,bbox:o}}function I(n,e,o){if(n<o.bbox[0]||e<o.bbox[1]||n>o.bbox[2]||e>o.bbox[3])return!1;let t=0;const s=o.closedRings;for(let r=0;r<s.length;r++){const i=s[r].coords,c=s[r].length;let l=i[0]-n,a=i[1]-e;for(let g=0;g<c;g++){const d=(g+1)*2,f=i[d]-n,u=i[d+1]-e;if(a===0&&u===0){if(f<=0&&l>=0||l<=0&&f>=0)return 0}else if(u>=0&&a<=0||u<=0&&a>=0){const h=x.orient2d(l,f,a,u,0,0);if(h===0)return 0;(h>0&&u>0&&a<=0||h<0&&u<=0&&a>0)&&t++}l=f,a=u}}return t%2!==0}function F(n,e,o){return o.some(t=>I(n,e,t))}exports.bboxToGridPoints=A;exports.buildKDBushPointIndex=y;exports.coordsInPolygonForInsidenessCheck=I;exports.coordsInPolygonsForInsidenessCheck=F;exports.interpolatePolygon=v;exports.interpolateRing=R;exports.pointOnLine=P;exports.preprocessPolygonForInsideCheck=B;exports.splitPolygonLines=D;exports.splitRingLines=m;
+//# sourceMappingURL=index.cjs422.js.map