Interactive interface for browsing global, full-resolution satellite imagery
import {
findIndex as lodashFindIndex,
} from 'lodash';
import update from 'immutability-helper';
import googleTagManager from 'googleTagManager';
import {
addLayer as addLayerSelector,
getLayers as getLayersSelector,
getActiveLayers as getActiveLayersSelector,
activateLayersForEventCategory as activateLayersForEventCategorySelector,
findEventLayers,
getGranuleLayer,
getActiveGranuleLayers,
} from './selectors';
import {
ADD_LAYER,
INIT_SECOND_LAYER_GROUP,
SYNC_SECOND_LAYER_GROUP,
REORDER_LAYERS,
REORDER_OVERLAY_GROUPS,
TOGGLE_LAYER_VISIBILITY,
TOGGLE_COLLAPSE_OVERLAY_GROUP,
TOGGLE_OVERLAY_GROUP_VISIBILITY,
TOGGLE_OVERLAY_GROUPS,
REMOVE_LAYER,
REMOVE_GROUP,
UPDATE_OPACITY,
ADD_LAYERS_FOR_EVENT,
ADD_GRANULE_LAYER_DATES,
UPDATE_GRANULE_LAYER_OPTIONS,
UPDATE_GRANULE_LAYER_GEOMETRY,
RESET_GRANULE_LAYER_OPTIONS,
CHANGE_GRANULE_SATELLITE_INSTRUMENT_GROUP,
UPDATE_COLLECTION,
UPDATE_DDV_LAYER,
ADD_GRANULE_DATE_RANGES,
ADD_TEMPO_DATE_RANGES,
UPDATE_DAY_COUNT,
} from './constants';
import { updateRecentLayers } from '../product-picker/util';
import { getOverlayGroups, getLayersFromGroups } from './util';
import safeLocalStorage from '../../util/local-storage';
import { getGranuleFootprints } from '../../map/granule/util';
export function initSecondLayerGroup() {
return {
type: INIT_SECOND_LAYER_GROUP,
};
}
export function syncSecondLayerGroup(lastExitALayerIds) {
return {
type: SYNC_SECOND_LAYER_GROUP,
lastExitALayerIds,
};
}
export function activateLayersForEventCategory(category) {
return (dispatch, getState) => {
const state = getState();
const originalLayers = state.layers.active.layers;
const newLayers = activateLayersForEventCategorySelector(state, category);
const overlayGroups = getOverlayGroups(newLayers);
const newEventLayers = findEventLayers(originalLayers, newLayers);
overlayGroups.forEach((groupObj) => {
const group = groupObj;
group.collapsed = true;
});
dispatch({
type: ADD_LAYERS_FOR_EVENT,
activeString: state.compare.activeString,
layers: newLayers,
overlayGroups,
eventLayers: newEventLayers,
});
};
}
export function toggleOverlayGroups() {
return (dispatch, getState) => {
const state = getState();
const { activeString } = state.compare;
const {
groupOverlays,
layers,
prevLayers,
overlayGroups,
} = state.layers[activeString];
const { GROUP_OVERLAYS } = safeLocalStorage.keys;
// Disabling Groups
if (groupOverlays) {
safeLocalStorage.setItem(GROUP_OVERLAYS, 'disabled');
const ungroupedLayers = prevLayers && prevLayers.length
? prevLayers
: getLayersFromGroups(state, overlayGroups);
dispatch({
type: TOGGLE_OVERLAY_GROUPS,
activeString,
groupOverlays: false,
layers: ungroupedLayers,
overlayGroups: [],
});
// Enabling Groups
} else {
safeLocalStorage.removeItem(GROUP_OVERLAYS);
const groups = getOverlayGroups(layers);
dispatch({
type: TOGGLE_OVERLAY_GROUPS,
activeString,
groupOverlays: true,
layers: getLayersFromGroups(state, groups),
overlayGroups: groups,
prevLayers: layers,
});
}
};
}
export function addLayer(id) {
googleTagManager.pushEvent({
event: 'layer_added',
layers: { id },
});
return (dispatch, getState) => {
const state = getState();
const {
layers, compare, config,
} = state;
const layerObj = layers.layerConfig[id];
const { groupOverlays } = layers[compare.activeString];
const activeLayers = getActiveLayersSelector(state);
const overlays = getLayersSelector(state, { group: 'overlays' });
const newLayers = addLayerSelector(
id,
activeLayers,
layers.layerConfig,
{},
overlays.length || 0,
groupOverlays,
);
const projections = Object.keys(config.projections);
updateRecentLayers(layerObj, projections);
dispatch({
type: ADD_LAYER,
id,
activeString: compare.activeString,
layers: newLayers,
});
};
}
export function reorderLayers(reorderedLayers) {
return (dispatch, getState) => {
const { compare } = getState();
dispatch({
type: REORDER_LAYERS,
activeString: compare.activeString,
layers: reorderedLayers,
});
};
}
export function reorderOverlayGroups(layers, overlayGroups) {
return (dispatch, getState) => {
const { compare } = getState();
dispatch({
type: REORDER_OVERLAY_GROUPS,
activeString: compare.activeString,
layers,
overlayGroups,
});
};
}
export function removeLayer(id) {
return (dispatch, getState) => {
const state = getState();
const { compare } = state;
const { activeString } = compare;
const activeLayers = getActiveLayersSelector(state);
const granuleLayers = getActiveGranuleLayers(state);
const index = lodashFindIndex(activeLayers, { id });
if (index === -1) {
return console.warn(`Invalid layer ID: ${id}`);
}
const def = activeLayers[index];
return dispatch({
type: REMOVE_LAYER,
activeString,
layersToRemove: [def],
layers: update(activeLayers, { $splice: [[index, 1]] }),
granuleLayers: update(granuleLayers, { $unset: [id] }),
});
};
}
export function removeGroup(ids) {
return (dispatch, getState) => {
const state = getState();
const { compare } = state;
const { activeString } = compare;
const activeLayers = getActiveLayersSelector(state);
const granuleLayers = getActiveGranuleLayers(state);
const layersToRemove = activeLayers.filter((l) => ids.includes(l.id));
const newLayers = activeLayers.filter((l) => !ids.includes(l.id));
dispatch({
type: REMOVE_GROUP,
activeString,
layersToRemove,
layers: newLayers,
granuleLayers: update(granuleLayers, { $unset: [ids] }),
});
};
}
export function toggleVisibility(id, visible) {
return (dispatch, getState) => {
const { compare } = getState();
dispatch({
type: TOGGLE_LAYER_VISIBILITY,
id,
visible,
activeString: compare.activeString,
});
};
}
export function toggleGroupVisibility(ids, visible) {
return (dispatch, getState) => {
const { compare } = getState();
const activeLayers = getActiveLayersSelector(getState());
const updatedLayers = activeLayers.map((layer) => (
ids.includes(layer.id) ? { ...layer, visible } : layer
));
dispatch({
type: TOGGLE_OVERLAY_GROUP_VISIBILITY,
layers: updatedLayers,
activeString: compare.activeString,
});
};
}
export function toggleGroupCollapsed(groupName, collapsed) {
return (dispatch, getState) => {
const state = getState();
dispatch({
type: TOGGLE_COLLAPSE_OVERLAY_GROUP,
groupName,
activeString: state.compare.activeString,
collapsed,
});
};
}
export function setOpacity(id, opacity) {
return (dispatch, getState) => {
const { compare } = getState();
const activeLayers = getActiveLayersSelector(getState());
const index = lodashFindIndex(activeLayers, { id });
if (index === -1) {
return console.warn(`Invalid layer ID: ${id}`);
}
return dispatch({
type: UPDATE_OPACITY,
id,
opacity: Number(opacity),
activeString: compare.activeString,
});
};
}
export function updateDayCount(id, dayCount) {
return (dispatch, getState) => {
const { compare } = getState();
return dispatch({
type: UPDATE_DAY_COUNT,
id,
dayCount: Number(dayCount),
activeString: compare.activeString,
});
};
}
export function hideLayers(layers) {
return (dispatch) => {
layers.forEach((obj) => {
dispatch(toggleVisibility(obj.id, false));
});
};
}
export function showLayers(layers) {
return (dispatch) => {
layers.forEach((obj) => {
dispatch(toggleVisibility(obj.id, true));
});
};
}
function updateGranuleLayerGeometry(layer, dates, granuleGeometry) {
return (dispatch, getState) => {
const { compare, layers } = getState();
// Write to the compare side the layer was built for
const activeString = layer.wv.group || compare.activeString;
const { id, count } = layer.wv;
const layerDef = layers.layerConfig[id];
const granulePlatform = `${layerDef.subtitle}`;
const activeSatelliteInstrumentGroup = layers[activeString].granulePlatform;
const activeGeometry = layers.granuleFootprints;
// determine if active satellite instrument, then update global geometry,
// else use current global geometry
const newGranuleGeometry = activeSatelliteInstrumentGroup === granulePlatform
? granuleGeometry
: activeGeometry;
dispatch({
type: UPDATE_GRANULE_LAYER_GEOMETRY,
id,
activeKey: activeString,
granuleFootprints: newGranuleGeometry,
dates,
count,
});
};
}
function addGranuleLayerDates(layer, granuleFootprints, granulePlatform) {
return (dispatch, getState) => {
const { compare } = getState();
// Write to the compare side the layer was built for
const activeString = layer.wv.group || compare.activeString;
const { id, granuleDates, count } = layer.wv;
dispatch({
type: ADD_GRANULE_LAYER_DATES,
id,
activeKey: activeString,
dates: granuleDates,
granuleFootprints,
granulePlatform,
count,
});
};
}
export function updateGranuleLayerState(layer) {
return (dispatch, getState) => {
const state = getState();
const {
id, def: { endDate, subtitle }, reorderedGranules, granuleDates,
} = layer.wv;
const mostRecentGranuleDate = granuleDates[0];
const isMostRecentDateOutOfRange = new Date(mostRecentGranuleDate) > new Date(endDate);
const updatedDates = isMostRecentDateOutOfRange ? [] : reorderedGranules || granuleDates;
const granuleFootprints = getGranuleFootprints(layer);
const existingLayer = getGranuleLayer(state, id, layer.wv.group);
if (existingLayer) {
dispatch(updateGranuleLayerGeometry(layer, updatedDates, granuleFootprints));
}
dispatch(addGranuleLayerDates(layer, granuleFootprints, `${subtitle}`));
};
}
const granuleRangesEqual = (a, b) => {
if (a === b) return true;
if (!a || !b || a.length !== b.length) return false;
for (let i = 0; i < a.length; i += 1) {
if (a[i][0] !== b[i][0] || a[i][1] !== b[i][1]) return false;
}
return true;
};
export function addGranuleDateRanges(layer, granuleDateRanges) {
return (dispatch, getState) => {
const { active: compareActive, activeString } = getState().compare;
const { id } = layer;
const dispatchForSide = (side) => {
// Re-read state so the dedup check sees results of prior dispatches.
const freshState = getState();
const existingLayer = getActiveLayersSelector(freshState, side).find((l) => l.id === id);
if (!existingLayer) return;
if (granuleRangesEqual(existingLayer.granuleDateRanges, granuleDateRanges)) {
return;
}
dispatch({
type: ADD_GRANULE_DATE_RANGES,
activeString: side,
id,
granuleDateRanges,
});
};
dispatchForSide(activeString);
// In compare mode, sync the same ranges to the other side so the B-side
// timeline coverage bar is populated regardless of which side is active.
if (compareActive) {
const otherSide = activeString === 'active' ? 'activeB' : 'active';
dispatchForSide(otherSide);
}
};
}
export function updateGranuleLayerOptions(dates, def, count) {
return (dispatch, getState) => {
const { activeString } = getState().compare;
dispatch({
type: UPDATE_GRANULE_LAYER_OPTIONS,
id: def.id,
activeKey: activeString,
dates,
count,
});
};
}
export function resetGranuleLayerDates(id) {
return (dispatch, getState) => {
const { compare } = getState();
const { activeString } = compare;
dispatch({
type: RESET_GRANULE_LAYER_OPTIONS,
id,
activeKey: activeString,
});
};
}
export function changeGranuleSatelliteInstrumentGroup(id, granulePlatform) {
return (dispatch, getState) => {
const { compare } = getState();
const { activeString } = compare;
const { geometry } = getGranuleLayer(getState(), id);
dispatch({
type: CHANGE_GRANULE_SATELLITE_INSTRUMENT_GROUP,
granulePlatform,
geometry,
activeKey: activeString,
});
};
}
export function updateCollection(collection) {
return {
type: UPDATE_COLLECTION,
payload: collection,
};
}
export function updateBandCombination(id, bandCombo, layerIndex, selectedPreset) {
return (dispatch, getState) => {
const state = getState();
const {
layers, compare, config,
} = state;
const layerObj = layers.layerConfig[id];
const { groupOverlays } = layers[compare.activeString];
const activeLayers = getActiveLayersSelector(state);
const overlays = getLayersSelector(state, { group: 'overlays' });
const newLayers = addLayerSelector(
id,
activeLayers,
layers.layerConfig,
{},
overlays.length || 0,
groupOverlays,
bandCombo,
selectedPreset,
);
const projections = Object.keys(config.projections);
updateRecentLayers(layerObj, projections);
dispatch({
type: UPDATE_DDV_LAYER,
id,
activeString: compare.activeString,
layers: newLayers,
layerIndex,
});
};
}
export function addTEMPODateRanges(layer, tempoDateRanges, activeString) {
return (dispatch) => {
const { id } = layer;
dispatch({
type: ADD_TEMPO_DATE_RANGES,
activeString,
id,
tempoDateRanges,
});
};
}