Skip to content

Interactive interface for browsing global, full-resolution satellite imagery

WV-2202: Disallow context menu outside map extent (#3939)

Jason Kent5c661ed34f9c
diff --git a/web/js/components/context-menu/context-menu.js b/web/js/components/context-menu/context-menu.js
index 8703a23d1..23414422f 100644
--- a/web/js/components/context-menu/context-menu.js
+++ b/web/js/components/context-menu/context-menu.js
@@ -6,10 +6,12 @@ import { faToggleOff, faToggleOn } from '@fortawesome/free-solid-svg-icons';
import { ContextMenu, MenuItem } from 'react-contextmenu';
import copy from 'copy-to-clipboard';
import { transform } from 'ol/proj';
+
import util from '../../util/util';
import CopyClipboardTooltip from '../location-search/copy-tooltip';
import { changeUnits } from '../../modules/measure/actions';
-import { getFormattedCoordinates } from '../location-search/util';
+import { getFormattedCoordinates, getNormalizedCoordinate } from '../location-search/util';
+import { areCoordinatesWithinExtent } from '../../modules/location-search/util';
const { events } = util;
@@ -19,22 +21,27 @@ function RightClickMenu(props) {
const [toolTipToggleTime, setToolTipToggleTime] = useState(0);
const [formattedCoordinates, setFormattedCoordinates] = useState();
const {
- map, crs, unitOfMeasure, onToggleUnits, isCoordinateSearchActive, allMeasurements, measurementIsActive,
+ map, proj, unitOfMeasure, onToggleUnits, isCoordinateSearchActive, allMeasurements, measurementIsActive,
} = props;
- const [getMap, setMap] = useState(map);
+ const { crs } = proj.selected;
const measurementsInProj = !!Object.keys(allMeasurements[crs]).length;
-
const handleClick = () => (show ? setShow(false) : null);
- function handleContextEvent(event, olMap) {
+ function handleContextEvent(event) {
if (measurementIsActive) return;
event.originalEvent.preventDefault();
- const coord = olMap.getCoordinateFromPixel(event.pixel);
- const [lon, lat] = transform(coord, crs, 'EPSG:4326');
- setPixelCoords({ pixel: event.pixel });
- setFormattedCoordinates(getFormattedCoordinates(lat, lon).join(','));
- setMap(olMap);
- setShow(true);
+ const coord = map.getCoordinateFromPixel(event.pixel);
+ const tCoord = transform(coord, crs, 'EPSG:4326');
+ const [lon, lat] = getNormalizedCoordinate(tCoord);
+
+ if (areCoordinatesWithinExtent(proj, [lon, lat])) {
+ const fCoord = getFormattedCoordinates([lat, lon]);
+ setFormattedCoordinates(fCoord);
+ setPixelCoords({ pixel: event.pixel });
+ setShow(true);
+ } else {
+ setShow(false);
+ }
}
function copyCoordsToClipboard() {
@@ -54,8 +61,8 @@ function RightClickMenu(props) {
events.trigger(`measure:${action}`);
}
- function addPlaceMarkerHandler(coords, olMap, crsData) {
- events.trigger('context-menu:location', coords, olMap, crsData);
+ function addPlaceMarkerHandler(coords, olMap, crs) {
+ events.trigger('context-menu:location', coords, olMap, crs);
setShow(false);
}
@@ -78,65 +85,61 @@ function RightClickMenu(props) {
};
});
- if (show) {
- return (
- <div id="context-menu">
- <CopyClipboardTooltip
- tooltipToggleTime={toolTipToggleTime}
- clearCopyToClipboardTooltip={() => {}}
- placement="top"
- />
- <ContextMenu id="context-menu-trigger">
- <MenuItem
- onClick={() => copyCoordsToClipboard()}
- attributes={{ id: 'context-menu-copy' }}
- >
- <span id="copy-coordinates-to-clipboard-button">
- {formattedCoordinates}
- </span>
- </MenuItem>
- <MenuItem
- onClick={() => addPlaceMarkerHandler(pixelCoords, getMap, crs)}
- attributes={{ id: 'context-menu-add-marker' }}
- >
- Add Place Marker
- </MenuItem>
- <MenuItem divider />
- <MenuItem
- onClick={() => handleMeasurementMenu('distance')}
- attributes={{ id: 'context-menu-measure-distance' }}
- >
- Measure Distance
- </MenuItem>
- <MenuItem
- onClick={() => handleMeasurementMenu('area')}
- attributes={{ id: 'context-menu-measure-area' }}
- >
- Measure Area
- </MenuItem>
- {measurementsInProj
- && (
- <MenuItem
- onClick={() => handleMeasurementMenu('clear')}
- attributes={{ id: 'context-menu-clear-measurements' }}
- >
- Remove Measurements
- </MenuItem>
- )}
- <MenuItem
- onClick={() => handleMeasurementMenu('units')}
- attributes={{ id: 'context-menu-change-units' }}
- >
- Change Units to
- {' '}
- {oppositeUnitOfMeasure().oppositeUnit}
- </MenuItem>
- </ContextMenu>
- </div>
- );
- }
-
- return <></>;
+ return show && (
+ <div id="context-menu">
+ <CopyClipboardTooltip
+ tooltipToggleTime={toolTipToggleTime}
+ clearCopyToClipboardTooltip={() => {}}
+ placement="top"
+ />
+ <ContextMenu id="context-menu-trigger">
+ <MenuItem
+ onClick={() => copyCoordsToClipboard()}
+ attributes={{ id: 'context-menu-copy' }}
+ >
+ <span id="copy-coordinates-to-clipboard-button">
+ {formattedCoordinates}
+ </span>
+ </MenuItem>
+ <MenuItem
+ onClick={() => addPlaceMarkerHandler(pixelCoords, map, crs)}
+ attributes={{ id: 'context-menu-add-marker' }}
+ >
+ Add Place Marker
+ </MenuItem>
+ <MenuItem divider />
+ <MenuItem
+ onClick={() => handleMeasurementMenu('distance')}
+ attributes={{ id: 'context-menu-measure-distance' }}
+ >
+ Measure Distance
+ </MenuItem>
+ <MenuItem
+ onClick={() => handleMeasurementMenu('area')}
+ attributes={{ id: 'context-menu-measure-area' }}
+ >
+ Measure Area
+ </MenuItem>
+ {measurementsInProj
+ && (
+ <MenuItem
+ onClick={() => handleMeasurementMenu('clear')}
+ attributes={{ id: 'context-menu-clear-measurements' }}
+ >
+ Remove Measurements
+ </MenuItem>
+ )}
+ <MenuItem
+ onClick={() => handleMeasurementMenu('units')}
+ attributes={{ id: 'context-menu-change-units' }}
+ >
+ Change Units to
+ {' '}
+ {oppositeUnitOfMeasure().oppositeUnit}
+ </MenuItem>
+ </ContextMenu>
+ </div>
+ );
}
function mapStateToProps(state) {
@@ -144,11 +147,10 @@ function mapStateToProps(state) {
map, proj, measure, locationSearch, config,
} = state;
const { unitOfMeasure, allMeasurements, isActive } = measure;
- const { crs } = proj.selected;
const { coordinates, isCoordinateSearchActive } = locationSearch;
return {
- map,
- crs,
+ map: map.ui.selected,
+ proj,
unitOfMeasure,
allMeasurements,
measurementIsActive: isActive,
@@ -165,7 +167,7 @@ const mapDispatchToProps = (dispatch) => ({
});
RightClickMenu.propTypes = {
map: PropTypes.object,
- crs: PropTypes.string,
+ proj: PropTypes.object,
unitOfMeasure: PropTypes.string,
onToggleUnits: PropTypes.func,
isCoordinateSearchActive: PropTypes.bool,
diff --git a/web/js/components/location-search/coordinates-dialog.js b/web/js/components/location-search/coordinates-dialog.js
index 14be56b32..4f1bc09d9 100644
--- a/web/js/components/location-search/coordinates-dialog.js
+++ b/web/js/components/location-search/coordinates-dialog.js
@@ -5,6 +5,7 @@ import { UncontrolledTooltip } from 'reactstrap';
import copy from 'copy-to-clipboard';
import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
import CopyClipboardTooltip from './copy-tooltip';
+import { getFormattedCoordinates } from './util';
class CoordinatesDialog extends Component {
constructor(props) {
@@ -125,19 +126,20 @@ class CoordinatesDialog extends Component {
// render copy to clipboard button
renderCopyToClipboardButton = () => {
- const { coordinatesMetadata, isMobile } = this.props;
- const { coordinates } = coordinatesMetadata;
+ const { coordinates, isMobile } = this.props;
const { isCopyToClipboardTooltipVisible, showTooltips } = this.state;
const buttonId = 'copy-coordinates-to-clipboard-button';
const labelText = 'Copy coordinates to clipboard';
const tooltipVisibilityCondition = !isMobile && !isCopyToClipboardTooltipVisible && showTooltips;
+ const formattedCoords = getFormattedCoordinates(coordinates);
+
return (
<div
id={buttonId}
className={buttonId}
- onClick={() => this.copyToClipboard(coordinates)}
- onTouchEnd={() => this.copyToClipboard(coordinates)}
+ onClick={() => this.copyToClipboard(formattedCoords)}
+ onTouchEnd={() => this.copyToClipboard(formattedCoords)}
>
{tooltipVisibilityCondition && (
<UncontrolledTooltip
@@ -155,28 +157,28 @@ class CoordinatesDialog extends Component {
render() {
const {
- coordinatesMetadata, tooltipId,
+ tooltipId,
+ coordinates,
+ title,
} = this.props;
const {
showTooltips,
tooltipToggleTime,
} = this.state;
- const {
- coordinates,
- title,
- } = coordinatesMetadata;
+
+ const formattedCoords = getFormattedCoordinates(coordinates);
return (
<div className={`tooltip-custom-black tooltip-static tooltip-coordinates-container ${tooltipId}`}>
{showTooltips && (
- <CopyClipboardTooltip
- tooltipToggleTime={tooltipToggleTime}
- clearCopyToClipboardTooltip={this.clearCopyToClipboardTooltip}
- placement="bottom"
- />
+ <CopyClipboardTooltip
+ tooltipToggleTime={tooltipToggleTime}
+ clearCopyToClipboardTooltip={this.clearCopyToClipboardTooltip}
+ placement="bottom"
+ />
)}
<div className="tooltip-coordinates-title">{title}</div>
- <div className="tooltip-coordinates">{coordinates}</div>
+ <div className="tooltip-coordinates">{formattedCoords}</div>
{this.renderDialogButtonControls()}
{this.renderCopyToClipboardButton()}
</div>
@@ -188,7 +190,8 @@ export default CoordinatesDialog;
CoordinatesDialog.propTypes = {
removeMarker: PropTypes.func,
removeCoordinatesDialog: PropTypes.func,
- coordinatesMetadata: PropTypes.object,
+ title: PropTypes.string,
+ coordinates: PropTypes.string,
isMobile: PropTypes.bool,
tooltipId: PropTypes.string,
};
diff --git a/web/js/components/location-search/location-marker.js b/web/js/components/location-search/location-marker.js
index 0fd0a5e77..1bedc5942 100644
--- a/web/js/components/location-search/location-marker.js
+++ b/web/js/components/location-search/location-marker.js
@@ -2,22 +2,44 @@ import React, { useState } from 'react';
import PropTypes from 'prop-types';
import CoordinatesDialog from './coordinates-dialog';
import util from '../../util/util';
-import { getCoordinatesMetadata } from './ol-coordinates-marker-util';
+
+const getDialogTitle = (geocodeProperties) => {
+ const { address, error } = geocodeProperties;
+ let title;
+ if (address && !error) {
+ /* eslint-disable camelcase */
+ const {
+ Match_addr,
+ City,
+ Region,
+ Subregion,
+ } = address;
+ if (City && Region) {
+ title = `${City}, ${Region}`;
+ } else if (Subregion && Region) {
+ title = `${Subregion}, ${Region}`;
+ } else {
+ title = `${Match_addr}`;
+ }
+ }
+ return title;
+};
export default function LocationMarker ({
reverseGeocodeResults, removeMarker, coordinatesObject, isMobile, dialogVisible = true,
}) {
const { longitude, latitude } = coordinatesObject;
const tooltipId = util.encodeId(`coordinates-map-marker_${longitude},${latitude}`);
- const geocodeProperties = { latitude, longitude, reverseGeocodeResults };
- const coordinatesMetadata = getCoordinatesMetadata(geocodeProperties);
+ const coordinates = [latitude, longitude];
+ const title = getDialogTitle(reverseGeocodeResults);
const [showDialog, setShowDialog] = useState(dialogVisible);
return (
<div className="location-dialog-pin-wrapper ">
{showDialog && (
<CoordinatesDialog
- coordinatesMetadata={coordinatesMetadata}
+ title={title}
+ coordinates={coordinates}
removeMarker={removeMarker}
removeCoordinatesDialog={() => setShowDialog(false)}
isMobile={isMobile}
diff --git a/web/js/components/location-search/location-search-modal.js b/web/js/components/location-search/location-search-modal.js
index b5c4cf57d..d05811bd0 100644
--- a/web/js/components/location-search/location-search-modal.js
+++ b/web/js/components/location-search/location-search-modal.js
@@ -13,7 +13,7 @@ import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
import SearchBox from './location-search-input';
import Alert from '../util/alert';
import HoverTooltip from '../util/hover-tooltip';
-import { getCoordinateFixedPrecision, isValidCoordinates } from './util';
+import { isValidCoordinates } from './util';
import {
clearSuggestions,
getSuggestions,
@@ -158,17 +158,14 @@ class LocationSearchModal extends Component {
const firstCandidate = result.candidates[0];
const { location, attributes } = firstCandidate;
const addressAttributes = { address: attributes };
-
const { x, y } = location;
- const parsedX = getCoordinateFixedPrecision(x);
- const parsedY = getCoordinateFixedPrecision(y);
- const coordinatesWithinExtent = isCoordinatePairWithinExtent([parsedX, parsedY]);
+ const coordinatesWithinExtent = isCoordinatePairWithinExtent([x, y]);
if (!coordinatesWithinExtent) {
this.setExtentAlert(true);
this.setInputAlertIcon(true);
} else {
- setPlaceMarker([parsedX, parsedY], addressAttributes);
+ setPlaceMarker([x, y], addressAttributes);
}
}
}).catch((error) => console.error(error));
diff --git a/web/js/components/location-search/ol-coordinates-marker-util.js b/web/js/components/location-search/ol-coordinates-marker-util.js
deleted file mode 100644
index cee26e402..000000000
--- a/web/js/components/location-search/ol-coordinates-marker-util.js
+++ /dev/null
@@ -1,54 +0,0 @@
-/* eslint-disable import/prefer-default-export */
-import { getFormattedCoordinates } from './util';
-
-/**
- * getCoordinatesDialogTitle
- *
- * @param {Object} geocodeProperties | address, error
- *
- * @returns {String | undefined} title
- */
-const getCoordinatesDialogTitle = (geocodeProperties) => {
- const { address, error } = geocodeProperties;
- let title;
- if (address && !error) {
- /* eslint-disable camelcase */
- const {
- Match_addr,
- City,
- Region,
- Subregion,
- } = address;
- if (City && Region) {
- title = `${City}, ${Region}`;
- } else if (Subregion && Region) {
- title = `${Subregion}, ${Region}`;
- } else {
- title = `${Match_addr}`;
- }
- }
- return title;
-};
-
-/**
- * getCoordinatesMetadata for tooltip display
- *
- * @param {Object} geocodeProperties
- *
- * @returns {Object} coordinatesMetadata
- */
-export const getCoordinatesMetadata = (geocodeProperties) => {
- const { latitude, longitude, reverseGeocodeResults } = geocodeProperties;
-
- // get formatted coordinates
- const [formattedLatitude, formattedLongitude] = getFormattedCoordinates(latitude, longitude);
-
- // build title based on available parameters
- const title = getCoordinatesDialogTitle(reverseGeocodeResults, formattedLatitude, formattedLongitude);
- const coordinates = `${formattedLatitude.trim()}, ${formattedLongitude.trim()}`;
-
- return {
- coordinates,
- title: title || coordinates,
- };
-};
diff --git a/web/js/components/location-search/ol-coordinates-marker.js b/web/js/components/location-search/ol-coordinates-marker.js
index 4e5752d8a..553925c0f 100644
--- a/web/js/components/location-search/ol-coordinates-marker.js
+++ b/web/js/components/location-search/ol-coordinates-marker.js
@@ -1,7 +1,4 @@
import { connect } from 'react-redux';
-import {
- isNaN as lodashIsNaN,
-} from 'lodash';
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import { transform } from 'ol/proj';
@@ -9,9 +6,9 @@ import Alert from '../util/alert';
import {
setPlaceMarker, toggleReverseGeocodeActive,
} from '../../modules/location-search/actions';
+import { getNormalizedCoordinate } from './util';
import { areCoordinatesWithinExtent } from '../../modules/location-search/util';
import { reverseGeocode } from '../../modules/location-search/util-api';
-import { getCoordinateFixedPrecision } from './util';
import util from '../../util/util';
const { events } = util;
@@ -59,27 +56,21 @@ export class CoordinatesMarker extends Component {
config,
proj,
setPlaceMarker,
- toggleReverseGeocodeActive,
} = this.props;
// handle reverse geocoding mouse click
const pixels = e.pixel;
const coord = map.getCoordinateFromPixel(pixels);
- const [lon, lat] = transform(coord, crs, 'EPSG:4326');
- const latitude = getCoordinateFixedPrecision(lat);
- const longitude = getCoordinateFixedPrecision(lon);
-
- // show alert warning and exit mode if outside current map extent
- const validNums = !lodashIsNaN(parseFloat(latitude)) && !lodashIsNaN(parseFloat(longitude));
- const withinExtent = areCoordinatesWithinExtent(proj, [longitude, latitude]);
- if (!validNums || !withinExtent) {
+ const tCoord = transform(coord, crs, 'EPSG:4326');
+ const [lon, lat] = getNormalizedCoordinate(tCoord);
+
+ if (!areCoordinatesWithinExtent(proj, [lon, lat])) {
this.setState({ showExtentAlert: true });
- toggleReverseGeocodeActive(false);
return;
}
- // get available reverse geocoding for coordinates and fly to point
- reverseGeocode([longitude, latitude], config).then((results) => {
- setPlaceMarker([longitude, latitude], results);
+
+ reverseGeocode([lon, lat], config).then((results) => {
+ setPlaceMarker(tCoord, results);
});
this.setState({ showExtentAlert: false });
}
@@ -140,9 +131,9 @@ const mapDispatchToProps = (dispatch) => ({
CoordinatesMarker.propTypes = {
config: PropTypes.object.isRequired,
isCoordinateSearchActive: PropTypes.bool.isRequired,
- proj: PropTypes.object,
setPlaceMarker: PropTypes.func.isRequired,
toggleReverseGeocodeActive: PropTypes.func.isRequired,
+ proj: PropTypes.object,
};
export default connect(
mapStateToProps,
diff --git a/web/js/components/location-search/util.js b/web/js/components/location-search/util.js
index b933d06ce..b714cf1bb 100644
--- a/web/js/components/location-search/util.js
+++ b/web/js/components/location-search/util.js
@@ -16,30 +16,30 @@ export function isValidCoordinates(position) {
}
/**
- * Get fixed precision coordinate number
- * @param {String} coordinate
- * @returns {Number} parsed coordinate with fixed precision
+ * * Normalize coordinates to be within the [-180, 180] range
+ * @param {*} coordindates
+ * @returns
*/
-export const getCoordinateFixedPrecision = (coordinate) => Number(coordinate.toFixed(4));
+export function getNormalizedCoordinate([lon, lat]) {
+ if (Math.abs(lon) < 180) {
+ return [lon, lat];
+ }
+ const isNegative = lon < 0;
+ const remainder = lon % 360;
+ const longitude = isNegative && remainder < -180 ? remainder + 360 : !isNegative && remainder > 180 ? remainder - 360 : remainder;
+ return [longitude, lat];
+}
/**
- * getFormattedCoordinates
+ * Trucate to 4 decimal places, normalize, and format based on user preference
*
- * @param {String} latitude
- * @param {String} longitude
- *
- * @returns {Array} formattedCoordinates
+ * @param {Array} coordinates
+ * @returns {Array}
*/
-export const getFormattedCoordinates = (latitude, longitude) => {
- const parsedLatitude = getCoordinateFixedPrecision(latitude);
- const parsedLongitude = getCoordinateFixedPrecision(longitude);
-
- // format coordinates based on localStorage preference
+export const getFormattedCoordinates = ([latitude, longitude]) => {
+ const [lon, lat] = getNormalizedCoordinate([longitude, latitude]);
+ const fixedLat = Number(Number(lat).toFixed(4));
+ const fixedLon = Number(Number(lon).toFixed(4));
const format = util.getCoordinateFormat();
- const coordinates = util.formatCoordinate(
- [parsedLongitude, parsedLatitude],
- format,
- );
- const formattedCoordinates = coordinates.split(',');
- return formattedCoordinates;
+ return util.formatCoordinate([fixedLon, fixedLat], format);
};
diff --git a/web/js/components/map/ol-coordinates.js b/web/js/components/map/ol-coordinates.js
index bc46755c2..75f5bd52f 100644
--- a/web/js/components/map/ol-coordinates.js
+++ b/web/js/components/map/ol-coordinates.js
@@ -7,6 +7,7 @@ import { transform } from 'ol/proj';
import { UncontrolledTooltip } from 'reactstrap';
import Coordinates from './coordinates';
import util from '../../util/util';
+import { getNormalizedCoordinate } from '../location-search/util';
const { events } = util;
const getContainerWidth = (format) => {
@@ -62,8 +63,7 @@ export default class OlCoordinates extends React.Component {
}
if (Math.abs(lon) > 180) {
if (crs === 'EPSG:4326' && Math.abs(lon) < 250) {
- lon = util.normalizeWrappedLongitude(lon);
- pcoord = [lon, lat];
+ pcoord = getNormalizedCoordinate([lon, lat]);
} else {
this.clearCoord();
return;
diff --git a/web/js/containers/image-download.js b/web/js/containers/image-download.js
index ce3dcd738..4759b21c6 100644
--- a/web/js/containers/image-download.js
+++ b/web/js/containers/image-download.js
@@ -28,6 +28,7 @@ import {
onPanelChange,
updateBoundaries,
} from '../modules/image-download/actions';
+import { getNormalizedCoordinate } from '../components/location-search/util';
const DEFAULT_URL = 'http://localhost:3002/api/v1/snapshot';
@@ -170,8 +171,8 @@ class ImageDownloadContainer extends Component {
proj.selected.resolutions,
);
const viewExtent = mapView.calculateExtent(map.ui.selected.getSize());
- const normalizedBottomLeftLatLong = [util.normalizeWrappedLongitude(bottomLeftLatLong[0]), bottomLeftLatLong[1]];
- const normalizedTopRightLatLong = [util.normalizeWrappedLongitude(topRightLatLong[0]), topRightLatLong[1]];
+ const normalizedBottomLeftLatLong = getNormalizedCoordinate(bottomLeftLatLong);
+ const normalizedTopRightLatLong = getNormalizedCoordinate(topRightLatLong);
return (
<ErrorBoundary>
diff --git a/web/js/map/ui.js b/web/js/map/ui.js
index 688108cfe..6e0622eed 100644
--- a/web/js/map/ui.js
+++ b/web/js/map/ui.js
@@ -39,9 +39,9 @@ import { CHANGE_PROJECTION } from '../modules/projection/constants';
import {
REMOVE_MARKER,
SET_MARKER,
- SET_REVERSE_GEOCODE_RESULTS,
TOGGLE_DIALOG_VISIBLE,
} from '../modules/location-search/constants';
+import { setGeocodeResults, removeMarker } from '../modules/location-search/actions';
import * as dateConstants from '../modules/date/constants';
import util from '../util/util';
import * as layerConstants from '../modules/layers/constants';
@@ -68,10 +68,10 @@ import {
import { getLeadingExtent, promiseImageryForTime } from '../modules/map/util';
import { updateVectorSelection } from '../modules/vector-styles/util';
import { animateCoordinates, getCoordinatesMarker, areCoordinatesWithinExtent } from '../modules/location-search/util';
+import { getNormalizedCoordinate } from '../components/location-search/util';
import { reverseGeocode } from '../modules/location-search/util-api';
import { startLoading, stopLoading, PRELOAD_TILES } from '../modules/loading/actions';
-
const { events } = util;
export default function mapui(models, config, store) {
@@ -354,14 +354,13 @@ export default function mapui(models, config, store) {
const { locationSearch, proj } = state;
const { coordinates } = locationSearch;
removeAllCoordinatesMarkers();
+
if (coordinates && coordinates.length > 0) {
coordinates.forEach((coordinatesObject) => {
const { longitude, latitude } = coordinatesObject;
- const latestCoordinates = [longitude, latitude];
- const areCoordinatesWithinExtentBool = areCoordinatesWithinExtent(proj, latestCoordinates);
- if (!areCoordinatesWithinExtentBool) return;
-
- reverseGeocode(latestCoordinates, config).then((results) => {
+ const coord = [longitude, latitude];
+ if (!areCoordinatesWithinExtent(proj, coord)) return;
+ reverseGeocode(getNormalizedCoordinate(coord), config).then((results) => {
addMarkerAndUpdateStore(true, results, null, coordinatesObject);
});
});
@@ -396,18 +395,12 @@ export default function mapui(models, config, store) {
const results = geocodeResults;
if (!results) return;
- const removeMarker = () => {
- store.dispatch({
- type: REMOVE_MARKER,
- coordinates: coordinatesObject,
- });
- };
-
+ const remove = () => store.dispatch(removeMarker(coordinatesObject));
const marker = getCoordinatesMarker(
proj,
coordinatesObject,
results,
- removeMarker,
+ remove,
browser.lessThan.medium,
showDialog,
);
@@ -425,10 +418,7 @@ export default function mapui(models, config, store) {
flyToMarker(coordinatesObject);
}
- store.dispatch({
- type: SET_REVERSE_GEOCODE_RESULTS,
- value: results,
- });
+ store.dispatch(setGeocodeResults(geocodeResults));
};
const flyToNewExtent = function(extent, rotation) {
diff --git a/web/js/modules/image-download/util.js b/web/js/modules/image-download/util.js
index 6bdf1f6c9..204aa1e88 100644
--- a/web/js/modules/image-download/util.js
+++ b/web/js/modules/image-download/util.js
@@ -2,10 +2,10 @@ import {
each as lodashEach,
get as lodashGet,
} from 'lodash';
+import { transform } from 'ol/proj';
import util from '../../util/util';
import { formatDisplayDate } from '../date/util';
import { nearestInterval } from '../layers/util';
-import { coordinatesCRSTransform } from '../projection/util';
const GEO_ESTIMATION_CONSTANT = 256.0;
const POLAR_ESTIMATION_CONSTANT = 0.002197265625;
@@ -141,7 +141,7 @@ export function getDownloadUrl(url, proj, layerDefs, bbox, dimensions, dateTime,
// handle adding coordinates marker
if (markerCoordinates.length > 0) {
const coords = markerCoordinates.reduce((validCoords, { longitude: lon, latitude: lat }) => {
- const mCoord = coordinatesCRSTransform([lon, lat], 'EPSG:4326', crs);
+ const mCoord = transform([lon, lat], 'EPSG:4326', crs);
// const inExtent = containsCoordinate(boundingExtent(bbox), mCoord);
return validCoords.concat([mCoord[0], mCoord[1]]);
}, []);
diff --git a/web/js/modules/location-search/actions.js b/web/js/modules/location-search/actions.js
index 11fe8b33f..a2bd2eada 100644
--- a/web/js/modules/location-search/actions.js
+++ b/web/js/modules/location-search/actions.js
@@ -1,14 +1,15 @@
import {
CLEAR_SUGGESTIONS,
+ REMOVE_MARKER,
SET_MARKER,
SET_SUGGESTION,
+ SET_REVERSE_GEOCODE_RESULTS,
TOGGLE_DIALOG_VISIBLE,
TOGGLE_REVERSE_GEOCODE,
TOGGLE_SHOW_LOCATION_SEARCH,
} from './constants';
import { requestAction } from '../core/actions';
import {
- areCoordinatesWithinExtent,
setLocalStorageCollapseState,
} from './util';
import {
@@ -58,14 +59,14 @@ export function toggleReverseGeocodeActive(isActive) {
* @param {Object} reverseGeocodeResults
* @param {Boolean} isInputSearch
*/
-export function setPlaceMarker(newCoordinates, reverseGeocodeResults, isInputSearch) {
+export function setPlaceMarker(coord, reverseGeocodeResults, isInputSearch) {
return (dispatch, getState) => {
const state = getState();
const {
- proj,
locationSearch: { coordinates },
} = state;
- const [longitude, latitude] = newCoordinates;
+ const longitude = Number(coord[0].toFixed(4));
+ const latitude = Number(coord[1].toFixed(4));
if (reverseGeocodeResults) {
const { error } = reverseGeocodeResults;
@@ -74,16 +75,8 @@ export function setPlaceMarker(newCoordinates, reverseGeocodeResults, isInputSea
}
}
- const coordinatesWithinExtent = areCoordinatesWithinExtent(proj, newCoordinates);
const markerAlreadyExists = coordinates.find(({ longitude: lon, latitude: lat }) => lon === longitude && lat === latitude);
- if (!coordinatesWithinExtent) {
- return dispatch({
- type: SET_MARKER,
- coordinates: [],
- });
- }
-
if (markerAlreadyExists) {
return dispatch({
type: SET_MARKER,
@@ -107,6 +100,20 @@ export function setPlaceMarker(newCoordinates, reverseGeocodeResults, isInputSea
};
}
+export function removeMarker(coordinates) {
+ return {
+ type: REMOVE_MARKER,
+ coordinates,
+ };
+}
+
+export function setGeocodeResults(results) {
+ return {
+ type: SET_REVERSE_GEOCODE_RESULTS,
+ results,
+ };
+}
+
/**
* Toggle show coordinates dialog
* @param {Boolean} isVisible
diff --git a/web/js/modules/location-search/util.js b/web/js/modules/location-search/util.js
index 62ceac2e7..7862b0df3 100644
--- a/web/js/modules/location-search/util.js
+++ b/web/js/modules/location-search/util.js
@@ -3,11 +3,12 @@ import ReactDOM from 'react-dom';
import update from 'immutability-helper';
import lodashIsNaN from 'lodash/isNaN';
import OlOverlay from 'ol/Overlay';
-import { containsXY } from 'ol/extent';
+import { containsCoordinate } from 'ol/extent';
+import { transform } from 'ol/proj';
import LocationMarker from '../../components/location-search/location-marker';
-import { coordinatesCRSTransform } from '../projection/util';
import safeLocalStorage from '../../util/local-storage';
import { fly } from '../../map/util';
+import { FULL_MAP_EXTENT } from '../map/constants';
const { LOCATION_SEARCH_COLLAPSED } = safeLocalStorage.keys;
@@ -23,7 +24,7 @@ export function animateCoordinates(map, proj, coordinates, zoom) {
let [x, y] = coordinates;
if (proj !== 'geographic') {
- [x, y] = coordinatesCRSTransform(coordinates, 'EPSG:4326', crs);
+ [x, y] = transform(coordinates, 'EPSG:4326', crs);
}
fly(map, proj, [x, y], zoom);
}
@@ -36,13 +37,9 @@ export function animateCoordinates(map, proj, coordinates, zoom) {
*/
export function areCoordinatesWithinExtent(proj, coordinates) {
const { maxExtent, crs } = proj.selected;
- let [x, y] = coordinates;
- if (crs !== 'EPSG:4326') {
- const transformedXY = coordinatesCRSTransform(coordinates, 'EPSG:4326', crs);
- [x, y] = transformedXY;
- }
- const coordinatesWithinExtent = containsXY(maxExtent, x, y);
- return coordinatesWithinExtent;
+ const extent = crs === 'EPSG:4326' ? FULL_MAP_EXTENT : maxExtent;
+ const coord = crs === 'EPSG:4326' ? coordinates : transform(coordinates, 'EPSG:4326', crs);
+ return containsCoordinate(extent, coord);
}
/**
@@ -57,16 +54,10 @@ export function getCoordinatesMarker(proj, coordinatesObject, results, removeMar
const { id, longitude, latitude } = coordinatesObject;
const coordinates = [longitude, latitude];
- // only add marker within current map extent
- const coordinatesWithinExtent = areCoordinatesWithinExtent(proj, coordinates);
- if (!coordinatesWithinExtent) {
- return false;
- }
-
// transform coordinates if not CRS EPSG:4326
let transformedCoords = coordinates;
if (proj !== 'geographic') {
- transformedCoords = coordinatesCRSTransform(coordinates, 'EPSG:4326', crs);
+ transformedCoords = transform(coordinates, 'EPSG:4326', crs);
}
const pinProps = {
diff --git a/web/js/modules/projection/util.js b/web/js/modules/projection/util.js
index 04fe0c7d1..7e6a79266 100644
--- a/web/js/modules/projection/util.js
+++ b/web/js/modules/projection/util.js
@@ -1,17 +1,5 @@
import { get as lodashGet } from 'lodash';
import update from 'immutability-helper';
-import * as olProj from 'ol/proj';
-
-/**
- * Transform coordinates from one projection to another
- *
- * @param {Array} coordinates | longitude, latitude ex: [40.21875, -76.218750]
- * @param {String} inputCRS | coordinate system of coordinates ex: "EPSG:4326"
- * @param {String} targetCRS | target output with transformed cooridnates ex: "EPSG:3031"
- */
-export function coordinatesCRSTransform(coordinates, inputCRS, targetCRS) {
- return olProj.transform(coordinates, inputCRS, targetCRS);
-}
export function getProjInitialState(config) {
const selected = lodashGet(