@allmaps/transform/dist/shared/transform-functions.js

Coordinate transformation functions

// TODO: consider implementing these functions in stdlib instead of using dependencies
import getWorldMidpoint from '@turf/midpoint';
import getWorldDistance from '@turf/distance';
import { mergeOptions } from '@allmaps/stdlib';
import { defaultRefinementOptions } from './refinement-functions.js';
// Options
export const defaultGeneralGcpTransformOptions = {
    maxDepth: 0,
    minOffsetRatio: 0,
    minOffsetDistance: Infinity,
    minLineDistance: Infinity,
    sourceIsGeographic: false,
    destinationIsGeographic: false,
    isMultiGeometry: false,
    distortionMeasures: [],
    referenceScale: 1,
    preForward: (point) => point,
    postForward: (point) => point,
    preBackward: (point) => point,
    postBackward: (point) => point
};
export const defaultGeneralGcpTransformerOptions = {
    differentHandedness: false,
    ...defaultGeneralGcpTransformOptions
};
export function gcpTransformOptionsToGeneralGcpTransformOptions(gcpTransformOptions) {
    if (gcpTransformOptions === undefined) {
        return {};
    }
    const generalGcpTransformOptions = gcpTransformOptions;
    if (gcpTransformOptions.geoIsGeographic) {
        generalGcpTransformOptions.destinationIsGeographic =
            gcpTransformOptions.geoIsGeographic;
    }
    if (gcpTransformOptions.postToGeo) {
        generalGcpTransformOptions.postForward = gcpTransformOptions.postToGeo;
    }
    if (gcpTransformOptions.preToResource) {
        generalGcpTransformOptions.preBackward = gcpTransformOptions.preToResource;
    }
    return generalGcpTransformOptions;
}
export function gcpTransformerOptionsToGeneralGcpTransformerOptions(gcpTransformerOptions) {
    if (gcpTransformerOptions === undefined) {
        return {};
    }
    // Note: None of the transformer options need to be adapted
    // only the transform options that could be included in them
    const generalGcpTransformerOptions = gcpTransformOptionsToGeneralGcpTransformOptions(gcpTransformerOptions);
    return generalGcpTransformerOptions;
}
export function generalGcpTransformOptionsToGcpTransformOptions(generalGcpTransformOptions) {
    if (generalGcpTransformOptions === undefined) {
        return {};
    }
    const gcpTransformOptions = generalGcpTransformOptions;
    if (generalGcpTransformOptions.destinationIsGeographic) {
        gcpTransformOptions.geoIsGeographic =
            generalGcpTransformOptions.destinationIsGeographic;
    }
    if (generalGcpTransformOptions.postForward) {
        gcpTransformOptions.postToGeo = generalGcpTransformOptions.postForward;
    }
    if (generalGcpTransformOptions.preBackward) {
        gcpTransformOptions.preToResource = generalGcpTransformOptions.preBackward;
    }
    return gcpTransformOptions;
}
export function generalGcpTransformerOptionsToGcpTransformerOptions(generalGcpTransformerOptions) {
    if (generalGcpTransformerOptions == undefined) {
        return {};
    }
    const gcpTransformerOptions = generalGcpTransformerOptions;
    return gcpTransformerOptions;
}
export const defaultGcpTransformOptions = generalGcpTransformOptionsToGcpTransformOptions(defaultGeneralGcpTransformOptions);
export const defaultGcpTransformerOptions = generalGcpTransformerOptionsToGcpTransformerOptions(defaultGeneralGcpTransformerOptions);
export function refinementOptionsFromForwardTransformOptions(generalGcpTransformOptions) {
    const refinementOptions = mergeOptions(defaultRefinementOptions, {
        minOffsetRatio: generalGcpTransformOptions.minOffsetRatio,
        minOffsetDistance: generalGcpTransformOptions.minOffsetDistance,
        minLineDistance: generalGcpTransformOptions.minLineDistance,
        maxDepth: generalGcpTransformOptions.maxDepth
    });
    if (generalGcpTransformOptions.sourceIsGeographic) {
        refinementOptions.sourceMidPointFunction = (point0, point1) => getWorldMidpoint(point0, point1).geometry.coordinates;
    }
    if (generalGcpTransformOptions.destinationIsGeographic) {
        refinementOptions.destinationMidPointFunction = (point0, point1) => getWorldMidpoint(point0, point1).geometry.coordinates;
        refinementOptions.destinationDistanceFunction = getWorldDistance;
    }
    return refinementOptions;
}
export function refinementOptionsFromBackwardTransformOptions(generalGcpTransformOptions) {
    const refinementOptions = mergeOptions(defaultRefinementOptions, {
        minOffsetRatio: generalGcpTransformOptions.minOffsetRatio,
        minOffsetDistance: generalGcpTransformOptions.minOffsetDistance,
        minLineDistance: generalGcpTransformOptions.minLineDistance,
        maxDepth: generalGcpTransformOptions.maxDepth
    });
    if (generalGcpTransformOptions.destinationIsGeographic) {
        refinementOptions.sourceMidPointFunction = (point0, point1) => getWorldMidpoint(point0, point1).geometry.coordinates;
    }
    if (generalGcpTransformOptions.sourceIsGeographic) {
        refinementOptions.destinationMidPointFunction = (point0, point1) => getWorldMidpoint(point0, point1).geometry.coordinates;
        refinementOptions.destinationDistanceFunction = getWorldDistance;
    }
    return refinementOptions;
}