Skip to content

Interactive interface for browsing global, full-resolution satellite imagery

11.0 KB
Raw Blame
/* eslint-disable new-cap */
import { useEffect, useRef } from 'react';
import { createRoot } from 'react-dom/client';
import PropTypes from 'prop-types';
import { connect } from 'react-redux';
import { unByKey as OlObservableUnByKey } from 'ol/Observable';
import Overlay from 'ol/Overlay';
import {
  LineString as OlLineString,
  Polygon as OlGeomPolygon,
} from 'ol/geom';
import { Draw as OlInteractionDraw } from 'ol/interaction';
import { Vector as OlVectorLayer } from 'ol/layer';
import { Vector as OlVectorSource } from 'ol/source';
import {
  Circle as OlStyleCircle,
  Fill as OlStyleFill,
  Stroke as OlStyleStroke,
  Style as OlStyle,
} from 'ol/style';
import { transform } from 'ol/proj';
import {
  toggleMeasureActive as toggleMeasureActiveAction,
  updateMeasurements as updateMeasurementsAction,
} from '../../modules/measure/actions';
import {
  transformLineStringArc,
  transformPolygonArc,
  downloadGeoJSON,
} from '../measure-tool/util';
import MeasureTooltip from '../measure-tool/measure-tooltip';
import util from '../../util/util';
import {
  MEASURE_DISTANCE,
  MEASURE_AREA,
  MEASURE_CLEAR,
  MEASURE_DOWNLOAD_GEOJSON,
  MAP_DISABLE_CLICK_ZOOM,
  MAP_ENABLE_CLICK_ZOOM,
} from '../../util/constants';
import { areCoordinatesWithinExtent } from '../../modules/location-search/util';
import { CRS } from '../../modules/map/constants';

const { events } = util;

let tooltipElement;
let tooltipOverlay;
let init = false;
const allMeasurements = {};
const vectorLayers = {};
const sources = {};
let draw;

/**
 * A component to add measurement functionality to the OL map
 */
function OlMeasureTool (props) {
  let drawChangeListener;
  let rightClickListener;
  let twoFingerTouchListener;
  const root = useRef([]);

  const {
    map, olMap, crs, unitOfMeasure, toggleMeasureActive, updateMeasurements, projections, proj,
  } = props;

  const areaBgFill = new OlStyleFill({
    color: 'rgba(213, 78, 33, 0.1)',
  });

  const solidBlackLineStroke = new OlStyleStroke({
    color: 'rgba(0, 0, 0, 1)',
    lineJoin: 'round',
    width: 5,
  });

  function usePrevious(data) {
    const ref = useRef();
    useEffect(() => {
      ref.current = data;
    }, [data]);
    return ref.current;
  }

  const previousCrs = usePrevious(crs);

  /**
   * End the current measurement interaction & remove the visual representation from the map
   */
  const terminateDraw = (olMapToTerminate = olMap) => {
    tooltipElement = null;
    toggleMeasureActive(false);
    olMapToTerminate.removeInteraction(draw);
    OlObservableUnByKey(drawChangeListener);
    OlObservableUnByKey(rightClickListener);
    OlObservableUnByKey(twoFingerTouchListener);
    events.trigger(MAP_ENABLE_CLICK_ZOOM);
  };

  /**
   * Call the appropriate transform function to add great circle arcs to
   * lines and polygon edges.  Otherwise pass through unaffected.
   * @param {*} feature
   */
  const styleGeometryFn = (feature) => {
    const geometry = feature.getGeometry();
    if (geometry instanceof OlLineString) {
      return transformLineStringArc(geometry, crs);
    }
    if (geometry instanceof OlGeomPolygon) {
      return transformPolygonArc(geometry, crs);
    }
    return geometry;
  };

  const vectorStyles = [
    new OlStyle({
      fill: areaBgFill,
      stroke: solidBlackLineStroke,
      geometry: styleGeometryFn,
    }),
    new OlStyle({
      stroke: new OlStyleStroke({
        color: '#fff',
        lineJoin: 'round',
        width: 2,
      }),
      geometry: styleGeometryFn,
    }),
  ];

  const drawStyles = [
    new OlStyle({
      fill: areaBgFill,
      stroke: solidBlackLineStroke,
      geometry: styleGeometryFn,
    }),
    new OlStyle({
      stroke: new OlStyleStroke({
        color: '#fff',
        lineDash: [10, 20],
        lineJoin: 'round',
        width: 2,
      }),
      image: new OlStyleCircle({
        radius: 7,
        stroke: new OlStyleStroke({
          color: 'rgba(0, 0, 0, 0.7)',
        }),
        fill: new OlStyleFill({
          color: 'rgba(255, 255, 255, 0.3)',
        }),
      }),
      geometry: styleGeometryFn,
    }),
  ];

  const renderTooltip = (feature, overlay) => {
    const removeFeature = () => {
      sources[crs].removeFeature(feature);
      olMap.removeOverlay(overlay);
      delete allMeasurements[crs][feature.ol_uid];
      updateMeasurements(allMeasurements);
    };

    root.current[overlay.ol_uid].render(
      (
        <MeasureTooltip
          active={!!tooltipElement}
          geometry={feature.getGeometry()}
          crs={crs}
          unitOfMeasure={unitOfMeasure}
          onRemove={removeFeature}
          olMap={olMap}
          proj={proj}
        />
      ),
    );
  };

  const drawStartCallback = ({ feature }) => {
    let tooltipCoord;
    events.trigger(MAP_DISABLE_CLICK_ZOOM);
    drawChangeListener = feature.getGeometry().on('change', (e) => {
      const geom = e.target;
      if (geom instanceof OlGeomPolygon) {
        tooltipCoord = geom.getInteriorPoint().getCoordinates();
      } else if (geom instanceof OlLineString) {
        tooltipCoord = geom.getLastCoordinate();
      }
      renderTooltip(feature, tooltipOverlay);
      tooltipOverlay.setPosition(tooltipCoord);
    });
  };

  const drawEndCallback = ({ feature }) => {
    tooltipOverlay.setOffset([0, -7]);
    allMeasurements[crs][feature.ol_uid] = {
      feature,
      overlay: tooltipOverlay,
    };
    updateMeasurements(allMeasurements);
    terminateDraw();
    renderTooltip(feature, tooltipOverlay);
  };

  /**
   * Initiate a measurement interaction of the given measureType ('distance' or 'area')
   * @param {String} measureType
   */
  function initMeasurement (measureType) {
    const type = measureType === 'area' ? 'Polygon' : 'LineString';
    const source = sources[crs];
    if (draw) {
      olMap.removeInteraction(draw);
    }
    draw = new OlInteractionDraw({
      source,
      type,
      style: drawStyles,
      condition(e) {
        const pixel = [e.originalEvent.x, e.originalEvent.y];
        const coord = olMap.getCoordinateFromPixel(pixel);
        const tCoord = transform(coord, crs, CRS.GEOGRAPHIC);
        return areCoordinatesWithinExtent(proj, tCoord);
      },
    });
    olMap.addInteraction(draw);
    if (!vectorLayers[crs]) {
      vectorLayers[crs] = new OlVectorLayer({
        source,
        style: vectorStyles,
        map: olMap,
      });
    }
    toggleMeasureActive(true);

    tooltipElement = document.createElement('div');
    tooltipOverlay = new Overlay({
      element: tooltipElement,
      offset: [0, -15],
      positioning: 'bottom-center',
      stopEvent: false,
    });
    olMap.addOverlay(tooltipOverlay);

    draw.on('drawstart', drawStartCallback);
    draw.on('drawend', drawEndCallback);
    rightClickListener = olMap.on('contextmenu', (evt) => {
      evt.preventDefault();
      terminateDraw();
      olMap.removeOverlay(tooltipOverlay);
    });
  }

  const initDistanceMeasurement = () => initMeasurement('distance');
  const initAreaMeasurement = () => initMeasurement('area');

  /**
   * Clear all existing measurements on the current map projection
   */
  function clearMeasurements () {
    Object.values(allMeasurements[crs]).forEach(
      ({ feature, overlay }) => {
        olMap.removeOverlay(overlay);
        sources[crs].removeFeature(feature);
      },
    );

    allMeasurements[crs] = {};
    updateMeasurements(allMeasurements);
    terminateDraw();
    olMap.removeOverlay(tooltipOverlay);
    if (vectorLayers[crs]) {
      vectorLayers[crs].setMap(null);
      vectorLayers[crs] = null;
    }
  }

  // Monitor for projection change &
  // terminate any incomplete measurement from the previous projection
  useEffect(() => {
    if (olMap != null) {
      const regionFromCrs = {
        [CRS.GEOGRAPHIC]: 'geographic',
        [CRS.ARCTIC]: 'arctic',
        [CRS.ANTARCTIC]: 'antarctic',
      };

      const geographyToTerminate = regionFromCrs[previousCrs];
      terminateDraw(map.ui.proj[geographyToTerminate]);

      if (document.getElementsByClassName('tooltip-active').length > 0) {
        map.ui.proj[geographyToTerminate].removeOverlay(tooltipOverlay);
      }
    }
  }, [crs]);

  useEffect(() => {
    if (!init) {
      projections.forEach((key) => {
        allMeasurements[key] = {};
        vectorLayers[key] = null;
        sources[key] = new OlVectorSource({ wrapX: false });
      });
      init = true;
    }
  }, [projections]);

  useEffect(() => {
    const dlGeoJSON = () => downloadGeoJSON(allMeasurements[crs], crs);

    if (map && map.rendered) {
      events.on(MEASURE_DISTANCE, initDistanceMeasurement);
      events.on(MEASURE_AREA, initAreaMeasurement);
      events.on(MEASURE_CLEAR, clearMeasurements);
      events.on(MEASURE_DOWNLOAD_GEOJSON, dlGeoJSON);
    }
    return () => {
      if (map && map.rendered) {
        events.off(MEASURE_DISTANCE, initDistanceMeasurement);
        events.off(MEASURE_AREA, initAreaMeasurement);
        events.off(MEASURE_CLEAR, clearMeasurements);
        events.off(MEASURE_DOWNLOAD_GEOJSON, dlGeoJSON);
      }
    };
  }, [map, unitOfMeasure]);

  useEffect(() => {
    if (!tooltipOverlay) return;
    root.current[tooltipOverlay.ol_uid] = createRoot(tooltipOverlay.getElement());
  }, [tooltipOverlay]);

  /**
   * Go through every tooltip and recalculate the measurement based on
   * current settings of unit of measurement
   */
  function recalculateAllMeasurements() {
    Object.values(allMeasurements).forEach((measurementsForProj) => {
      Object.values(measurementsForProj).forEach(
        ({ feature, overlay }) => {
          renderTooltip(feature, overlay);
          feature.getGeometry().changed();
          overlay.setOffset([0, -7]);
        },
      );
    });
  }

  useEffect(recalculateAllMeasurements, [unitOfMeasure]);

  useEffect(recalculateAllMeasurements, [crs]);

  // we need this to make sure we have the latest version of olMap in renderToolTip()
  useEffect(recalculateAllMeasurements, [olMap]);

  return null;
}

OlMeasureTool.propTypes = {
  map: PropTypes.oneOfType([PropTypes.object, PropTypes.oneOf(['null'])]),
  olMap: PropTypes.oneOfType([PropTypes.object, PropTypes.oneOf(['null'])]),
  crs: PropTypes.string,
  toggleMeasureActive: PropTypes.func,
  unitOfMeasure: PropTypes.string,
  updateMeasurements: PropTypes.func,
  projections: PropTypes.oneOfType([PropTypes.array, PropTypes.oneOf(['null'])]),
  proj: PropTypes.oneOfType([PropTypes.object, PropTypes.oneOf(['null'])]),
};

const mapDispatchToProps = (dispatch) => ({
  toggleMeasureActive: (isActive) => {
    dispatch(toggleMeasureActiveAction(isActive));
  },
  updateMeasurements: (measurements) => {
    dispatch(updateMeasurementsAction(measurements));
  },
});

const mapStateToProps = (state) => {
  const {
    map,
    proj,
    measure,
    config,
  } = state;
  const { unitOfMeasure } = measure;
  const { crs } = proj.selected;
  const projections = Object.keys(config.projections).map((key) => config.projections[key].crs);
  return {
    map,
    olMap: map.ui.selected,
    crs,
    unitOfMeasure,
    projections,
    proj,
  };
};

export default connect(
  mapStateToProps,
  mapDispatchToProps,
)(OlMeasureTool);