#### Measure

Using a draw interaction to measure lengths and areas.

The `getLength()` and `getArea()` functions calculate spherical lengths and areas for geometries. Lengths are calculated by assuming great circle segments between geometry coordinates. Areas are calculated as if edges of polygons were great circle segments.

Note that the `geometry.getLength()` and `geometry.getArea()` methods return measures of projected (planar) geometries. These can be very different than on-the-ground measures in certain situations — in northern and southern latitudes using Web Mercator for example. For better results, use the functions in the `ol/sphere` module.

##### main.js
``````import Draw from 'ol/interaction/Draw.js';
import Map from 'ol/Map.js';
import Overlay from 'ol/Overlay.js';
import View from 'ol/View.js';
import {Circle as CircleStyle, Fill, Stroke, Style} from 'ol/style.js';
import {LineString, Polygon} from 'ol/geom.js';
import {OSM, Vector as VectorSource} from 'ol/source.js';
import {Tile as TileLayer, Vector as VectorLayer} from 'ol/layer.js';
import {getArea, getLength} from 'ol/sphere.js';
import {unByKey} from 'ol/Observable.js';

const raster = new TileLayer({
source: new OSM(),
});

const source = new VectorSource();

const vector = new VectorLayer({
source: source,
style: {
'fill-color': 'rgba(255, 255, 255, 0.2)',
'stroke-color': '#ffcc33',
'stroke-width': 2,
'circle-fill-color': '#ffcc33',
},
});

/**
* Currently drawn feature.
* @type {import("../src/ol/Feature.js").default}
*/
let sketch;

/**
* The help tooltip element.
* @type {HTMLElement}
*/
let helpTooltipElement;

/**
* Overlay to show the help messages.
* @type {Overlay}
*/
let helpTooltip;

/**
* The measure tooltip element.
* @type {HTMLElement}
*/
let measureTooltipElement;

/**
* Overlay to show the measurement.
* @type {Overlay}
*/
let measureTooltip;

/**
* Message to show when the user is drawing a polygon.
* @type {string}
*/
const continuePolygonMsg = 'Click to continue drawing the polygon';

/**
* Message to show when the user is drawing a line.
* @type {string}
*/
const continueLineMsg = 'Click to continue drawing the line';

/**
* Handle pointer move.
* @param {import("../src/ol/MapBrowserEvent").default} evt The event.
*/
const pointerMoveHandler = function (evt) {
if (evt.dragging) {
return;
}
/** @type {string} */
let helpMsg = 'Click to start drawing';

if (sketch) {
const geom = sketch.getGeometry();
if (geom instanceof Polygon) {
helpMsg = continuePolygonMsg;
} else if (geom instanceof LineString) {
helpMsg = continueLineMsg;
}
}

helpTooltipElement.innerHTML = helpMsg;
helpTooltip.setPosition(evt.coordinate);

helpTooltipElement.classList.remove('hidden');
};

const map = new Map({
layers: [raster, vector],
target: 'map',
view: new View({
center: [-11000000, 4600000],
zoom: 15,
}),
});

map.on('pointermove', pointerMoveHandler);

});

const typeSelect = document.getElementById('type');

let draw; // global so we can remove it later

/**
* Format length output.
* @param {LineString} line The line.
* @return {string} The formatted length.
*/
const formatLength = function (line) {
const length = getLength(line);
let output;
if (length > 100) {
output = Math.round((length / 1000) * 100) / 100 + ' ' + 'km';
} else {
output = Math.round(length * 100) / 100 + ' ' + 'm';
}
return output;
};

/**
* Format area output.
* @param {Polygon} polygon The polygon.
* @return {string} Formatted area.
*/
const formatArea = function (polygon) {
const area = getArea(polygon);
let output;
if (area > 10000) {
output = Math.round((area / 1000000) * 100) / 100 + ' ' + 'km<sup>2</sup>';
} else {
output = Math.round(area * 100) / 100 + ' ' + 'm<sup>2</sup>';
}
return output;
};

const style = new Style({
fill: new Fill({
color: 'rgba(255, 255, 255, 0.2)',
}),
stroke: new Stroke({
color: 'rgba(0, 0, 0, 0.5)',
lineDash: [10, 10],
width: 2,
}),
image: new CircleStyle({
stroke: new Stroke({
color: 'rgba(0, 0, 0, 0.7)',
}),
fill: new Fill({
color: 'rgba(255, 255, 255, 0.2)',
}),
}),
});

const type = typeSelect.value == 'area' ? 'Polygon' : 'LineString';
draw = new Draw({
source: source,
type: type,
style: function (feature) {
const geometryType = feature.getGeometry().getType();
if (geometryType === type || geometryType === 'Point') {
return style;
}
},
});

createMeasureTooltip();
createHelpTooltip();

let listener;
draw.on('drawstart', function (evt) {
// set sketch
sketch = evt.feature;

/** @type {import("../src/ol/coordinate.js").Coordinate|undefined} */
let tooltipCoord = evt.coordinate;

listener = sketch.getGeometry().on('change', function (evt) {
const geom = evt.target;
let output;
if (geom instanceof Polygon) {
output = formatArea(geom);
tooltipCoord = geom.getInteriorPoint().getCoordinates();
} else if (geom instanceof LineString) {
output = formatLength(geom);
tooltipCoord = geom.getLastCoordinate();
}
measureTooltipElement.innerHTML = output;
measureTooltip.setPosition(tooltipCoord);
});
});

draw.on('drawend', function () {
measureTooltipElement.className = 'ol-tooltip ol-tooltip-static';
measureTooltip.setOffset([0, -7]);
// unset sketch
sketch = null;
// unset tooltip so that a new one can be created
measureTooltipElement = null;
createMeasureTooltip();
unByKey(listener);
});
}

/**
* Creates a new help tooltip
*/
function createHelpTooltip() {
if (helpTooltipElement) {
helpTooltipElement.parentNode.removeChild(helpTooltipElement);
}
helpTooltipElement = document.createElement('div');
helpTooltipElement.className = 'ol-tooltip hidden';
helpTooltip = new Overlay({
element: helpTooltipElement,
offset: [15, 0],
positioning: 'center-left',
});
}

/**
* Creates a new measure tooltip
*/
function createMeasureTooltip() {
if (measureTooltipElement) {
measureTooltipElement.parentNode.removeChild(measureTooltipElement);
}
measureTooltipElement = document.createElement('div');
measureTooltipElement.className = 'ol-tooltip ol-tooltip-measure';
measureTooltip = new Overlay({
element: measureTooltipElement,
offset: [0, -15],
positioning: 'bottom-center',
stopEvent: false,
insertFirst: false,
});
}

/**
* Let user change the geometry type.
*/
typeSelect.onchange = function () {
map.removeInteraction(draw);
};

``````
##### index.html
``````<!DOCTYPE html>
<html lang="en">
<meta charset="UTF-8">
<title>Measure</title>
<style>
.map {
width: 100%;
height: 400px;
}
.ol-tooltip {
position: relative;
background: rgba(0, 0, 0, 0.5);
color: white;
opacity: 0.7;
white-space: nowrap;
font-size: 12px;
cursor: default;
user-select: none;
}
.ol-tooltip-measure {
opacity: 1;
font-weight: bold;
}
.ol-tooltip-static {
background-color: #ffcc33;
color: black;
border: 1px solid white;
}
.ol-tooltip-measure:before,
.ol-tooltip-static:before {
border-top: 6px solid rgba(0, 0, 0, 0.5);
border-right: 6px solid transparent;
border-left: 6px solid transparent;
content: "";
position: absolute;
bottom: -6px;
margin-left: -7px;
left: 50%;
}
.ol-tooltip-static:before {
border-top-color: #ffcc33;
}
</style>
<body>
<div id="map" class="map"></div>
<form>
<label for="type">Measurement type &nbsp;</label>
<select id="type">
<option value="length">Length (LineString)</option>
<option value="area">Area (Polygon)</option>
</select>
</form>

<script type="module" src="main.js"></script>
</body>
</html>``````
##### package.json
``````{
"name": "measure",
"dependencies": {
"ol": "9.2.4"
},
"devDependencies": {
"vite": "^3.2.3"
},
"scripts": {
"start": "vite",
"build": "vite build"
}
}``````