@igo2/geo 1.12.1 → 1.13.0-alpha.0

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

@@ -0,0 +1,489 @@
+import * as olstyle from 'ol/style';
+import OlPoint from 'ol/geom/Point';
+import OlLineString from 'ol/geom/LineString';
+import OlPolygon from 'ol/geom/Polygon';
+import OlCircle from 'ol/geom/Circle';
+import OlOverlay from 'ol/Overlay';
+import { getCenter as olGetCenter } from 'ol/extent';
+import { getLength as olGetLength, getArea as olGetArea } from 'ol/sphere';
+import { MeasureAreaUnit, MeasureAreaUnitAbbreviation, MeasureLengthUnit, MeasureLengthUnitAbbreviation } from './measure.enum';
+/**
+ * Convert value from meters to kilometers
+ * @param value Value in meters
+ * @returns Value in kilometers
+ */
+export function metersToKilometers(value) {
+    return value * 0.001;
+}
+/**
+ * Convert value from meters to feet
+ * @param value Value in meters
+ * @returns Value in feet
+ */
+export function metersToFeet(value) {
+    return value * 3.2808;
+}
+/**
+ * Convert value from meters to miles
+ * @param value Value in meters
+ * @returns Value in miles
+ */
+export function metersToMiles(value) {
+    return value * 0.000621;
+}
+/**
+ * Convert value from square meters to square kilometers
+ * @param value Value in square meters
+ * @returns Value in square kilometers
+ */
+export function squareMetersToSquareKilometers(value) {
+    return value * 0.000001;
+}
+/**
+ * Convert value from square meters to square miles
+ * @param value Value in square meters
+ * @returns Value in square miles
+ */
+export function squareMetersToSquareMiles(value) {
+    return value * 0.0000003861;
+}
+/**
+ * Convert value from square meters to square feet
+ * @param value Value in square meters
+ * @returns Value in square feet
+ */
+export function squareMetersToSquareFeet(value) {
+    return value * 10.764;
+}
+/**
+ * Convert value from square meters to hectares
+ * @param value Value in square meters
+ * @returns Value in hectares
+ */
+export function squareMetersToHectares(value) {
+    return value * 0.0001;
+}
+/**
+ * Convert value from square meters to acres
+ * @param value Value in square meters
+ * @returns Value in acres
+ */
+export function squareMetersToAcres(value) {
+    return value * 0.00024711;
+}
+/**
+ * Convert value from meters to the specified length unit
+ * @param value Value in meters
+ * @param unit Length unit
+ * @returns Value in unit
+ */
+export function metersToUnit(value, unit) {
+    const conversionMapper = new Map([
+        [MeasureLengthUnit.Meters, (val) => val],
+        [MeasureLengthUnit.Kilometers, metersToKilometers],
+        [MeasureLengthUnit.Miles, metersToMiles],
+        [MeasureLengthUnit.Feet, metersToFeet],
+    ]);
+    const conversion = conversionMapper.get(unit);
+    return conversion ? conversion(value) : undefined;
+}
+/**
+ * Convert value from square meters to the specified area unit
+ * @param value Value in meters
+ * @param unit Area unit
+ * @returns Value in unit
+ */
+export function squareMetersToUnit(value, unit) {
+    const conversionMapper = new Map([
+        [MeasureAreaUnit.SquareMeters, (val) => val],
+        [MeasureAreaUnit.SquareKilometers, squareMetersToSquareKilometers],
+        [MeasureAreaUnit.SquareMiles, squareMetersToSquareMiles],
+        [MeasureAreaUnit.SquareFeet, squareMetersToSquareFeet],
+        [MeasureAreaUnit.Hectares, squareMetersToHectares],
+        [MeasureAreaUnit.Acres, squareMetersToAcres],
+    ]);
+    const conversion = conversionMapper.get(unit);
+    return conversion ? conversion(value) : undefined;
+}
+/**
+ * This method format a measure to a readable format
+ * @param measure Measure
+ * @param options Formatting options
+ * @returns Formatted measure
+ */
+export function formatMeasure(measure, options, languageService) {
+    let decimal = options.decimal;
+    if (decimal === undefined || decimal < 0) {
+        decimal = 1;
+    }
+    const parts = [];
+    if (options.locale !== undefined) {
+        parts.push(measure.toLocaleString(options.locale, {
+            minimumFractionDigits: decimal,
+            maximumFractionDigits: decimal
+        }));
+    }
+    else {
+        parts.push(measure.toFixed(decimal).toString());
+    }
+    if (options.unit !== undefined && options.unitAbbr === true) {
+        if (languageService) {
+            parts.push(MeasureLengthUnitAbbreviation[options.unit] ?
+                languageService.translate.instant('igo.geo.measure.' + MeasureLengthUnitAbbreviation[options.unit]) :
+                languageService.translate.instant('igo.geo.measure.' + MeasureAreaUnitAbbreviation[options.unit]));
+        }
+        else {
+            parts.push(MeasureLengthUnitAbbreviation[options.unit] || MeasureAreaUnitAbbreviation[options.unit]);
+        }
+    }
+    return parts.filter(p => p !== undefined).join(' ');
+}
+/**
+ * Compute best length measure unit for a given measure in meters
+ * @param value Value in meters
+ * @returns Measure unit
+ */
+export function computeBestLengthUnit(value) {
+    let unit = MeasureLengthUnit.Meters;
+    let converted = value;
+    const possibleUnits = [MeasureLengthUnit.Kilometers];
+    while (converted > 1000 && possibleUnits.length > 0) {
+        unit = possibleUnits.pop();
+        converted = metersToUnit(value, unit);
+    }
+    return unit;
+}
+/**
+ * Compute best length measure unit for a given measure in square meters
+ * @param value Value in meters
+ * @returns Measure unit
+ */
+export function computeBestAreaUnit(value) {
+    let unit = MeasureAreaUnit.SquareMeters;
+    let converted = value;
+    const possibleUnits = [MeasureAreaUnit.SquareKilometers];
+    while (converted > 1000000 && possibleUnits.length > 0) {
+        unit = possibleUnits.pop();
+        converted = squareMetersToUnit(value, unit);
+    }
+    return unit;
+}
+/**
+ * Create a default style for a measure interaction
+ * @returns OL style
+ */
+export function createMeasureInteractionStyle() {
+    return new olstyle.Style({
+        stroke: new olstyle.Stroke({
+            color: '#ffcc33',
+            lineDash: [10, 10],
+            width: 2
+        }),
+        fill: new olstyle.Fill({
+            color: 'rgba(255, 255, 255, 0.2)'
+        }),
+        image: new olstyle.Circle({
+            radius: 5,
+            stroke: new olstyle.Stroke({
+                color: '#ffcc33',
+            }),
+            fill: new olstyle.Fill({
+                color: 'rgba(255, 255, 255, 0.2)'
+            })
+        })
+    });
+}
+/**
+ * Create a default style for a measure layer
+ * @returns OL style
+ */
+export function createMeasureLayerStyle() {
+    return new olstyle.Style({
+        stroke: new olstyle.Stroke({
+            color: '#ffcc33',
+            width: 2
+        }),
+        fill: new olstyle.Fill({
+            color: 'rgba(255, 255, 255, 0.2)'
+        })
+    });
+}
+/**
+ * Compute the length in meters of an OL geometry with a given projection
+ * @param olGeometry Ol geometry
+ * @param projection olGeometry's projection
+ * @returns Length in meters
+ */
+export function measureOlGeometryLength(olGeometry, projection) {
+    if (olGeometry instanceof OlPoint) {
+        return undefined;
+    }
+    if (olGeometry.getFlatCoordinates().length === 0) {
+        return undefined;
+    }
+    return olGetLength(olGeometry, { projection });
+}
+/**
+ * Compute the area in square meters of an OL geometry with a given projection
+ * @param olGeometry Ol geometry
+ * @param projection olGeometry's projection
+ * @returns Area in square meters
+ */
+export function measureOlGeometryArea(olGeometry, projection) {
+    if (olGeometry instanceof OlPoint || olGeometry instanceof OlLineString) {
+        return undefined;
+    }
+    if (olGeometry.getFlatCoordinates().length === 0) {
+        return undefined;
+    }
+    return olGetArea(olGeometry, { projection });
+}
+/**
+ * Compute the area (square meters), length (meters) and last length (meters)
+ * of an OL geometry with a given projection.
+ * @param olGeometry Ol geometry
+ * @param projection olGeometry's projection
+ * @returns Computed measure
+ */
+export function measureOlGeometry(olGeometry, projection) {
+    const length = measureOlGeometryLength(olGeometry, projection);
+    const area = measureOlGeometryArea(olGeometry, projection);
+    const lengths = [];
+    const coordinates = olGeometry.getFlatCoordinates();
+    const coordinatesLength = coordinates.length;
+    for (let i = 0; i <= coordinatesLength - 4; i += 2) {
+        const olSegment = new OlLineString([
+            [coordinates[i], coordinates[i + 1]],
+            [coordinates[i + 2], coordinates[i + 3]]
+        ]);
+        lengths.push(measureOlGeometryLength(olSegment, projection));
+    }
+    return {
+        area,
+        length,
+        lengths
+    };
+}
+/**
+ * Update an OL geometry midpoints and return an array of those points
+ * @param olGeometry OL Geometry
+ * @returns OL points
+ */
+export function updateOlGeometryMidpoints(olGeometry) {
+    let olMidpoints;
+    if (olGeometry instanceof OlPoint) {
+        const olMidpointPoint = new OlPoint(olGeometry.getFlatCoordinates());
+        olMidpoints = new Array(1);
+        olMidpoints[0] = olMidpointPoint;
+    }
+    else {
+        olMidpoints = getOlGeometryMidpoints(olGeometry);
+        // TODO: handle multi geometries
+        const coordinates = olGeometry.getFlatCoordinates();
+        const midpointsLength = olMidpoints.length;
+        for (let i = 0; i < midpointsLength; i++) {
+            const j = i * 2;
+            const olSegment = new OlLineString([
+                [coordinates[j], coordinates[j + 1]],
+                [coordinates[j + 2], coordinates[j + 3]]
+            ]);
+            const midpointCoordinate = olSegment.getCoordinateAt(0.5);
+            const olMidpoint = olMidpoints[i];
+            if (olMidpoint !== undefined) {
+                olMidpoint.setCoordinates(midpointCoordinate);
+            }
+            else {
+                olMidpoints[i] = new OlPoint(midpointCoordinate);
+            }
+        }
+    }
+    return olMidpoints;
+}
+/**
+ * Clear an OL geometry midpoints and return an array of those points
+ * @param olGeometry OL Geometry
+ */
+export function clearOlGeometryMidpoints(olGeometry) {
+    const olMidpoints = olGeometry.get('_midpoints') || [];
+    const midpointsLength = olMidpoints.length;
+    for (let i = 0; i < midpointsLength; i++) {
+        const olMidpoint = olMidpoints[i];
+        if (olMidpoint !== undefined) {
+            if (olMidpoint !== undefined) {
+                clearOlMidpointTooltip(olMidpoint);
+            }
+        }
+    }
+    olGeometry.set('_midpoints', undefined, true);
+    return olMidpoints;
+}
+/**
+ * Return an array of  OL geometry midpoints, if any
+ * @param olGeometry OL Geometry
+ * @returns OL points
+ */
+function getOlGeometryMidpoints(olGeometry) {
+    let expectedNumber;
+    if (olGeometry instanceof OlCircle) {
+        expectedNumber = 0;
+    }
+    else {
+        expectedNumber = Math.max((olGeometry.getFlatCoordinates().length / 2) - 1, 0);
+    }
+    // TODO: This works but it's quite messy. If time permits,
+    // clean this. Maybe a Tooltip class could handle that
+    let olMidpoints = olGeometry.get('_midpoints');
+    if (olMidpoints === undefined) {
+        if (olGeometry instanceof OlPoint) {
+            olMidpoints = new Array(1);
+        }
+        else {
+            olMidpoints = new Array(expectedNumber);
+        }
+        olGeometry.set('_midpoints', olMidpoints, true);
+        return olMidpoints;
+    }
+    if (expectedNumber === 0) {
+        return olMidpoints;
+    }
+    if (expectedNumber === olMidpoints.length) {
+        return olMidpoints;
+    }
+    if (expectedNumber > olMidpoints.length) {
+        olMidpoints.push(...new Array(expectedNumber - olMidpoints.length));
+        return olMidpoints;
+    }
+    for (let i = expectedNumber; i < olMidpoints.length; i++) {
+        const olMidpoint = olMidpoints[expectedNumber];
+        if (olMidpoint !== undefined) {
+            clearOlMidpointTooltip(olMidpoint);
+        }
+    }
+    olMidpoints.splice(expectedNumber);
+    return olMidpoints;
+}
+/**
+ * Remove an OL midpoint's tooltip from the map
+ * @param olMidpoint OL Point
+ */
+function clearOlMidpointTooltip(olMidpoint) {
+    const olTooltip = olMidpoint.get('_tooltip');
+    if (olTooltip !== undefined) {
+        const olMap = olTooltip.getMap();
+        if (olMap !== undefined) {
+            olMap.removeOverlay(olTooltip);
+        }
+    }
+}
+/**
+ * Add an OL overlay at each midpoint and return an array of those overlays
+ * @param olGeometry OL Geometry
+ * @returns OL overlays
+ */
+export function updateOlTooltipsAtMidpoints(olGeometry) {
+    const olMidpoints = updateOlGeometryMidpoints(olGeometry);
+    let typeGeom = '';
+    if (olGeometry instanceof OlLineString) {
+        typeGeom = 'line-';
+    }
+    else if (olGeometry instanceof OlPolygon) {
+        typeGeom = 'polygone-';
+    }
+    const olTooltips = olMidpoints.map((olMidpoint) => {
+        let olTooltip = olMidpoint.get('_tooltip');
+        if (olTooltip === undefined) {
+            olTooltip = createOlTooltipAtPoint(olMidpoint, false, typeGeom);
+        }
+        else {
+            olTooltip.setPosition(olMidpoint.getFlatCoordinates());
+        }
+        return olTooltip;
+    });
+    return olTooltips;
+}
+/**
+ * Return an array of OL overlay at midspoints, if any
+ * @param olGeometry OL Geometry
+ * @returns OL overlays
+ */
+export function getOlTooltipsAtMidpoints(olGeometry) {
+    const olMidpoints = getOlGeometryMidpoints(olGeometry);
+    return olMidpoints.map((olMidpoint) => {
+        return olMidpoint ? olMidpoint.get('_tooltip') : undefined;
+    });
+}
+/**
+ * Update an OL geometry center and return it
+ * @param olGeometry OL Geometry
+ * @returns OL point
+ */
+export function updateOlGeometryCenter(olGeometry) {
+    let olCenter = olGeometry.get('_center');
+    const centerCoordinate = olGetCenter(olGeometry.getExtent());
+    if (olCenter !== undefined) {
+        olCenter.setCoordinates(centerCoordinate);
+    }
+    else {
+        olCenter = new OlPoint(centerCoordinate);
+        olGeometry.set('_center', olCenter);
+    }
+    return olCenter;
+}
+/**
+ * Add an OL overlay at the center of a geometry and return that overlay
+ * @param olGeometry OL Geometry
+ * @returns OL overlay
+ */
+export function updateOlTooltipAtCenter(olGeometry) {
+    const olCenter = updateOlGeometryCenter(olGeometry);
+    let olTooltip = olCenter.get('_tooltip');
+    if (olTooltip === undefined) {
+        olTooltip = createOlTooltipAtPoint(olCenter, true);
+    }
+    else {
+        olTooltip.setPosition(olCenter.getFlatCoordinates());
+    }
+    return olTooltip;
+}
+/**
+ * Return an array of OL overlay at midspoints, if any
+ * @param olGeometry OL Geometry
+ * @returns OL overlays
+ */
+export function getOlTooltipAtCenter(olGeometry) {
+    const olCenter = olGeometry.get('_center');
+    return olCenter ? olCenter.get('_tooltip') : undefined;
+}
+/**
+ * Get all the tooltips of an OL geometry
+ * @param olGeometry OL Geometry
+ * @returns OL overlays
+ */
+export function getTooltipsOfOlGeometry(olGeometry) {
+    const olTooltips = [].concat(getOlTooltipsAtMidpoints(olGeometry) || []);
+    const olCenterTooltip = getOlTooltipAtCenter(olGeometry);
+    if (olCenterTooltip !== undefined) {
+        olTooltips.push(olCenterTooltip);
+    }
+    return olTooltips;
+}
+/**
+ * Create an OL overlay at a point and bind the overlay to the point
+ * @param olPoint OL Point
+ * @returns OL overlay
+ */
+export function createOlTooltipAtPoint(olPoint, center = false, srcGeomType = '') {
+    const olTooltip = new OlOverlay({
+        element: document.createElement('div'),
+        offset: [-30, -10],
+        className: (center ?
+            ['igo-map-tooltip',
+                'igo-map-tooltip-measure', 'igo-map-tooltip-measure-area'] : ['igo-map-tooltip', 'igo-map-tooltip-measure',
+            `igo-map-tooltip-measure-${srcGeomType}segments`]).join(' '),
+        stopEvent: false
+    });
+    olTooltip.setPosition(olPoint.getFlatCoordinates());
+    olPoint.set('_tooltip', olTooltip);
+    return olTooltip;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"measure.utils.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/measure/shared/measure.utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,OAAO,MAAM,UAAU,CAAC;AACpC,OAAO,OAAO,MAAM,eAAe,CAAC;AACpC,OAAO,YAAY,MAAM,oBAAoB,CAAC;AAC9C,OAAO,SAAS,MAAM,iBAAiB,CAAC;AACxC,OAAO,QAAQ,MAAM,gBAAgB,CAAC;AACtC,OAAO,SAAS,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,SAAS,IAAI,WAAW,EAAE,MAAM,WAAW,CAAC;AACrD,OAAO,EACL,SAAS,IAAI,WAAW,EACxB,OAAO,IAAI,SAAS,EACrB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,eAAe,EACf,2BAA2B,EAC3B,iBAAiB,EACjB,6BAA6B,EAC9B,MAAM,gBAAgB,CAAC;AAExB;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAa;IAC9C,OAAO,KAAK,GAAG,KAAK,CAAC;AACvB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,KAAa;IACxC,OAAO,KAAK,GAAG,MAAM,CAAC;AACxB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAAC,KAAa;IACzC,OAAO,KAAK,GAAG,QAAQ,CAAC;AAC1B,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,8BAA8B,CAAC,KAAa;IAC1D,OAAO,KAAK,GAAG,QAAQ,CAAC;AAC1B,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,yBAAyB,CAAC,KAAa;IACrD,OAAO,KAAK,GAAG,YAAY,CAAC;AAC9B,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,wBAAwB,CAAC,KAAa;IACpD,OAAO,KAAK,GAAG,MAAM,CAAC;AACxB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CAAC,KAAa;IAClD,OAAO,KAAK,GAAG,MAAM,CAAC;AACxB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAa;IAC/C,OAAO,KAAK,GAAG,UAAU,CAAC;AAC5B,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,KAAa,EAAE,IAAuB;IACjE,MAAM,gBAAgB,GAAG,IAAI,GAAG,CAAC;QAC/B,CAAC,iBAAiB,CAAC,MAAM,EAAE,CAAC,GAAW,EAAE,EAAE,CAAC,GAAG,CAAC;QAChD,CAAC,iBAAiB,CAAC,UAAU,EAAE,kBAAkB,CAAC;QAClD,CAAC,iBAAiB,CAAC,KAAK,EAAE,aAAa,CAAC;QACxC,CAAC,iBAAiB,CAAC,IAAI,EAAE,YAAY,CAAC;KACvC,CAAC,CAAC;IACH,MAAM,UAAU,GAAG,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAE9C,OAAO,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AACpD,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAa,EAAE,IAAqB;IACrE,MAAM,gBAAgB,GAAG,IAAI,GAAG,CAAC;QAC/B,CAAC,eAAe,CAAC,YAAY,EAAE,CAAC,GAAW,EAAE,EAAE,CAAC,GAAG,CAAC;QACpD,CAAC,eAAe,CAAC,gBAAgB,EAAE,8BAA8B,CAAC;QAClE,CAAC,eAAe,CAAC,WAAW,EAAE,yBAAyB,CAAC;QACxD,CAAC,eAAe,CAAC,UAAU,EAAE,wBAAwB,CAAC;QACtD,CAAC,eAAe,CAAC,QAAQ,EAAE,sBAAsB,CAAC;QAClD,CAAC,eAAe,CAAC,KAAK,EAAE,mBAAmB,CAAC;KAC7C,CAAC,CAAC;IACH,MAAM,UAAU,GAAG,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAE9C,OAAO,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AACpD,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAC3B,OAAe,EACf,OAKC,EACD,eAAiC;IACjC,IAAI,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAC9B,IAAI,OAAO,KAAK,SAAS,IAAI,OAAO,GAAG,CAAC,EAAE;QACxC,OAAO,GAAG,CAAC,CAAC;KACb;IAED,MAAM,KAAK,GAAG,EAAE,CAAC;IACjB,IAAI,OAAO,CAAC,MAAM,KAAK,SAAS,EAAE;QAChC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,MAAM,EAAE;YAChD,qBAAqB,EAAE,OAAO;YAC9B,qBAAqB,EAAE,OAAO;SAC/B,CAAC,CAAC,CAAC;KACL;SAAM;QACL,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;KACjD;IAED,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS,IAAI,OAAO,CAAC,QAAQ,KAAK,IAAI,EAAE;QAC3D,IAAI,eAAe,EAAE;YACnB,KAAK,CAAC,IAAI,CACR,6BAA6B,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;gBAC3C,eAAe,CAAC,SAAS,CAAC,OAAO,CAAC,kBAAkB,GAAG,6BAA6B,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBACrG,eAAe,CAAC,SAAS,CAAC,OAAO,CAAC,kBAAkB,GAAG,2BAA2B,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CACpG,CAAC;SACH;aAAM;YACL,KAAK,CAAC,IAAI,CACR,6BAA6B,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,2BAA2B,CAAC,OAAO,CAAC,IAAI,CAAC,CACzF,CAAC;SACH;KACF;IAED,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACtD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CAAC,KAAa;IACjD,IAAI,IAAI,GAAG,iBAAiB,CAAC,MAAM,CAAC;IACpC,IAAI,SAAS,GAAG,KAAK,CAAC;IACtB,MAAM,aAAa,GAAG,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;IACrD,OAAO,SAAS,GAAG,IAAI,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE;QACnD,IAAI,GAAG,aAAa,CAAC,GAAG,EAAE,CAAC;QAC3B,SAAS,GAAG,YAAY,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;KACvC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAa;IAC/C,IAAI,IAAI,GAAG,eAAe,CAAC,YAAY,CAAC;IACxC,IAAI,SAAS,GAAG,KAAK,CAAC;IACtB,MAAM,aAAa,GAAG,CAAC,eAAe,CAAC,gBAAgB,CAAC,CAAC;IACzD,OAAO,SAAS,GAAG,OAAO,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE;QACtD,IAAI,GAAG,aAAa,CAAC,GAAG,EAAE,CAAC;QAC3B,SAAS,GAAG,kBAAkB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;KAC7C;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,6BAA6B;IAC3C,OAAO,IAAI,OAAO,CAAC,KAAK,CAAC;QACvB,MAAM,EAAE,IAAI,OAAO,CAAC,MAAM,CAAC;YACzB,KAAK,EAAE,SAAS;YAChB,QAAQ,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC;YAClB,KAAK,EAAE,CAAC;SACT,CAAC;QACF,IAAI,EAAG,IAAI,OAAO,CAAC,IAAI,CAAC;YACtB,KAAK,EAAE,0BAA0B;SAClC,CAAC;QACF,KAAK,EAAE,IAAI,OAAO,CAAC,MAAM,CAAC;YACxB,MAAM,EAAE,CAAC;YACT,MAAM,EAAE,IAAI,OAAO,CAAC,MAAM,CAAC;gBACzB,KAAK,EAAE,SAAS;aACjB,CAAC;YACF,IAAI,EAAE,IAAI,OAAO,CAAC,IAAI,CAAC;gBACrB,KAAK,EAAE,0BAA0B;aAClC,CAAC;SACH,CAAC;KACH,CAAC,CAAC;AACL,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,uBAAuB;IACrC,OAAO,IAAI,OAAO,CAAC,KAAK,CAAC;QACvB,MAAM,EAAE,IAAI,OAAO,CAAC,MAAM,CAAC;YACzB,KAAK,EAAE,SAAS;YAChB,KAAK,EAAE,CAAC;SACT,CAAC;QACF,IAAI,EAAG,IAAI,OAAO,CAAC,IAAI,CAAC;YACtB,KAAK,EAAE,0BAA0B;SAClC,CAAC;KACH,CAAC,CAAC;AACL,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,uBAAuB,CAAC,UAAyD,EAAE,UAAkB;IACnH,IAAI,UAAU,YAAY,OAAO,EAAE;QACjC,OAAO,SAAS,CAAC;KAClB;IACD,IAAI,UAAU,CAAC,kBAAkB,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE;QAChD,OAAO,SAAS,CAAC;KAClB;IACD,OAAO,WAAW,CAAC,UAAU,EAAE,EAAC,UAAU,EAAC,CAAC,CAAC;AAC/C,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CAAC,UAAyD,EAAE,UAAkB;IACjH,IAAI,UAAU,YAAY,OAAO,IAAI,UAAU,YAAY,YAAY,EAAE;QACvE,OAAO,SAAS,CAAC;KAClB;IACD,IAAI,UAAU,CAAC,kBAAkB,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE;QAChD,OAAO,SAAS,CAAC;KAClB;IACD,OAAO,SAAS,CAAC,UAAU,EAAE,EAAC,UAAU,EAAC,CAAC,CAAC;AAC7C,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAAC,UAAyD,EAAE,UAAkB;IAC7G,MAAM,MAAM,GAAG,uBAAuB,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;IAC/D,MAAM,IAAI,GAAG,qBAAqB,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;IAE3D,MAAM,OAAO,GAAG,EAAE,CAAC;IACnB,MAAM,WAAW,GAAG,UAAU,CAAC,kBAAkB,EAAE,CAAC;IACpD,MAAM,iBAAiB,GAAG,WAAW,CAAC,MAAM,CAAC;IAC7C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,iBAAiB,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE;QAClD,MAAM,SAAS,GAAG,IAAI,YAAY,CAAC;YACjC,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YACpC,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;SACzC,CAAC,CAAC;QAEH,OAAO,CAAC,IAAI,CAAC,uBAAuB,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC;KAC9D;IAED,OAAO;QACL,IAAI;QACJ,MAAM;QACN,OAAO;KACR,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,yBAAyB,CAAC,UAAyD;IACjG,IAAI,WAAW,CAAC;IAChB,IAAI,UAAU,YAAY,OAAO,EAAE;QACjC,MAAM,eAAe,GAAG,IAAI,OAAO,CAAC,UAAU,CAAC,kBAAkB,EAAE,CAAC,CAAC;QACrE,WAAW,GAAG,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC;QAC3B,WAAW,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC;KAClC;SAAM;QACL,WAAW,GAAG,sBAAsB,CAAC,UAAU,CAAC,CAAC;QACjD,gCAAgC;QAChC,MAAM,WAAW,GAAG,UAAU,CAAC,kBAAkB,EAAE,CAAC;QACpD,MAAM,eAAe,GAAG,WAAW,CAAC,MAAM,CAAC;QAC3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,eAAe,EAAE,CAAC,EAAE,EAAE;YACxC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAChB,MAAM,SAAS,GAAG,IAAI,YAAY,CAAC;gBACjC,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;gBACpC,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;aACzC,CAAC,CAAC;YAEH,MAAM,kBAAkB,GAAG,SAAS,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;YAC1D,MAAM,UAAU,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;YAClC,IAAI,UAAU,KAAK,SAAS,EAAE;gBAC5B,UAAU,CAAC,cAAc,CAAC,kBAAkB,CAAC,CAAC;aAC/C;iBAAM;gBACL,WAAW,CAAC,CAAC,CAAC,GAAG,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAAC;aAClD;SACF;KACF;IACD,OAAO,WAAW,CAAC;AACrB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,wBAAwB,CAAC,UAAyD;IAChG,MAAM,WAAW,GAAG,UAAU,CAAC,GAAG,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;IACvD,MAAM,eAAe,GAAG,WAAW,CAAC,MAAM,CAAC;IAC3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,eAAe,EAAE,CAAC,EAAE,EAAE;QACxC,MAAM,UAAU,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;QAClC,IAAI,UAAU,KAAK,SAAS,EAAE;YAC5B,IAAI,UAAU,KAAK,SAAS,EAAE;gBAC5B,sBAAsB,CAAC,UAAU,CAAC,CAAC;aACpC;SACF;KACF;IAED,UAAU,CAAC,GAAG,CAAC,YAAY,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC;IAE9C,OAAO,WAAW,CAAC;AACrB,CAAC;AAED;;;;GAIG;AACH,SAAS,sBAAsB,CAAC,UAAyD;IACvF,IAAI,cAAc,CAAC;IACnB,IAAI,UAAU,YAAY,QAAQ,EAAE;QAClC,cAAc,GAAG,CAAC,CAAC;KACpB;SAAM;QACL,cAAc,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,UAAU,CAAC,kBAAkB,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;KAChF;IACD,0DAA0D;IAC1D,sDAAsD;IACtD,IAAI,WAAW,GAAG,UAAU,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;IAE/C,IAAI,WAAW,KAAK,SAAS,EAAE;QAC7B,IAAI,UAAU,YAAY,OAAO,EAAE;YACjC,WAAW,GAAG,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC;SAC5B;aAAM;YACL,WAAW,GAAG,IAAI,KAAK,CAAC,cAAc,CAAC,CAAC;SACzC;QACD,UAAU,CAAC,GAAG,CAAC,YAAY,EAAE,WAAW,EAAE,IAAI,CAAC,CAAC;QAChD,OAAO,WAAW,CAAC;KACpB;IAED,IAAI,cAAc,KAAK,CAAC,EAAE;QACxB,OAAO,WAAW,CAAC;KACpB;IAED,IAAI,cAAc,KAAK,WAAW,CAAC,MAAM,EAAE;QACzC,OAAO,WAAW,CAAC;KACpB;IAED,IAAI,cAAc,GAAG,WAAW,CAAC,MAAM,EAAE;QACvC,WAAW,CAAC,IAAI,CAAC,GAAG,IAAI,KAAK,CAAC,cAAc,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC;QACpE,OAAO,WAAW,CAAC;KACpB;IAED,KAAK,IAAI,CAAC,GAAG,cAAc,EAAE,CAAC,GAAG,WAAW,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACxD,MAAM,UAAU,GAAG,WAAW,CAAC,cAAc,CAAC,CAAC;QAC/C,IAAI,UAAU,KAAK,SAAS,EAAE;YAC5B,sBAAsB,CAAC,UAAU,CAAC,CAAC;SACpC;KACF;IACD,WAAW,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;IAEnC,OAAO,WAAW,CAAC;AACrB,CAAC;AAED;;;GAGG;AACH,SAAS,sBAAsB,CAAC,UAAmB;IACjD,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IAC7C,IAAI,SAAS,KAAK,SAAS,EAAE;QAC3B,MAAM,KAAK,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC;QACjC,IAAI,KAAK,KAAK,SAAS,EAAE;YACvB,KAAK,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;SAChC;KACF;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,2BAA2B,CAAC,UAAyD;IACnG,MAAM,WAAW,GAAG,yBAAyB,CAAC,UAAU,CAAC,CAAC;IAC1D,IAAI,QAAQ,GAAG,EAAE,CAAC;IAClB,IAAI,UAAU,YAAY,YAAY,EAAE;QACxC,QAAQ,GAAG,OAAO,CAAC;KAClB;SAAM,IAAI,UAAU,YAAY,SAAS,EAAE;QAC1C,QAAQ,GAAG,WAAW,CAAC;KACtB;IACH,MAAM,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,UAAmB,EAAE,EAAE;QACzD,IAAI,SAAS,GAAG,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QAC3C,IAAI,SAAS,KAAK,SAAS,EAAE;YAC3B,SAAS,GAAG,sBAAsB,CAAC,UAAU,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;SACjE;aAAM;YACL,SAAS,CAAC,WAAW,CAAC,UAAU,CAAC,kBAAkB,EAAE,CAAC,CAAC;SACxD;QACD,OAAO,SAAS,CAAC;IACnB,CAAC,CAAC,CAAC;IACH,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,wBAAwB,CAAC,UAAyD;IAChG,MAAM,WAAW,GAAG,sBAAsB,CAAC,UAAU,CAAC,CAAC;IACvD,OAAO,WAAW,CAAC,GAAG,CAAC,CAAC,UAAmB,EAAE,EAAE;QAC7C,OAAO,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAC7D,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CAAC,UAAyD;IAC9F,IAAI,QAAQ,GAAG,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IACzC,MAAM,gBAAgB,GAAG,WAAW,CAAC,UAAU,CAAC,SAAS,EAAE,CAAC,CAAC;IAC7D,IAAI,QAAQ,KAAK,SAAS,EAAE;QAC1B,QAAQ,CAAC,cAAc,CAAC,gBAAgB,CAAC,CAAC;KAC3C;SAAM;QACL,QAAQ,GAAG,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAAC;QACzC,UAAU,CAAC,GAAG,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;KACrC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,uBAAuB,CAAC,UAAyD;IAC/F,MAAM,QAAQ,GAAG,sBAAsB,CAAC,UAAU,CAAC,CAAC;IACpD,IAAI,SAAS,GAAG,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IACzC,IAAI,SAAS,KAAK,SAAS,EAAE;QAC3B,SAAS,GAAG,sBAAsB,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;KACpD;SAAM;QACL,SAAS,CAAC,WAAW,CAAC,QAAQ,CAAC,kBAAkB,EAAE,CAAC,CAAC;KACtD;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAC,UAAyD;IAC5F,MAAM,QAAQ,GAAG,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IAC3C,OAAO,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AACzD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,uBAAuB,CAAC,UAAyD;IAC/F,MAAM,UAAU,GAAG,EAAE,CAAC,MAAM,CAAC,wBAAwB,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC;IACzE,MAAM,eAAe,GAAG,oBAAoB,CAAC,UAAU,CAAC,CAAC;IACzD,IAAI,eAAe,KAAK,SAAS,EAAE;QACjC,UAAU,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;KAClC;IACD,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CAAC,OAAgB,EAAE,SAAkB,KAAK,EAAE,cAAqB,EAAE;IACvG,MAAM,SAAS,GAAG,IAAI,SAAS,CAAC;QAC9B,OAAO,EAAE,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC;QACtC,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;QAClB,SAAS,EAAE,CAAC,MAAM,CAAC,CAAC;YACpB,CAAE,iBAAiB;gBACjB,yBAAyB,EAAE,8BAA8B,CAAC,CAAC,CAAC,CAAC,CAAC,iBAAiB,EAAE,yBAAyB;YAC1G,2BAA2B,WAAW,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;QAC9D,SAAS,EAAE,KAAK;KACjB,CAAC,CAAC;IACH,SAAS,CAAC,WAAW,CAAC,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAAC;IACpD,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;IAEnC,OAAO,SAAS,CAAC;AACnB,CAAC","sourcesContent":["import { LanguageService } from '@igo2/core';\r\nimport * as olstyle from 'ol/style';\r\nimport OlPoint from 'ol/geom/Point';\r\nimport OlLineString from 'ol/geom/LineString';\r\nimport OlPolygon from 'ol/geom/Polygon';\r\nimport OlCircle from 'ol/geom/Circle';\r\nimport OlOverlay from 'ol/Overlay';\r\nimport { getCenter as olGetCenter } from 'ol/extent';\r\nimport {\r\n  getLength as olGetLength,\r\n  getArea as olGetArea\r\n} from 'ol/sphere';\r\n\r\nimport { Measure } from './measure.interfaces';\r\nimport {\r\n  MeasureAreaUnit,\r\n  MeasureAreaUnitAbbreviation,\r\n  MeasureLengthUnit,\r\n  MeasureLengthUnitAbbreviation\r\n} from './measure.enum';\r\n\r\n/**\r\n * Convert value from meters to kilometers\r\n * @param value Value in meters\r\n * @returns Value in kilometers\r\n */\r\nexport function metersToKilometers(value: number): number {\r\n  return value * 0.001;\r\n}\r\n\r\n/**\r\n * Convert value from meters to feet\r\n * @param value Value in meters\r\n * @returns Value in feet\r\n */\r\nexport function metersToFeet(value: number): number {\r\n  return value * 3.2808;\r\n}\r\n\r\n/**\r\n * Convert value from meters to miles\r\n * @param value Value in meters\r\n * @returns Value in miles\r\n */\r\nexport function metersToMiles(value: number): number {\r\n  return value * 0.000621;\r\n}\r\n\r\n/**\r\n * Convert value from square meters to square kilometers\r\n * @param value Value in square meters\r\n * @returns Value in square kilometers\r\n */\r\nexport function squareMetersToSquareKilometers(value: number): number {\r\n  return value * 0.000001;\r\n}\r\n\r\n/**\r\n * Convert value from square meters to square miles\r\n * @param value Value in square meters\r\n * @returns Value in square miles\r\n */\r\nexport function squareMetersToSquareMiles(value: number): number {\r\n  return value * 0.0000003861;\r\n}\r\n\r\n/**\r\n * Convert value from square meters to square feet\r\n * @param value Value in square meters\r\n * @returns Value in square feet\r\n */\r\nexport function squareMetersToSquareFeet(value: number): number {\r\n  return value * 10.764;\r\n}\r\n\r\n/**\r\n * Convert value from square meters to hectares\r\n * @param value Value in square meters\r\n * @returns Value in hectares\r\n */\r\nexport function squareMetersToHectares(value: number): number {\r\n  return value * 0.0001;\r\n}\r\n\r\n/**\r\n * Convert value from square meters to acres\r\n * @param value Value in square meters\r\n * @returns Value in acres\r\n */\r\nexport function squareMetersToAcres(value: number): number {\r\n  return value * 0.00024711;\r\n}\r\n\r\n/**\r\n * Convert value from meters to the specified length unit\r\n * @param value Value in meters\r\n * @param unit Length unit\r\n * @returns Value in unit\r\n */\r\nexport function metersToUnit(value: number, unit: MeasureLengthUnit): number | undefined {\r\n  const conversionMapper = new Map([\r\n    [MeasureLengthUnit.Meters, (val: number) => val],\r\n    [MeasureLengthUnit.Kilometers, metersToKilometers],\r\n    [MeasureLengthUnit.Miles, metersToMiles],\r\n    [MeasureLengthUnit.Feet, metersToFeet],\r\n  ]);\r\n  const conversion = conversionMapper.get(unit);\r\n\r\n  return conversion ? conversion(value) : undefined;\r\n}\r\n\r\n/**\r\n * Convert value from square meters to the specified area unit\r\n * @param value Value in meters\r\n * @param unit Area unit\r\n * @returns Value in unit\r\n */\r\nexport function squareMetersToUnit(value: number, unit: MeasureAreaUnit): number | undefined {\r\n  const conversionMapper = new Map([\r\n    [MeasureAreaUnit.SquareMeters, (val: number) => val],\r\n    [MeasureAreaUnit.SquareKilometers, squareMetersToSquareKilometers],\r\n    [MeasureAreaUnit.SquareMiles, squareMetersToSquareMiles],\r\n    [MeasureAreaUnit.SquareFeet, squareMetersToSquareFeet],\r\n    [MeasureAreaUnit.Hectares, squareMetersToHectares],\r\n    [MeasureAreaUnit.Acres, squareMetersToAcres],\r\n  ]);\r\n  const conversion = conversionMapper.get(unit);\r\n\r\n  return conversion ? conversion(value) : undefined;\r\n}\r\n\r\n/**\r\n * This method format a measure to a readable format\r\n * @param measure Measure\r\n * @param options Formatting options\r\n * @returns Formatted measure\r\n */\r\nexport function formatMeasure(\r\n  measure: number,\r\n  options?: {\r\n    decimal?: number;\r\n    unit?: MeasureAreaUnit | MeasureLengthUnit;\r\n    unitAbbr?: boolean;\r\n    locale?: string;\r\n  },\r\n  languageService?: LanguageService) {\r\n  let decimal = options.decimal;\r\n  if (decimal === undefined || decimal < 0) {\r\n    decimal = 1;\r\n  }\r\n\r\n  const parts = [];\r\n  if (options.locale !== undefined) {\r\n    parts.push(measure.toLocaleString(options.locale, {\r\n      minimumFractionDigits: decimal,\r\n      maximumFractionDigits: decimal\r\n    }));\r\n  } else {\r\n    parts.push(measure.toFixed(decimal).toString());\r\n  }\r\n\r\n  if (options.unit !== undefined && options.unitAbbr === true) {\r\n    if (languageService) {\r\n      parts.push(\r\n        MeasureLengthUnitAbbreviation[options.unit] ?\r\n          languageService.translate.instant('igo.geo.measure.' + MeasureLengthUnitAbbreviation[options.unit]) :\r\n          languageService.translate.instant('igo.geo.measure.' + MeasureAreaUnitAbbreviation[options.unit])\r\n      );\r\n    } else {\r\n      parts.push(\r\n        MeasureLengthUnitAbbreviation[options.unit] || MeasureAreaUnitAbbreviation[options.unit]\r\n      );\r\n    }\r\n  }\r\n\r\n  return parts.filter(p => p !== undefined).join(' ');\r\n}\r\n\r\n/**\r\n * Compute best length measure unit for a given measure in meters\r\n * @param value Value in meters\r\n * @returns Measure unit\r\n */\r\nexport function computeBestLengthUnit(value: number): MeasureLengthUnit {\r\n  let unit = MeasureLengthUnit.Meters;\r\n  let converted = value;\r\n  const possibleUnits = [MeasureLengthUnit.Kilometers];\r\n  while (converted > 1000 && possibleUnits.length > 0) {\r\n    unit = possibleUnits.pop();\r\n    converted = metersToUnit(value, unit);\r\n  }\r\n  return unit;\r\n}\r\n\r\n/**\r\n * Compute best length measure unit for a given measure in square meters\r\n * @param value Value in meters\r\n * @returns Measure unit\r\n */\r\nexport function computeBestAreaUnit(value: number): MeasureAreaUnit {\r\n  let unit = MeasureAreaUnit.SquareMeters;\r\n  let converted = value;\r\n  const possibleUnits = [MeasureAreaUnit.SquareKilometers];\r\n  while (converted > 1000000 && possibleUnits.length > 0) {\r\n    unit = possibleUnits.pop();\r\n    converted = squareMetersToUnit(value, unit);\r\n  }\r\n  return unit;\r\n}\r\n\r\n/**\r\n * Create a default style for a measure interaction\r\n * @returns OL style\r\n */\r\nexport function createMeasureInteractionStyle(): olstyle.Style {\r\n  return new olstyle.Style({\r\n    stroke: new olstyle.Stroke({\r\n      color: '#ffcc33',\r\n      lineDash: [10, 10],\r\n      width: 2\r\n    }),\r\n    fill:  new olstyle.Fill({\r\n      color: 'rgba(255, 255, 255, 0.2)'\r\n    }),\r\n    image: new olstyle.Circle({\r\n      radius: 5,\r\n      stroke: new olstyle.Stroke({\r\n        color: '#ffcc33',\r\n      }),\r\n      fill: new olstyle.Fill({\r\n        color: 'rgba(255, 255, 255, 0.2)'\r\n      })\r\n    })\r\n  });\r\n}\r\n\r\n/**\r\n * Create a default style for a measure layer\r\n * @returns OL style\r\n */\r\nexport function createMeasureLayerStyle(): olstyle.Style {\r\n  return new olstyle.Style({\r\n    stroke: new olstyle.Stroke({\r\n      color: '#ffcc33',\r\n      width: 2\r\n    }),\r\n    fill:  new olstyle.Fill({\r\n      color: 'rgba(255, 255, 255, 0.2)'\r\n    })\r\n  });\r\n}\r\n\r\n/**\r\n * Compute the length in meters of an OL geometry with a given projection\r\n * @param olGeometry Ol geometry\r\n * @param projection olGeometry's projection\r\n * @returns Length in meters\r\n */\r\nexport function measureOlGeometryLength(olGeometry: OlPoint | OlLineString | OlPolygon | OlCircle, projection: string): number | undefined {\r\n  if (olGeometry instanceof OlPoint) {\r\n    return undefined;\r\n  }\r\n  if (olGeometry.getFlatCoordinates().length === 0) {\r\n    return undefined;\r\n  }\r\n  return olGetLength(olGeometry, {projection});\r\n}\r\n\r\n/**\r\n * Compute the area in square meters of an OL geometry with a given projection\r\n * @param olGeometry Ol geometry\r\n * @param projection olGeometry's projection\r\n * @returns Area in square meters\r\n */\r\nexport function measureOlGeometryArea(olGeometry: OlPoint | OlLineString | OlPolygon | OlCircle, projection: string): number | undefined {\r\n  if (olGeometry instanceof OlPoint || olGeometry instanceof OlLineString) {\r\n    return undefined;\r\n  }\r\n  if (olGeometry.getFlatCoordinates().length === 0) {\r\n    return undefined;\r\n  }\r\n  return olGetArea(olGeometry, {projection});\r\n}\r\n\r\n/**\r\n * Compute the area (square meters), length (meters) and last length (meters)\r\n * of an OL geometry with a given projection.\r\n * @param olGeometry Ol geometry\r\n * @param projection olGeometry's projection\r\n * @returns Computed measure\r\n */\r\nexport function measureOlGeometry(olGeometry: OlPoint | OlLineString | OlPolygon | OlCircle, projection: string): Measure {\r\n  const length = measureOlGeometryLength(olGeometry, projection);\r\n  const area = measureOlGeometryArea(olGeometry, projection);\r\n\r\n  const lengths = [];\r\n  const coordinates = olGeometry.getFlatCoordinates();\r\n  const coordinatesLength = coordinates.length;\r\n  for (let i = 0; i <= coordinatesLength - 4; i += 2) {\r\n    const olSegment = new OlLineString([\r\n      [coordinates[i], coordinates[i + 1]],\r\n      [coordinates[i + 2], coordinates[i + 3]]\r\n    ]);\r\n\r\n    lengths.push(measureOlGeometryLength(olSegment, projection));\r\n  }\r\n\r\n  return {\r\n    area,\r\n    length,\r\n    lengths\r\n  };\r\n}\r\n\r\n/**\r\n * Update an OL geometry midpoints and return an array of those points\r\n * @param olGeometry OL Geometry\r\n * @returns OL points\r\n */\r\nexport function updateOlGeometryMidpoints(olGeometry: OlPoint | OlLineString | OlPolygon | OlCircle): OlPoint[] {\r\n  let olMidpoints;\r\n  if (olGeometry instanceof OlPoint) {\r\n    const olMidpointPoint = new OlPoint(olGeometry.getFlatCoordinates());\r\n    olMidpoints = new Array(1);\r\n    olMidpoints[0] = olMidpointPoint;\r\n  } else {\r\n    olMidpoints = getOlGeometryMidpoints(olGeometry);\r\n    // TODO: handle multi geometries\r\n    const coordinates = olGeometry.getFlatCoordinates();\r\n    const midpointsLength = olMidpoints.length;\r\n    for (let i = 0; i < midpointsLength; i++) {\r\n      const j = i * 2;\r\n      const olSegment = new OlLineString([\r\n        [coordinates[j], coordinates[j + 1]],\r\n        [coordinates[j + 2], coordinates[j + 3]]\r\n      ]);\r\n\r\n      const midpointCoordinate = olSegment.getCoordinateAt(0.5);\r\n      const olMidpoint = olMidpoints[i];\r\n      if (olMidpoint !== undefined) {\r\n        olMidpoint.setCoordinates(midpointCoordinate);\r\n      } else {\r\n        olMidpoints[i] = new OlPoint(midpointCoordinate);\r\n      }\r\n    }\r\n  }\r\n  return olMidpoints;\r\n}\r\n\r\n/**\r\n * Clear an OL geometry midpoints and return an array of those points\r\n * @param olGeometry OL Geometry\r\n */\r\nexport function clearOlGeometryMidpoints(olGeometry: OlPoint | OlLineString | OlPolygon | OlCircle) {\r\n  const olMidpoints = olGeometry.get('_midpoints') || [];\r\n  const midpointsLength = olMidpoints.length;\r\n  for (let i = 0; i < midpointsLength; i++) {\r\n    const olMidpoint = olMidpoints[i];\r\n    if (olMidpoint !== undefined) {\r\n      if (olMidpoint !== undefined) {\r\n        clearOlMidpointTooltip(olMidpoint);\r\n      }\r\n    }\r\n  }\r\n\r\n  olGeometry.set('_midpoints', undefined, true);\r\n\r\n  return olMidpoints;\r\n}\r\n\r\n/**\r\n * Return an array of  OL geometry midpoints, if any\r\n * @param olGeometry OL Geometry\r\n * @returns OL points\r\n */\r\nfunction getOlGeometryMidpoints(olGeometry: OlPoint | OlLineString | OlPolygon | OlCircle): OlPoint[] {\r\n  let expectedNumber;\r\n  if (olGeometry instanceof OlCircle) {\r\n    expectedNumber = 0;\r\n  } else {\r\n    expectedNumber = Math.max((olGeometry.getFlatCoordinates().length / 2) - 1, 0);\r\n  }\r\n  // TODO: This works but it's quite messy. If time permits,\r\n  // clean this. Maybe a Tooltip class could handle that\r\n  let olMidpoints = olGeometry.get('_midpoints');\r\n\r\n  if (olMidpoints === undefined) {\r\n    if (olGeometry instanceof OlPoint) {\r\n      olMidpoints = new Array(1);\r\n    } else {\r\n      olMidpoints = new Array(expectedNumber);\r\n    }\r\n    olGeometry.set('_midpoints', olMidpoints, true);\r\n    return olMidpoints;\r\n  }\r\n\r\n  if (expectedNumber === 0) {\r\n    return olMidpoints;\r\n  }\r\n\r\n  if (expectedNumber === olMidpoints.length) {\r\n    return olMidpoints;\r\n  }\r\n\r\n  if (expectedNumber > olMidpoints.length) {\r\n    olMidpoints.push(...new Array(expectedNumber - olMidpoints.length));\r\n    return olMidpoints;\r\n  }\r\n\r\n  for (let i = expectedNumber; i < olMidpoints.length; i++) {\r\n    const olMidpoint = olMidpoints[expectedNumber];\r\n    if (olMidpoint !== undefined) {\r\n      clearOlMidpointTooltip(olMidpoint);\r\n    }\r\n  }\r\n  olMidpoints.splice(expectedNumber);\r\n\r\n  return olMidpoints;\r\n}\r\n\r\n/**\r\n * Remove an OL midpoint's tooltip from the map\r\n * @param olMidpoint OL Point\r\n */\r\nfunction clearOlMidpointTooltip(olMidpoint: OlPoint) {\r\n  const olTooltip = olMidpoint.get('_tooltip');\r\n  if (olTooltip !== undefined) {\r\n    const olMap = olTooltip.getMap();\r\n    if (olMap !== undefined) {\r\n      olMap.removeOverlay(olTooltip);\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Add an OL overlay at each midpoint and return an array of those overlays\r\n * @param olGeometry OL Geometry\r\n * @returns OL overlays\r\n */\r\nexport function updateOlTooltipsAtMidpoints(olGeometry: OlPoint | OlLineString | OlPolygon | OlCircle): OlOverlay[] {\r\n  const olMidpoints = updateOlGeometryMidpoints(olGeometry);\r\n  let typeGeom = '';\r\n  if (olGeometry instanceof OlLineString) {\r\n  typeGeom = 'line-';\r\n  } else if (olGeometry instanceof OlPolygon) {\r\n    typeGeom = 'polygone-';\r\n    }\r\n  const olTooltips = olMidpoints.map((olMidpoint: OlPoint) => {\r\n    let olTooltip = olMidpoint.get('_tooltip');\r\n    if (olTooltip === undefined) {\r\n      olTooltip = createOlTooltipAtPoint(olMidpoint, false, typeGeom);\r\n    } else {\r\n      olTooltip.setPosition(olMidpoint.getFlatCoordinates());\r\n    }\r\n    return olTooltip;\r\n  });\r\n  return olTooltips;\r\n}\r\n\r\n/**\r\n * Return an array of OL overlay at midspoints, if any\r\n * @param olGeometry OL Geometry\r\n * @returns OL overlays\r\n */\r\nexport function getOlTooltipsAtMidpoints(olGeometry: OlPoint | OlLineString | OlPolygon | OlCircle): OlOverlay[] {\r\n  const olMidpoints = getOlGeometryMidpoints(olGeometry);\r\n  return olMidpoints.map((olMidpoint: OlPoint) => {\r\n    return olMidpoint ? olMidpoint.get('_tooltip') : undefined;\r\n  });\r\n}\r\n\r\n/**\r\n * Update an OL geometry center and return it\r\n * @param olGeometry OL Geometry\r\n * @returns OL point\r\n */\r\nexport function updateOlGeometryCenter(olGeometry: OlPoint | OlLineString | OlPolygon | OlCircle): OlPoint {\r\n  let olCenter = olGeometry.get('_center');\r\n  const centerCoordinate = olGetCenter(olGeometry.getExtent());\r\n  if (olCenter !== undefined) {\r\n    olCenter.setCoordinates(centerCoordinate);\r\n  } else {\r\n    olCenter = new OlPoint(centerCoordinate);\r\n    olGeometry.set('_center', olCenter);\r\n  }\r\n\r\n  return olCenter;\r\n}\r\n\r\n/**\r\n * Add an OL overlay at the center of a geometry and return that overlay\r\n * @param olGeometry OL Geometry\r\n * @returns OL overlay\r\n */\r\nexport function updateOlTooltipAtCenter(olGeometry: OlPoint | OlLineString | OlPolygon | OlCircle): OlOverlay {\r\n  const olCenter = updateOlGeometryCenter(olGeometry);\r\n  let olTooltip = olCenter.get('_tooltip');\r\n  if (olTooltip === undefined) {\r\n    olTooltip = createOlTooltipAtPoint(olCenter, true);\r\n  } else {\r\n    olTooltip.setPosition(olCenter.getFlatCoordinates());\r\n  }\r\n  return olTooltip;\r\n}\r\n\r\n/**\r\n * Return an array of OL overlay at midspoints, if any\r\n * @param olGeometry OL Geometry\r\n * @returns OL overlays\r\n */\r\nexport function getOlTooltipAtCenter(olGeometry: OlPoint | OlLineString | OlPolygon | OlCircle): OlOverlay {\r\n  const olCenter = olGeometry.get('_center');\r\n  return olCenter ? olCenter.get('_tooltip') : undefined;\r\n}\r\n\r\n/**\r\n * Get all the tooltips of an OL geometry\r\n * @param olGeometry OL Geometry\r\n * @returns OL overlays\r\n */\r\nexport function getTooltipsOfOlGeometry(olGeometry: OlPoint | OlLineString | OlPolygon | OlCircle): OlOverlay[] {\r\n  const olTooltips = [].concat(getOlTooltipsAtMidpoints(olGeometry) || []);\r\n  const olCenterTooltip = getOlTooltipAtCenter(olGeometry);\r\n  if (olCenterTooltip !== undefined) {\r\n    olTooltips.push(olCenterTooltip);\r\n  }\r\n  return olTooltips;\r\n}\r\n\r\n/**\r\n * Create an OL overlay at a point and bind the overlay to the point\r\n * @param olPoint OL Point\r\n * @returns OL overlay\r\n */\r\nexport function createOlTooltipAtPoint(olPoint: OlPoint, center: boolean = false, srcGeomType: string= ''): OlOverlay {\r\n  const olTooltip = new OlOverlay({\r\n    element: document.createElement('div'),\r\n    offset: [-30, -10],\r\n    className: (center ?\r\n    [ 'igo-map-tooltip',\r\n      'igo-map-tooltip-measure', 'igo-map-tooltip-measure-area'] : ['igo-map-tooltip', 'igo-map-tooltip-measure',\r\n      `igo-map-tooltip-measure-${srcGeomType}segments`]).join(' '),\r\n    stopEvent: false\r\n  });\r\n  olTooltip.setPosition(olPoint.getFlatCoordinates());\r\n  olPoint.set('_tooltip', olTooltip);\r\n\r\n  return olTooltip;\r\n}\r\n"]}

package/esm2020/lib/metadata/index.mjs

@@ -0,0 +1,3 @@
+export * from './shared';
+export * from './metadata-button';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9tZXRhZGF0YS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLG1CQUFtQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zaGFyZWQnO1xyXG5leHBvcnQgKiBmcm9tICcuL21ldGFkYXRhLWJ1dHRvbic7XHJcbiJdfQ==

package/esm2020/lib/metadata/metadata-button/index.mjs

@@ -0,0 +1,2 @@
+export * from './metadata-button.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9tZXRhZGF0YS9tZXRhZGF0YS1idXR0b24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw2QkFBNkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbWV0YWRhdGEtYnV0dG9uLmNvbXBvbmVudCc7XHJcbiJdfQ==