Interactive interface for browsing global, full-resolution satellite imagery
import { useEffect, useRef } from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux';
import OlLayerGroup from 'ol/layer/Group';
import { isEmpty } from 'ol/extent';
import {
get as lodashGet,
} from 'lodash';
import {
fitToLeadingExtent as fitToLeadingExtentAction,
updateMapUI as updateMapUIAction,
} from '../../../modules/map/actions';
import { getLeadingExtent } from '../../../modules/map/util';
import {
getLayers,
getActiveLayers,
} from '../../../modules/layers/selectors';
import { getSelectedDate } from '../../../modules/date/selectors';
import util from '../../../util/util';
import { fly } from '../../../map/util';
import * as layerConstants from '../../../modules/layers/constants';
import * as compareConstants from '../../../modules/compare/constants';
import * as paletteConstants from '../../../modules/palettes/constants';
import * as vectorStyleConstants from '../../../modules/vector-styles/constants';
import { LOCATION_POP_ACTION } from '../../../redux-location-state-customs';
import { EXIT_ANIMATION, STOP_ANIMATION } from '../../../modules/animation/constants';
import { SET_SCREEN_INFO } from '../../../modules/screen-size/constants';
import { requestPalette as requestPaletteAction } from '../../../modules/palettes/actions';
import usePrevious from '../../../util/customHooks';
import { addTEMPODateRanges as addTEMPODateRangesAction } from '../../../modules/layers/actions';
import { loadLayersWithSlots } from '../../util/util';
function UpdateProjection(props) {
const {
action,
activeLayers,
compare,
compareMapUi,
compareMode,
config,
dateCompareState,
fitToLeadingExtent,
getGranuleOptions,
layerCreationQueue,
isKioskModeActive,
isMobile,
layerState,
map,
models,
preloadForCompareMode,
proj,
projectionTrigger,
updateExtent,
updateLayerVisibilities,
updateMapUI,
ui,
renderedPalettes,
requestPalette,
addTEMPODateRanges,
} = props;
const layerStateRef = useRef(layerState);
useEffect(() => {
layerStateRef.current = layerState;
}, [layerState]);
/**
* Remove Layers from map
*
* @method clearLayers
* @static
*
* @returns {void}
*/
const clearLayers = function(saveCache) {
ui.selected?.setLayers([]);
if (saveCache) return;
ui.cache.clear();
};
/**
* Create a Layergroup given the date and layerGroups when compare mode is activated and
* the group similar layers option is selected.
*
* @method getCompareLayerGroup
* @static
*
* @param {string} compareActiveString
* @param {string} compareDateString
* @param {object} state object representing the layers,
* compare, & proj properties from global state
* @param {object} granuleOptions object representing selected granule layer options
*/
async function getCompareLayerGroup(
[compareActiveString, compareDateString],
state,
granuleOptions,
) {
const { createLayer } = ui;
const compareSideLayers = getActiveLayers(state, compareActiveString);
const layers = getLayers(state, { reverse: true }, compareSideLayers)
.map(async (def) => {
const options = {
...getGranuleOptions(state, def, compareActiveString, granuleOptions),
date: getSelectedDate(dateCompareState, compareDateString),
group: compareActiveString,
};
// Check if the layer contains a palette & load if necessary
if (def.palette) {
requestPalette(def.id);
}
if (def.id.includes('TEMPO')) {
options.tempoCallback = addTEMPODateRanges;
}
return createLayer(def, options);
});
const compareLayerGroup = await Promise.all(layers);
return new OlLayerGroup({
layers: compareLayerGroup,
date: getSelectedDate(dateCompareState, compareDateString),
group: compareActiveString,
});
}
/**
* @method reloadLayers
*
* @param {Object} granuleOptions (optional: only used for granule layers)
* @param {Boolean} granuleDates - array of granule dates
* @param {Boolean} id - layer id
* @returns {void}
*/
async function reloadLayers(granuleOptions, saveCache) {
const mapUI = ui.selected;
const { createLayer } = ui;
if (!config.features.compare || !compare.active) {
const compareMapDestroyed = !compare.active && compareMapUi.active;
if (compareMapDestroyed) {
compareMapUi.destroy();
}
clearLayers(saveCache);
const defs = getLayers(layerStateRef.current, { reverse: true });
// Async loading — each layer renders as soon as it resolves.
await loadLayersWithSlots({
defs,
createLayer,
mapUI,
queue: saveCache ? null : layerCreationQueue,
skipYield: saveCache,
updateLayerVisibilities,
getLayerOptions: (def) => {
const options = getGranuleOptions(
layerStateRef.current,
def,
compare.activeString,
granuleOptions,
);
if (def.id.includes('TEMPO')) {
options.tempoCallback = addTEMPODateRanges;
}
return options;
},
});
return; // Exit early since we've handled the non-compare case
} else {
const stateArray = [['active', 'selected'], ['activeB', 'selectedB']];
if (compare && !compare.isCompareA && compare.mode === 'spy') {
stateArray.reverse(); // Set Layer order based on active A|B group
}
const stateArrayGroups = stateArray
.map(async (arr) => getCompareLayerGroup(arr, layerStateRef.current, granuleOptions));
// Chain onto any in-flight processingPromise so updateDate
// and other async callers wait for this build to finish.
const previousPromise = ui.processingPromise || Promise.resolve();
const compareLoadPromise = previousPromise
.catch(() => {}) // don't let a prior failure block this build
.then(() => Promise.all(stateArrayGroups))
.then((compareLayerGroups) => {
clearLayers(saveCache);
mapUI?.setLayers(compareLayerGroups);
compareMapUi.create(mapUI, compare.mode);
});
ui.processingPromise = compareLoadPromise;
await compareLoadPromise;
// Only clear if we're still the latest — a newer call may have chained on.
if (ui.processingPromise === compareLoadPromise) {
ui.processingPromise = null;
}
}
updateLayerVisibilities();
}
const onStopAnimation = function() {
// Only vector layers need a reload here for style refresh.
// Granule layers are already rebuilt by updateDate via SELECT_DATE.
const hasVectorLayers = activeLayers.some(({ type }) => type === 'vector');
if (hasVectorLayers) {
// Wait for any pending updateDate work before rebuilding.
const waitFor = ui.processingPromise || Promise.resolve();
waitFor.catch(() => {}).then(() => reloadLayers());
}
};
/**
* Hide Map
*
* @method hideMap
* @static
*
* @param {object} mapObj - Openlayers Map obj
*
* @returns {void}
*/
function hideMap(mapObj) {
const el = document.getElementById(`${mapObj.getTarget()}`);
if (el) el.style.display = 'none';
}
/**
* Show Map
*
* @method showMap
* @static
*
* @param {object} map - Openlayers Map obj
*
* @returns {void}
*/
function showMap(mapObj) {
const el = document.getElementById(`${mapObj.getTarget()}`);
if (el) el.style.display = 'block';
}
/**
* When page is resized set for mobile or desktop
*
* @method onResize
* @static
*
* @returns {void}
*/
function onResize() {
const mapUI = ui.selected;
if (isMobile) {
mapUI.removeControl(mapUI.wv.scaleImperial);
mapUI.removeControl(mapUI.wv.scaleMetric);
} else {
mapUI.addControl(mapUI.wv.scaleImperial);
mapUI.addControl(mapUI.wv.scaleMetric);
}
}
const updateProjection = (start) => {
if (ui.selected) {
// Keep track of center point on projection switch
ui.selected.previousCenter = ui.selected.center;
hideMap(ui.selected);
}
ui.selected = ui.proj[proj.id];
const mapObj = ui.selected;
const isProjectionRotatable = proj.id !== 'geographic' && proj.id !== 'webmerc';
const currentRotation = isProjectionRotatable ? mapObj.getView().getRotation() : 0;
const rotationStart = isProjectionRotatable ? models.map.rotation : 0;
const rotation = start ? rotationStart : currentRotation;
updateMapUI(ui, rotation);
reloadLayers(null, !start);
// If the browser was resized, the inactive map was not notified of
// the event. Force the update no matter what and reposition the center
// using the previous value.
showMap(mapObj);
mapObj.updateSize();
if (ui.selected.previousCenter) {
ui.selected.setCenter(ui.selected.previousCenter);
}
if (start) {
const projId = proj.selected.id;
let extent = null;
let callback = null;
if (models.map.extent && !isEmpty(models.map.extent)) {
extent = models.map.extent;
} else if (!models.map.extent && projId === 'geographic') {
extent = getLeadingExtent(config.pageLoadTime);
callback = () => {
const view = mapObj.getView();
const calculatedExtent = view.calculateExtent(mapObj.getSize());
fitToLeadingExtent(calculatedExtent);
};
}
if (projId !== 'geographic') {
callback = () => {
const view = mapObj.getView();
view.setRotation(rotationStart);
};
}
if (extent) {
mapObj.getView().fit(extent, {
constrainResolution: false,
callback,
});
} else if (rotationStart && projId !== 'geographic') {
callback();
}
}
updateExtent();
onResize();
};
/**
* Collect information required & initiate a "fly" map transition
* Used in Tour Stories.
* @method flyToNewExtent
* @static
*
* @param {object} extent
* @param {number} rotation
*/
const flyToNewExtent = function(extent, rotation) {
const coordinateX = extent[0] + (extent[2] - extent[0]) / 2;
const coordinateY = extent[1] + (extent[3] - extent[1]) / 2;
const coordinates = [coordinateX, coordinateY];
const resolution = ui.selected.getView().getResolutionForExtent(extent);
const zoom = ui.selected.getView().getZoomForResolution(resolution);
// Animate to extent, zoom & rotate:
// Don't animate when an event is selected (Event selection already animates)
return fly(ui.selected, proj, coordinates, isKioskModeActive, zoom, rotation);
};
const actionSwitch = () => {
switch (action.type) {
case STOP_ANIMATION:
case EXIT_ANIMATION:
return onStopAnimation();
case LOCATION_POP_ACTION: {
const newState = util.fromQueryString(action.payload.search);
const extent = lodashGet(map, 'extent');
const rotate = lodashGet(map, 'rotation') || 0;
setTimeout(() => {
updateProjection();
if (newState.v && !newState.e && extent) {
flyToNewExtent(extent, rotate);
}
}, 200); return undefined;
}
case layerConstants.UPDATE_GRANULE_LAYER_OPTIONS: {
const granuleOptions = {
id: action.id,
reset: null,
};
return reloadLayers(granuleOptions);
}
case layerConstants.RESET_GRANULE_LAYER_OPTIONS: {
const granuleOptions = {
id: action.id,
reset: action.id,
};
return reloadLayers(granuleOptions);
}
case layerConstants.UPDATE_DAY_COUNT:
return reloadLayers();
case compareConstants.CHANGE_STATE:
if (compareMode === 'spy') {
return reloadLayers();
}
return undefined;
case layerConstants.REORDER_LAYERS:
case layerConstants.REORDER_OVERLAY_GROUPS:
case compareConstants.TOGGLE_ON_OFF:
case compareConstants.CHANGE_MODE:
reloadLayers();
preloadForCompareMode();
return undefined;
case layerConstants.TOGGLE_OVERLAY_GROUPS:
return reloadLayers();
case paletteConstants.SET_THRESHOLD_RANGE_SQUASH_AND_NOCLIP:
case paletteConstants.SET_CUSTOM:
case paletteConstants.SET_DISABLED_CLASSIFICATION:
case paletteConstants.CLEAR_CUSTOM:
case layerConstants.ADD_LAYERS_FOR_EVENT:
return setTimeout(reloadLayers, 100);
case vectorStyleConstants.SET_FILTER_RANGE:
case vectorStyleConstants.SET_VECTORSTYLE:
case vectorStyleConstants.CLEAR_VECTORSTYLE:
case SET_SCREEN_INFO:
return onResize();
default:
break;
}
return undefined;
};
useEffect(() => {
actionSwitch();
}, [action]);
useEffect(() => {
if (projectionTrigger === 1) {
updateProjection(true);
} else if (projectionTrigger > 1) {
updateProjection();
}
}, [projectionTrigger]);
const prevRenderedPalettes = usePrevious(renderedPalettes);
useEffect(() => {
if (!ui.selected) return;
const prevRenderedPalettesKeys = Object.keys(prevRenderedPalettes);
const renderedPalettesKeys = Object.keys(renderedPalettes);
if (prevRenderedPalettesKeys.length === renderedPalettesKeys.length) return;
reloadLayers(null, false);
}, [renderedPalettes]);
const selectL2Layers = (layers) => layers
.filter((layer) => layer.id.includes('L2'))
.map((layer) => layer.granuleDateRanges);
const prevActiveLayers = usePrevious(activeLayers);
const prevActiveString = usePrevious(compare.activeString);
useEffect(() => {
if (!ui.selected) return;
// Skip reload on A↔B tab switch — handled by CHANGE_STATE in actionSwitch.
if (compare.active && compare.activeString !== prevActiveString) return;
const prevL2Layers = selectL2Layers(prevActiveLayers);
const activeL2Layers = selectL2Layers(activeLayers);
// Check if new date ranges have been added to L2 layers.
// We don't want to reload every time new ranges are added so
// also check if there were no ranges before.
const hasNewDateRanges = activeL2Layers.some(
(dateRange, i) => dateRange?.length !== prevL2Layers[i]?.length,
) && prevL2Layers.includes(undefined);
// Check if new layers have been added
const hasNewLayers = prevActiveLayers.length !== activeLayers.length;
// Date changes are handled by updateDate, not here.
const needsReload = hasNewDateRanges || hasNewLayers;
if (needsReload) {
reloadLayers(null, true);
}
}, [activeLayers]);
return null;
}
const mapStateToProps = (state) => {
const {
proj, map, screenSize, layers, compare, date, palettes,
} = state;
const { isKioskModeActive } = state.ui;
const layerState = { layers, compare, proj };
const isMobile = screenSize.isMobileDevice;
const dateCompareState = { date, compare };
const activeLayers = getActiveLayers(state);
const compareMode = compare.mode;
const renderedPalettes = palettes.rendered;
return {
activeLayers,
compare,
compareMode,
dateCompareState,
isKioskModeActive,
isMobile,
layerState,
proj,
map,
renderedPalettes,
};
};
const mapDispatchToProps = (dispatch) => ({
fitToLeadingExtent: (extent) => {
dispatch(fitToLeadingExtentAction(extent));
},
updateMapUI: (ui, rotation) => {
dispatch(updateMapUIAction(ui, rotation));
},
requestPalette: (id) => {
dispatch(requestPaletteAction(id));
},
addTEMPODateRanges: (layer, dateRanges, activeString) => {
dispatch(addTEMPODateRangesAction(layer, dateRanges, activeString));
},
});
export default connect(
mapStateToProps,
mapDispatchToProps,
)(UpdateProjection);
UpdateProjection.propTypes = {
action: PropTypes.object,
activeLayers: PropTypes.array,
compare: PropTypes.object,
compareMode: PropTypes.string,
compareMapUi: PropTypes.object,
config: PropTypes.object,
dateCompareState: PropTypes.object,
fitToLeadingExtent: PropTypes.func,
getGranuleOptions: PropTypes.func,
layerCreationQueue: PropTypes.object,
isKioskModeActive: PropTypes.bool,
isMobile: PropTypes.bool,
layerState: PropTypes.object,
map: PropTypes.object,
models: PropTypes.object,
preloadForCompareMode: PropTypes.func,
proj: PropTypes.object,
projectionTrigger: PropTypes.number,
ui: PropTypes.object,
updateExtent: PropTypes.func,
updateLayerVisibilities: PropTypes.func,
updateMapUI: PropTypes.func,
renderedPalettes: PropTypes.object,
requestPalette: PropTypes.func,
addTEMPODateRanges: PropTypes.func,
};