@igo2/geo 1.12.1 → 1.13.0-alpha.0

package/esm2020/lib/map/shared/map.utils.mjs

@@ -0,0 +1,459 @@
+import * as olproj from 'ol/proj';
+import { MAC } from 'ol/has';
+import { NumberUtils } from '@igo2/utils';
+/**
+ * This method extracts a coordinate tuple from a string.
+ * @param str Any string
+ * @param mapProjection string Map Projection
+ * @param opts.forceNA boolean Force North America Zone
+ * @returns object:
+ *             lonLat: Coordinate,
+ *             message: Message of error,
+ *             radius: radius of the confience of coordinate,
+ *             conf: confidence of the coordinate}
+ */
+export function stringToLonLat(str, mapProjection, opts = {}) {
+    let lonLat;
+    let coordStr;
+    let negativeLon;
+    let degreesLon;
+    let minutesLon;
+    let secondsLon;
+    let directionLon;
+    let decimalLon;
+    let negativeLat;
+    let degreesLat;
+    let minutesLat;
+    let secondsLat;
+    let directionLat;
+    let decimalLat;
+    let zone;
+    let radius;
+    let conf;
+    let lon;
+    let lat;
+    const projectionPattern = '(\\s*;\\s*[\\d]{4,6})';
+    const toProjection = '4326';
+    let projectionStr;
+    const projectionRegex = new RegExp(projectionPattern, 'g');
+    const lonlatCoord = '([-+])?([\\d]{1,3})([,.](\\d+))?';
+    const lonLatPattern = `${lonlatCoord}[\\s,]+${lonlatCoord}`;
+    const lonLatRegex = new RegExp(`^${lonLatPattern}$`, 'g');
+    const dmsCoord = '([0-9]{1,2})[:|°]?\\s*([0-9]{1,2})?[:|\'|′|’]?\\s*([0-9]{1,2}(?:.[0-9]+){0,1})?\\s*["|″|”]?\\s*';
+    const dmsCoordPattern = `${dmsCoord}([N|S|E|W|O]),?\\s*${dmsCoord}([N|S|E|W|O])`;
+    const dmsRegex = new RegExp(`^${dmsCoordPattern}$`, 'gi');
+    const patternUtm = '(UTM)-?(\\d{1,2})[\\s,]*(\\d+[.,]?\\d+)[\\s,]+(\\d+[.,]?\\d+)';
+    const utmRegex = new RegExp(`^${patternUtm}`, 'gi');
+    const patternMtm = '(MTM)-?(\\d{1,2})[\\s,]*(\\d+[.,]?\\d+)[\\s,]+(\\d+[.,]?\\d+)';
+    const mtmRegex = new RegExp(`^${patternMtm}`, 'gi');
+    const ddCoord = '([-+])?(\\d{1,3})[,.](\\d+)';
+    const patternDd = `${ddCoord}\\s*[,]?\\s*${ddCoord}`;
+    const ddRegex = new RegExp(`^${patternDd}`, 'g');
+    const dmdCoord = '([-+])?(\\d{1,3})[\\s,.]{1}(\\d{1,2})[\\s,.]{1}(\\d{1,2})[.,]?(\\d{1,5})?';
+    const patternDmd = `${dmdCoord}\\s*[,.]?\\s*${dmdCoord}`;
+    const dmdRegex = new RegExp(`^${patternDmd}`, 'g');
+    /* eslint-disable max-len */
+    const patternBELL = 'LAT\\s*[\\s:]*\\s*([-+])?(\\d{1,2})[\\s.,]?(\\d+)?[\\s.,]?\\s*(\\d{1,2}([.,]\\d+)?)?\\s*(N|S|E|W)?\\s*LONG\\s*[\\s:]*\\s*([-+])?(\\d{1,3})[\\s.,]?(\\d+)?[\\s.,]?\\s*(\\d{1,2}([.,]\\d+)?)?\\s*(N|S|E|W)?\\s*UNC\\s*[\\s:]?\\s*(\\d+)\\s*CONF\\s*[\\s:]?\\s*(\\d{1,3})';
+    const bellRegex = new RegExp(`^${patternBELL}?`, 'gi');
+    const mmCoord = '([-+]?\\d+)[,.]?(\\d+)?';
+    const mmPattern = `${mmCoord}[\\s,]+${mmCoord}`;
+    const mmRegex = new RegExp(`^${mmPattern}$`, 'g');
+    let isXYCoords = false;
+    str = str.toLocaleUpperCase().trim();
+    // Extract projection
+    if (projectionRegex.test(str)) {
+        [coordStr, projectionStr] = str.split(';').map(s => s.trim());
+    }
+    else {
+        coordStr = str;
+    }
+    if (lonLatRegex.test(coordStr)) {
+        [
+            ,
+            negativeLon,
+            lon,
+            ,
+            decimalLon,
+            negativeLat,
+            lat,
+            ,
+            decimalLat
+        ] = coordStr.match(lonLatPattern);
+        lon = parseFloat((negativeLon ? negativeLon : '') + lon + '.' + decimalLon);
+        lat = parseFloat((negativeLat ? negativeLat : '') + lat + '.' + decimalLat);
+    }
+    else if (dmsRegex.test(coordStr)) {
+        [
+            ,
+            degreesLon,
+            minutesLon,
+            secondsLon,
+            directionLon,
+            degreesLat,
+            minutesLat,
+            secondsLat,
+            directionLat
+        ] = coordStr.match(dmsCoordPattern);
+        if (directionLon === 'S' || directionLon === 'N') {
+            degreesLon = [degreesLat, (degreesLat = degreesLon)][0];
+            minutesLon = [minutesLat, (minutesLat = minutesLon)][0];
+            secondsLon = [secondsLat, (secondsLat = secondsLon)][0];
+            directionLon = [directionLat, (directionLat = directionLon)][0];
+        }
+        lon = convertDMSToDD(parseFloat(degreesLon), parseFloat(minutesLon), parseFloat(secondsLon), directionLon);
+        lat = convertDMSToDD(parseFloat(degreesLat), parseFloat(minutesLat), parseFloat(secondsLat), directionLat);
+    }
+    else if (utmRegex.test(coordStr)) {
+        isXYCoords = true;
+        [, , zone, lon, lat] = coordStr.match(patternUtm);
+        const epsgUtm = Number(zone) < 10 ? `EPSG:3260${zone}` : `EPSG:326${zone}`;
+        [lon, lat] = olproj.transform([parseFloat(lon), parseFloat(lat)], epsgUtm, 'EPSG:4326');
+    }
+    else if (mtmRegex.test(coordStr)) {
+        isXYCoords = true;
+        [, , zone, lon, lat] = coordStr.match(patternMtm);
+        const epsgMtm = Number(zone) < 10 ? `EPSG:3218${zone}` : `EPSG:321${80 + Number(zone)}`;
+        [lon, lat] = olproj.transform([parseFloat(lon), parseFloat(lat)], epsgMtm, 'EPSG:4326');
+    }
+    else if (dmdRegex.test(coordStr)) {
+        [
+            ,
+            negativeLon,
+            degreesLon,
+            minutesLon,
+            secondsLon,
+            decimalLon,
+            negativeLat,
+            degreesLat,
+            minutesLat,
+            secondsLat,
+            decimalLat
+        ] = coordStr.match(patternDmd);
+        lon = convertDMSToDD(parseFloat((negativeLon ? negativeLon : '') + degreesLon), parseFloat(minutesLon), parseFloat(secondsLon), directionLon);
+        lat = convertDMSToDD(parseFloat((negativeLat ? negativeLat : '') + degreesLat), parseFloat(minutesLat), parseFloat(secondsLat), directionLat);
+    }
+    else if (ddRegex.test(coordStr)) {
+        [
+            ,
+            negativeLon,
+            degreesLon,
+            decimalLon,
+            negativeLat,
+            degreesLat,
+            decimalLat
+        ] = coordStr.match(patternDd);
+        lon = convertDMSToDD(parseFloat((negativeLon ? negativeLon : '') + degreesLon), parseFloat(minutesLon), parseFloat(secondsLon), directionLon);
+        lat = convertDMSToDD(parseFloat((negativeLat ? negativeLat : '') + degreesLat), parseFloat(minutesLat), parseFloat(secondsLat), directionLat);
+    }
+    else if (bellRegex.test(coordStr)) {
+        [
+            ,
+            negativeLat,
+            degreesLat,
+            minutesLat,
+            secondsLat,
+            ,
+            directionLat,
+            negativeLon,
+            degreesLon,
+            minutesLon,
+            secondsLon,
+            ,
+            directionLon,
+            radius,
+            conf
+        ] = coordStr.match(patternBELL);
+        // Set default value for North America
+        if (!directionLon) {
+            directionLon = 'W';
+        }
+        // Check if real minutes or decimals
+        if (minutesLon && minutesLon.length > 2) {
+            lon = parseFloat((negativeLon ? negativeLon : '') + degreesLon + '.' + minutesLon);
+        }
+        else {
+            lon = convertDMSToDD(parseFloat(degreesLon), parseFloat(minutesLon), parseFloat(secondsLon), directionLon);
+        }
+        if (minutesLat && minutesLat.length > 2) {
+            lat = parseFloat((negativeLat ? negativeLat : '') + degreesLat + '.' + minutesLat);
+        }
+        else {
+            lat = convertDMSToDD(parseFloat(degreesLat), parseFloat(minutesLat), parseFloat(secondsLat), directionLat);
+        }
+    }
+    else if (mmRegex.test(coordStr)) {
+        isXYCoords = true;
+        [, lon, decimalLon, lat, decimalLat] = coordStr.match(mmPattern);
+        if (decimalLon) {
+            lon = parseFloat(lon + '.' + decimalLon);
+        }
+        if (decimalLat) {
+            lat = parseFloat(lat + '.' + decimalLat);
+        }
+    }
+    else {
+        return {
+            lonLat: undefined,
+            message: '',
+            radius: undefined,
+            conf: undefined
+        };
+    }
+    if (opts.forceNA && !isXYCoords) {
+        // Set a negative coordinate for North America zone
+        if (lon > 0 && lat > 0) {
+            if (lon > lat) {
+                lon = -lon;
+            }
+            else {
+                lat = -lat;
+            }
+        }
+        // Reverse coordinate to respect lonLat convention
+        if (lon > lat) {
+            lon = [lat, (lat = lon)][0];
+        }
+    }
+    lonLat = [Number(lon), Number(lat)];
+    // Reproject the coordinate if projection parameter have been set and coord is not 4326
+    if ((projectionStr !== undefined && projectionStr !== toProjection) ||
+        (lonLat[0] > 180 || lonLat[0] < -180) ||
+        (lonLat[1] > 90 || lonLat[1] < -90)) {
+        const source = projectionStr ? 'EPSG:' + projectionStr : mapProjection;
+        const dest = 'EPSG:' + toProjection;
+        try {
+            lonLat = olproj.transform(lonLat, source, dest);
+        }
+        catch (e) {
+            return {
+                lonLat: undefined,
+                message: 'Projection ' + source + ' not supported',
+                radius: undefined,
+                conf: undefined
+            };
+        }
+    }
+    if (Math.abs(lonLat[0]) <= 180 && Math.abs(lonLat[1]) <= 90) {
+        return {
+            lonLat,
+            message: '',
+            radius: radius ? parseInt(radius, 10) : undefined,
+            conf: conf ? parseInt(conf, 10) : undefined
+        };
+    }
+    else {
+        return {
+            lonLat: undefined,
+            message: 'Coordinate out of Longitude/Latitude bounds',
+            radius: undefined,
+            conf: undefined
+        };
+    }
+}
+/**
+ * Convert degrees minutes seconds to dd
+ * @param degrees Degrees
+ * @param minutes Minutes
+ * @param seconds Seconds
+ * @param direction Direction
+ */
+function convertDMSToDD(degrees, minutes, seconds, direction) {
+    minutes = minutes || 0;
+    seconds = seconds || 0;
+    const neg = degrees < 0;
+    let dd = Math.abs(degrees) + minutes / 60 + seconds / 3600;
+    if (neg || direction === 'S' || direction === 'W') {
+        dd = -dd;
+    } // Don't do anything for N or E
+    return dd;
+}
+/**
+ * Convert dd to degrees minutes seconds
+ * @param lonLatDD longitude and latitude in dd
+ * @param decimal number of decimals for seconds
+ * @returns longitude and latitude in dms
+ */
+export function convertDDToDMS(lonLatDD, decimal = 3) {
+    const lonLatDMS = [];
+    lonLatDD.forEach(dd => {
+        const degrees = dd < 0 ? Math.ceil(dd) : Math.floor(dd);
+        const int = dd < 0 ? (degrees - dd) * 60 : (dd - degrees) * 60;
+        const minutes = Math.floor(int);
+        const seconds = ((int - minutes) * 60).toFixed(decimal);
+        lonLatDMS.push(`${degrees}° ${minutes}' ${seconds}"`);
+    });
+    return lonLatDMS;
+}
+/**
+ * Return true of two view states are equal.
+ * @param state1 View state
+ * @param state2 View state
+ * @returns True if the view states are equal
+ */
+export function viewStatesAreEqual(state1, state2) {
+    if (state1 === undefined || state2 === undefined) {
+        return false;
+    }
+    const tolerance = 1 / 10000;
+    return (state1.zoom === state2.zoom &&
+        Math.trunc(state1.center[0] / tolerance) ===
+            Math.trunc(state2.center[0] / tolerance) &&
+        Math.trunc(state1.center[1] / tolerance) ===
+            Math.trunc(state2.center[1] / tolerance));
+}
+/**
+ * Format the scale to a human readable text
+ * @param Scale of the map
+ * @returns Human readable scale text
+ */
+export function formatScale(scale) {
+    scale = Math.round(scale);
+    if (scale < 10000) {
+        return scale + '';
+    }
+    scale = Math.round(scale / 1000);
+    if (scale < 1000) {
+        return scale + 'K';
+    }
+    scale = Math.round(scale / 1000);
+    return scale + 'M';
+}
+/**
+ * Return the resolution from a scale denom
+ * @param scale Scale denom
+ * @param dpi DPI
+ * @returns Resolution
+ */
+export function getResolutionFromScale(scale, dpi = 96) {
+    const inchesPerMeter = 39.3701;
+    return scale / (inchesPerMeter * dpi);
+}
+/**
+ * Return the resolution from a scale denom
+ * @param Scale denom
+ * @returns Resolution
+ */
+export function getScaleFromResolution(resolution, unit = 'm', dpi = 96) {
+    const inchesPerMeter = 39.3701;
+    return resolution * olproj.METERS_PER_UNIT[unit] * inchesPerMeter * dpi;
+}
+/**
+ * Returns true if the CTRL key is pushed during an Ol MapBrowserPointerEvent
+ * @param event OL MapBrowserPointerEvent
+ * @returns Whether the CTRL key is pushed
+ */
+export function ctrlKeyDown(event) {
+    const originalEvent = event.originalEvent;
+    return (!originalEvent.altKey &&
+        (MAC ? originalEvent.metaKey : originalEvent.ctrlKey) &&
+        !originalEvent.shiftKey);
+}
+export function roundCoordTo(coord, decimal = 3) {
+    return [
+        NumberUtils.roundToNDecimal(coord[0], decimal),
+        NumberUtils.roundToNDecimal(coord[1], decimal)
+    ];
+}
+/**
+ * Returns an array of converted coordinates.
+ * Conversion is done for every configured projections
+ * and for the current UTM zone and MTM zone.
+ * @param lonLat [number, number] array of the coordinate to transform.
+ * @param projections  Projection[] Array of destination projection.
+ * @returns Returns an array of converted coordinates.
+ */
+export function lonLatConversion(lonLat, projections) {
+    const rawCoord3857 = olproj.transform(lonLat, 'EPSG:4326', 'EPSG:3857');
+    const convertedLonLat = [
+        {
+            code: 'EPSG:3857',
+            alias: 'Web Mercator',
+            coord: rawCoord3857,
+            igo2CoordFormat: `${roundCoordTo(rawCoord3857).join(', ')} ; 3857`
+        }
+    ];
+    // detect the current utm zone.
+    const utmZone = utmZoneFromLonLat(lonLat);
+    const epsgUtm = utmZone < 10 ? `EPSG:3260${utmZone}` : `EPSG:326${utmZone}`;
+    const utmName = `UTM-${utmZone}`;
+    const rawCoordUtm = olproj.transform(lonLat, 'EPSG:4326', epsgUtm);
+    convertedLonLat.push({
+        code: epsgUtm,
+        alias: 'UTM',
+        coord: rawCoordUtm,
+        igo2CoordFormat: `${utmName} ${roundCoordTo(rawCoordUtm).join(', ')}`
+    });
+    // detect the current mtm zone.
+    const mtmZone = mtmZoneFromLonLat(lonLat);
+    if (mtmZone) {
+        const epsgMtm = mtmZone < 10 ? `EPSG:3218${mtmZone}` : `EPSG:321${80 + mtmZone}`;
+        const mtmName = `MTM-${mtmZone}`;
+        const rawCoordMtm = olproj.transform(lonLat, 'EPSG:4326', epsgMtm);
+        convertedLonLat.push({
+            code: epsgMtm,
+            alias: 'MTM',
+            coord: rawCoordMtm,
+            igo2CoordFormat: `${mtmName} ${roundCoordTo(rawCoordMtm).join(', ')}`
+        });
+    }
+    projections.forEach(projection => {
+        const rawCoord = olproj.transform(lonLat, 'EPSG:4326', projection.code);
+        const numericEpsgCode = projection.code.split(':')[1];
+        convertedLonLat.push({
+            code: projection.code,
+            alias: projection.alias || projection.code,
+            coord: rawCoord,
+            igo2CoordFormat: `${roundCoordTo(rawCoord).join(', ')} ; ${numericEpsgCode}`
+        });
+    });
+    return convertedLonLat;
+}
+/**
+ * Detect the current utm zone of the lon/lat coordinate.
+ * @param lonLat [number, number] array of the coordinate to detect the UTM zone.
+ * @returns number The UTM zone.
+ */
+export function utmZoneFromLonLat(lonLat) {
+    return Math.ceil((lonLat[0] + 180) / 6);
+}
+/**
+ * Detect the current mtm zone of the lon/lat coordinate.
+ * @param lonLat [number, number] array of the coordinate to detect the MTM zone.
+ * @returns number The MTM zone. Undefined if outside of the mtm application zone.
+ */
+export function mtmZoneFromLonLat(lonLat) {
+    const long = lonLat[0];
+    let mtmZone;
+    if (long < -51 && long > -54) {
+        mtmZone = 1;
+    }
+    if (long < -54 && long > -57) {
+        mtmZone = 2;
+    }
+    if (long < -57 && long > -60) {
+        mtmZone = 3;
+    }
+    if (long < -60 && long > -63) {
+        mtmZone = 4;
+    }
+    if (long < -63 && long > -66) {
+        mtmZone = 5;
+    }
+    if (long < -66 && long > -69) {
+        mtmZone = 6;
+    }
+    if (long < -69 && long > -72) {
+        mtmZone = 7;
+    }
+    if (long < -72 && long > -75) {
+        mtmZone = 8;
+    }
+    if (long < -75 && long > -78) {
+        mtmZone = 9;
+    }
+    if (long < -78 && long > -81) {
+        mtmZone = 10;
+    }
+    return mtmZone;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"map.utils.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/map/shared/map.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import * as olproj from 'ol/proj';\r\nimport MapBrowserPointerEvent from 'ol/MapBrowserEvent';\r\nimport { MAC } from 'ol/has';\r\n\r\nimport { NumberUtils } from '@igo2/utils';\r\n\r\nimport { MapViewState } from './map.interface';\r\nimport { Projection } from './projection.interfaces';\r\n\r\n/**\r\n * This method extracts a coordinate tuple from a string.\r\n * @param str Any string\r\n * @param mapProjection string Map Projection\r\n * @param opts.forceNA boolean Force North America Zone\r\n * @returns object:\r\n *             lonLat: Coordinate,\r\n *             message: Message of error,\r\n *             radius: radius of the confience of coordinate,\r\n *             conf: confidence of the coordinate}\r\n */\r\nexport function stringToLonLat(\r\n  str: string,\r\n  mapProjection: string,\r\n  opts: { forceNA?: boolean } = {}\r\n): {\r\n  lonLat: [number, number] | undefined;\r\n  message: string;\r\n  radius: number | undefined;\r\n  conf: number | undefined;\r\n} {\r\n  let lonLat: [number, number];\r\n  let coordStr: string;\r\n  let negativeLon: string;\r\n  let degreesLon: string;\r\n  let minutesLon: string;\r\n  let secondsLon: string;\r\n  let directionLon: string;\r\n  let decimalLon: string;\r\n  let negativeLat: string;\r\n  let degreesLat: string;\r\n  let minutesLat: string;\r\n  let secondsLat: string;\r\n  let directionLat: string;\r\n  let decimalLat: string;\r\n  let zone: string;\r\n  let radius: string;\r\n  let conf: string;\r\n  let lon: any;\r\n  let lat: any;\r\n\r\n  const projectionPattern = '(\\\\s*;\\\\s*[\\\\d]{4,6})';\r\n  const toProjection = '4326';\r\n  let projectionStr: string;\r\n  const projectionRegex = new RegExp(projectionPattern, 'g');\r\n\r\n  const lonlatCoord = '([-+])?([\\\\d]{1,3})([,.](\\\\d+))?';\r\n  const lonLatPattern = `${lonlatCoord}[\\\\s,]+${lonlatCoord}`;\r\n  const lonLatRegex = new RegExp(`^${lonLatPattern}$`, 'g');\r\n\r\n  const dmsCoord =\r\n    '([0-9]{1,2})[:|°]?\\\\s*([0-9]{1,2})?[:|\\'|′|’]?\\\\s*([0-9]{1,2}(?:.[0-9]+){0,1})?\\\\s*[\"|″|”]?\\\\s*';\r\n  const dmsCoordPattern = `${dmsCoord}([N|S|E|W|O]),?\\\\s*${dmsCoord}([N|S|E|W|O])`;\r\n  const dmsRegex = new RegExp(`^${dmsCoordPattern}$`, 'gi');\r\n\r\n  const patternUtm =\r\n    '(UTM)-?(\\\\d{1,2})[\\\\s,]*(\\\\d+[.,]?\\\\d+)[\\\\s,]+(\\\\d+[.,]?\\\\d+)';\r\n  const utmRegex = new RegExp(`^${patternUtm}`, 'gi');\r\n\r\n  const patternMtm =\r\n    '(MTM)-?(\\\\d{1,2})[\\\\s,]*(\\\\d+[.,]?\\\\d+)[\\\\s,]+(\\\\d+[.,]?\\\\d+)';\r\n  const mtmRegex = new RegExp(`^${patternMtm}`, 'gi');\r\n\r\n  const ddCoord = '([-+])?(\\\\d{1,3})[,.](\\\\d+)';\r\n  const patternDd = `${ddCoord}\\\\s*[,]?\\\\s*${ddCoord}`;\r\n  const ddRegex = new RegExp(`^${patternDd}`, 'g');\r\n\r\n  const dmdCoord =\r\n    '([-+])?(\\\\d{1,3})[\\\\s,.]{1}(\\\\d{1,2})[\\\\s,.]{1}(\\\\d{1,2})[.,]?(\\\\d{1,5})?';\r\n  const patternDmd = `${dmdCoord}\\\\s*[,.]?\\\\s*${dmdCoord}`;\r\n  const dmdRegex = new RegExp(`^${patternDmd}`, 'g');\r\n\r\n /* eslint-disable max-len */\r\n  const patternBELL =\r\n    'LAT\\\\s*[\\\\s:]*\\\\s*([-+])?(\\\\d{1,2})[\\\\s.,]?(\\\\d+)?[\\\\s.,]?\\\\s*(\\\\d{1,2}([.,]\\\\d+)?)?\\\\s*(N|S|E|W)?\\\\s*LONG\\\\s*[\\\\s:]*\\\\s*([-+])?(\\\\d{1,3})[\\\\s.,]?(\\\\d+)?[\\\\s.,]?\\\\s*(\\\\d{1,2}([.,]\\\\d+)?)?\\\\s*(N|S|E|W)?\\\\s*UNC\\\\s*[\\\\s:]?\\\\s*(\\\\d+)\\\\s*CONF\\\\s*[\\\\s:]?\\\\s*(\\\\d{1,3})';\r\n  const bellRegex = new RegExp(`^${patternBELL}?`, 'gi');\r\n\r\n  const mmCoord = '([-+]?\\\\d+)[,.]?(\\\\d+)?';\r\n  const mmPattern = `${mmCoord}[\\\\s,]+${mmCoord}`;\r\n  const mmRegex = new RegExp(`^${mmPattern}$`, 'g');\r\n\r\n  let isXYCoords = false;\r\n\r\n  str = str.toLocaleUpperCase().trim();\r\n\r\n  // Extract projection\r\n  if (projectionRegex.test(str)) {\r\n    [coordStr, projectionStr] = str.split(';').map(s => s.trim());\r\n  } else {\r\n    coordStr = str;\r\n  }\r\n  if (lonLatRegex.test(coordStr)) {\r\n    [\r\n      ,\r\n      negativeLon,\r\n      lon,\r\n      ,\r\n      decimalLon,\r\n      negativeLat,\r\n      lat,\r\n      ,\r\n      decimalLat\r\n    ] = coordStr.match(lonLatPattern);\r\n\r\n    lon = parseFloat((negativeLon ? negativeLon : '') + lon + '.' + decimalLon);\r\n    lat = parseFloat((negativeLat ? negativeLat : '') + lat + '.' + decimalLat);\r\n  } else if (dmsRegex.test(coordStr)) {\r\n    [\r\n      ,\r\n      degreesLon,\r\n      minutesLon,\r\n      secondsLon,\r\n      directionLon,\r\n      degreesLat,\r\n      minutesLat,\r\n      secondsLat,\r\n      directionLat\r\n    ] = coordStr.match(dmsCoordPattern);\r\n\r\n    if (directionLon === 'S' || directionLon === 'N') {\r\n      degreesLon = [degreesLat, (degreesLat = degreesLon)][0];\r\n      minutesLon = [minutesLat, (minutesLat = minutesLon)][0];\r\n      secondsLon = [secondsLat, (secondsLat = secondsLon)][0];\r\n      directionLon = [directionLat, (directionLat = directionLon)][0];\r\n    }\r\n\r\n    lon = convertDMSToDD(\r\n      parseFloat(degreesLon),\r\n      parseFloat(minutesLon),\r\n      parseFloat(secondsLon),\r\n      directionLon\r\n    );\r\n    lat = convertDMSToDD(\r\n      parseFloat(degreesLat),\r\n      parseFloat(minutesLat),\r\n      parseFloat(secondsLat),\r\n      directionLat\r\n    );\r\n  } else if (utmRegex.test(coordStr)) {\r\n    isXYCoords = true;\r\n    [, , zone, lon, lat] = coordStr.match(patternUtm);\r\n    const epsgUtm = Number(zone) < 10 ? `EPSG:3260${zone}` : `EPSG:326${zone}`;\r\n    [lon, lat] = olproj.transform(\r\n      [parseFloat(lon), parseFloat(lat)],\r\n      epsgUtm,\r\n      'EPSG:4326'\r\n    );\r\n  } else if (mtmRegex.test(coordStr)) {\r\n    isXYCoords = true;\r\n    [, , zone, lon, lat] = coordStr.match(patternMtm);\r\n    const epsgMtm =\r\n      Number(zone) < 10 ? `EPSG:3218${zone}` : `EPSG:321${80 + Number(zone)}`;\r\n    [lon, lat] = olproj.transform(\r\n      [parseFloat(lon), parseFloat(lat)],\r\n      epsgMtm,\r\n      'EPSG:4326'\r\n    );\r\n  } else if (dmdRegex.test(coordStr)) {\r\n    [\r\n      ,\r\n      negativeLon,\r\n      degreesLon,\r\n      minutesLon,\r\n      secondsLon,\r\n      decimalLon,\r\n      negativeLat,\r\n      degreesLat,\r\n      minutesLat,\r\n      secondsLat,\r\n      decimalLat\r\n    ] = coordStr.match(patternDmd);\r\n\r\n    lon = convertDMSToDD(\r\n      parseFloat((negativeLon ? negativeLon : '') + degreesLon),\r\n      parseFloat(minutesLon),\r\n      parseFloat(secondsLon),\r\n      directionLon\r\n    );\r\n    lat = convertDMSToDD(\r\n      parseFloat((negativeLat ? negativeLat : '') + degreesLat),\r\n      parseFloat(minutesLat),\r\n      parseFloat(secondsLat),\r\n      directionLat\r\n    );\r\n  } else if (ddRegex.test(coordStr)) {\r\n    [\r\n      ,\r\n      negativeLon,\r\n      degreesLon,\r\n      decimalLon,\r\n      negativeLat,\r\n      degreesLat,\r\n      decimalLat\r\n    ] = coordStr.match(patternDd);\r\n\r\n    lon = convertDMSToDD(\r\n      parseFloat((negativeLon ? negativeLon : '') + degreesLon),\r\n      parseFloat(minutesLon),\r\n      parseFloat(secondsLon),\r\n      directionLon\r\n    );\r\n    lat = convertDMSToDD(\r\n      parseFloat((negativeLat ? negativeLat : '') + degreesLat),\r\n      parseFloat(minutesLat),\r\n      parseFloat(secondsLat),\r\n      directionLat\r\n    );\r\n  } else if (bellRegex.test(coordStr)) {\r\n    [\r\n      ,\r\n      negativeLat,\r\n      degreesLat,\r\n      minutesLat,\r\n      secondsLat,\r\n      ,\r\n      directionLat,\r\n      negativeLon,\r\n      degreesLon,\r\n      minutesLon,\r\n      secondsLon,\r\n      ,\r\n      directionLon,\r\n      radius,\r\n      conf\r\n    ] = coordStr.match(patternBELL);\r\n\r\n    // Set default value for North America\r\n    if (!directionLon) {\r\n      directionLon = 'W';\r\n    }\r\n\r\n    // Check if real minutes or decimals\r\n    if (minutesLon && minutesLon.length > 2) {\r\n      lon = parseFloat(\r\n        (negativeLon ? negativeLon : '') + degreesLon + '.' + minutesLon\r\n      );\r\n    } else {\r\n      lon = convertDMSToDD(\r\n        parseFloat(degreesLon),\r\n        parseFloat(minutesLon),\r\n        parseFloat(secondsLon),\r\n        directionLon\r\n      );\r\n    }\r\n\r\n    if (minutesLat && minutesLat.length > 2) {\r\n      lat = parseFloat(\r\n        (negativeLat ? negativeLat : '') + degreesLat + '.' + minutesLat\r\n      );\r\n    } else {\r\n      lat = convertDMSToDD(\r\n        parseFloat(degreesLat),\r\n        parseFloat(minutesLat),\r\n        parseFloat(secondsLat),\r\n        directionLat\r\n      );\r\n    }\r\n  } else if (mmRegex.test(coordStr)) {\r\n    isXYCoords = true;\r\n    [, lon, decimalLon, lat, decimalLat] = coordStr.match(mmPattern);\r\n\r\n    if (decimalLon) {\r\n      lon = parseFloat(lon + '.' + decimalLon);\r\n    }\r\n\r\n    if (decimalLat) {\r\n      lat = parseFloat(lat + '.' + decimalLat);\r\n    }\r\n  } else {\r\n    return {\r\n      lonLat: undefined,\r\n      message: '',\r\n      radius: undefined,\r\n      conf: undefined\r\n    };\r\n  }\r\n\r\n  if (opts.forceNA && !isXYCoords) {\r\n    // Set a negative coordinate for North America zone\r\n    if (lon > 0 && lat > 0) {\r\n      if (lon > lat) {\r\n        lon = -lon;\r\n      } else {\r\n        lat = -lat;\r\n      }\r\n    }\r\n\r\n    // Reverse coordinate to respect lonLat convention\r\n    if (lon > lat) {\r\n      lon = [lat, (lat = lon)][0];\r\n    }\r\n  }\r\n\r\n  lonLat = [Number(lon), Number(lat)] as [number, number];\r\n\r\n  // Reproject the coordinate if projection parameter have been set and coord is not 4326\r\n  if (\r\n    (projectionStr !== undefined && projectionStr !== toProjection) ||\r\n    (lonLat[0] > 180 || lonLat[0] < -180) ||\r\n    (lonLat[1] > 90 || lonLat[1] < -90)\r\n  ) {\r\n    const source = projectionStr ? 'EPSG:' + projectionStr : mapProjection;\r\n    const dest = 'EPSG:' + toProjection;\r\n\r\n    try {\r\n      lonLat = olproj.transform(lonLat, source, dest) as [number, number];\r\n    } catch (e) {\r\n      return {\r\n        lonLat: undefined,\r\n        message: 'Projection ' + source + ' not supported',\r\n        radius: undefined,\r\n        conf: undefined\r\n      };\r\n    }\r\n  }\r\n  if (Math.abs(lonLat[0]) <= 180 && Math.abs(lonLat[1]) <= 90) {\r\n    return {\r\n      lonLat,\r\n      message: '',\r\n      radius: radius ? parseInt(radius, 10) : undefined,\r\n      conf: conf ? parseInt(conf, 10) : undefined\r\n    };\r\n  } else {\r\n    return {\r\n      lonLat: undefined,\r\n      message: 'Coordinate out of Longitude/Latitude bounds',\r\n      radius: undefined,\r\n      conf: undefined\r\n    };\r\n  }\r\n}\r\n\r\n/**\r\n * Convert degrees minutes seconds to dd\r\n * @param degrees Degrees\r\n * @param minutes Minutes\r\n * @param seconds Seconds\r\n * @param direction Direction\r\n */\r\nfunction convertDMSToDD(\r\n  degrees: number,\r\n  minutes: number,\r\n  seconds: number,\r\n  direction: string\r\n) {\r\n  minutes = minutes || 0;\r\n  seconds = seconds || 0;\r\n\r\n  const neg = degrees < 0;\r\n  let dd = Math.abs(degrees) + minutes / 60 + seconds / 3600;\r\n\r\n  if (neg || direction === 'S' || direction === 'W') {\r\n    dd = -dd;\r\n  } // Don't do anything for N or E\r\n  return dd;\r\n}\r\n\r\n/**\r\n * Convert dd to degrees minutes seconds\r\n * @param lonLatDD longitude and latitude in dd\r\n * @param decimal number of decimals for seconds\r\n * @returns longitude and latitude in dms\r\n */\r\nexport function convertDDToDMS(\r\n  lonLatDD: [number, number], decimal: number = 3\r\n): string[] {\r\n  const lonLatDMS = [];\r\n\r\n  lonLatDD.forEach(dd => {\r\n    const degrees = dd < 0 ? Math.ceil(dd) : Math.floor(dd);\r\n    const int = dd < 0 ? (degrees - dd) * 60 : (dd - degrees) * 60;\r\n    const minutes = Math.floor(int);\r\n    const seconds = ((int - minutes) * 60).toFixed(decimal);\r\n\r\n    lonLatDMS.push(`${degrees}° ${minutes}' ${seconds}\"`);\r\n  });\r\n  return lonLatDMS;\r\n}\r\n\r\n/**\r\n * Return true of two view states are equal.\r\n * @param state1 View state\r\n * @param state2 View state\r\n * @returns True if the view states are equal\r\n */\r\nexport function viewStatesAreEqual(\r\n  state1: MapViewState,\r\n  state2: MapViewState\r\n): boolean {\r\n  if (state1 === undefined || state2 === undefined) {\r\n    return false;\r\n  }\r\n\r\n  const tolerance = 1 / 10000;\r\n  return (\r\n    state1.zoom === state2.zoom &&\r\n    Math.trunc(state1.center[0] / tolerance) ===\r\n      Math.trunc(state2.center[0] / tolerance) &&\r\n    Math.trunc(state1.center[1] / tolerance) ===\r\n      Math.trunc(state2.center[1] / tolerance)\r\n  );\r\n}\r\n\r\n/**\r\n * Format the scale to a human readable text\r\n * @param Scale of the map\r\n * @returns Human readable scale text\r\n */\r\nexport function formatScale(scale) {\r\n  scale = Math.round(scale);\r\n  if (scale < 10000) {\r\n    return scale + '';\r\n  }\r\n\r\n  scale = Math.round(scale / 1000);\r\n  if (scale < 1000) {\r\n    return scale + 'K';\r\n  }\r\n\r\n  scale = Math.round(scale / 1000);\r\n  return scale + 'M';\r\n}\r\n\r\n/**\r\n * Return the resolution from a scale denom\r\n * @param scale Scale denom\r\n * @param dpi DPI\r\n * @returns Resolution\r\n */\r\nexport function getResolutionFromScale(\r\n  scale: number,\r\n  dpi: number = 96\r\n): number {\r\n  const inchesPerMeter = 39.3701;\r\n  return scale / (inchesPerMeter * dpi);\r\n}\r\n\r\n/**\r\n * Return the resolution from a scale denom\r\n * @param Scale denom\r\n * @returns Resolution\r\n */\r\nexport function getScaleFromResolution(\r\n  resolution: number,\r\n  unit: string = 'm',\r\n  dpi: number = 96\r\n): number {\r\n  const inchesPerMeter = 39.3701;\r\n  return resolution * olproj.METERS_PER_UNIT[unit] * inchesPerMeter * dpi;\r\n}\r\n\r\n/**\r\n * Returns true if the CTRL key is pushed during an Ol MapBrowserPointerEvent\r\n * @param event OL MapBrowserPointerEvent\r\n * @returns Whether the CTRL key is pushed\r\n */\r\nexport function ctrlKeyDown(event: MapBrowserPointerEvent<any>): boolean {\r\n  const originalEvent = event.originalEvent;\r\n  return (\r\n    !originalEvent.altKey &&\r\n    (MAC ? originalEvent.metaKey : originalEvent.ctrlKey) &&\r\n    !originalEvent.shiftKey\r\n  );\r\n}\r\n\r\nexport function roundCoordTo(coord: [number, number], decimal: number = 3): [number, number] {\r\n  return [\r\n    NumberUtils.roundToNDecimal(coord[0], decimal),\r\n    NumberUtils.roundToNDecimal(coord[1], decimal)] as [number, number];\r\n}\r\n\r\n/**\r\n * Returns an array of converted coordinates.\r\n * Conversion is done for every configured projections\r\n * and for the current UTM zone and MTM zone.\r\n * @param lonLat [number, number] array of the coordinate to transform.\r\n * @param projections  Projection[] Array of destination projection.\r\n * @returns Returns an array of converted coordinates.\r\n */\r\nexport function lonLatConversion(\r\n  lonLat: [number, number],\r\n  projections: Projection[]\r\n): {\r\n  code: string;\r\n  alias: string;\r\n  coord: [number, number];\r\n  igo2CoordFormat: string;\r\n}[] {\r\n  const rawCoord3857 = olproj.transform(lonLat, 'EPSG:4326', 'EPSG:3857') as [number, number];\r\n  const convertedLonLat = [\r\n    {\r\n      code: 'EPSG:3857',\r\n      alias: 'Web Mercator',\r\n      coord: rawCoord3857,\r\n      igo2CoordFormat: `${roundCoordTo(rawCoord3857).join(', ')} ; 3857`\r\n    }\r\n  ];\r\n\r\n  // detect the current utm zone.\r\n  const utmZone = utmZoneFromLonLat(lonLat);\r\n  const epsgUtm = utmZone < 10 ? `EPSG:3260${utmZone}` : `EPSG:326${utmZone}`;\r\n  const utmName = `UTM-${utmZone}`;\r\n  const rawCoordUtm = olproj.transform(lonLat, 'EPSG:4326', epsgUtm) as [number, number];\r\n  convertedLonLat.push({\r\n    code: epsgUtm,\r\n    alias: 'UTM',\r\n    coord: rawCoordUtm,\r\n    igo2CoordFormat: `${utmName} ${roundCoordTo(rawCoordUtm).join(', ')}`\r\n  });\r\n\r\n  // detect the current mtm zone.\r\n  const mtmZone = mtmZoneFromLonLat(lonLat);\r\n  if (mtmZone) {\r\n    const epsgMtm =\r\n      mtmZone < 10 ? `EPSG:3218${mtmZone}` : `EPSG:321${80 + mtmZone}`;\r\n    const mtmName = `MTM-${mtmZone}`;\r\n    const rawCoordMtm = olproj.transform(lonLat, 'EPSG:4326', epsgMtm) as [number, number];\r\n    convertedLonLat.push({\r\n      code: epsgMtm,\r\n      alias: 'MTM',\r\n      coord: rawCoordMtm,\r\n      igo2CoordFormat: `${mtmName} ${roundCoordTo(rawCoordMtm).join(', ')}`\r\n    });\r\n  }\r\n\r\n  projections.forEach(projection => {\r\n    const rawCoord = olproj.transform(lonLat, 'EPSG:4326', projection.code) as [number, number];\r\n    const numericEpsgCode = projection.code.split(':')[1];\r\n    convertedLonLat.push({\r\n      code: projection.code,\r\n      alias: projection.alias || projection.code,\r\n      coord: rawCoord,\r\n      igo2CoordFormat: `${roundCoordTo(rawCoord).join(\r\n        ', '\r\n      )} ; ${numericEpsgCode}`\r\n    });\r\n  });\r\n\r\n  return convertedLonLat;\r\n}\r\n\r\n/**\r\n * Detect the current utm zone of the lon/lat coordinate.\r\n * @param lonLat [number, number] array of the coordinate to detect the UTM zone.\r\n * @returns number The UTM zone.\r\n */\r\nexport function utmZoneFromLonLat(lonLat: [number, number]) {\r\n  return Math.ceil((lonLat[0] + 180) / 6);\r\n}\r\n\r\n/**\r\n * Detect the current mtm zone of the lon/lat coordinate.\r\n * @param lonLat [number, number] array of the coordinate to detect the MTM zone.\r\n * @returns number The MTM zone. Undefined if outside of the mtm application zone.\r\n */\r\nexport function mtmZoneFromLonLat(lonLat: [number, number]) {\r\n  const long = lonLat[0];\r\n  let mtmZone;\r\n  if (long < -51 && long > -54) {\r\n    mtmZone = 1;\r\n  }\r\n  if (long < -54 && long > -57) {\r\n    mtmZone = 2;\r\n  }\r\n  if (long < -57 && long > -60) {\r\n    mtmZone = 3;\r\n  }\r\n  if (long < -60 && long > -63) {\r\n    mtmZone = 4;\r\n  }\r\n  if (long < -63 && long > -66) {\r\n    mtmZone = 5;\r\n  }\r\n  if (long < -66 && long > -69) {\r\n    mtmZone = 6;\r\n  }\r\n  if (long < -69 && long > -72) {\r\n    mtmZone = 7;\r\n  }\r\n  if (long < -72 && long > -75) {\r\n    mtmZone = 8;\r\n  }\r\n  if (long < -75 && long > -78) {\r\n    mtmZone = 9;\r\n  }\r\n  if (long < -78 && long > -81) {\r\n    mtmZone = 10;\r\n  }\r\n  return mtmZone;\r\n}\r\n"]}