Skip to content

Interactive interface for browsing global, full-resolution satellite imagery

preload map tiles for next increment

Jason Kent2390564a2111
diff --git a/web/js/components/animation-widget/play-queue.js b/web/js/components/animation-widget/play-queue.js
index 987830b24..c243e9c25 100644
--- a/web/js/components/animation-widget/play-queue.js
+++ b/web/js/components/animation-widget/play-queue.js
@@ -5,7 +5,6 @@ import { isEmpty as lodashIsEmpty } from 'lodash';
import Spinner from 'react-loader';
import Queue from 'promise-queue';
import util from '../../util/util';
-import { getLayersActiveAtDate } from '../../modules/date/util';
/*
* Preload and play animation
@@ -353,8 +352,7 @@ class PlayAnimation extends React.Component {
* @returns {object} JS Date
*/
addDate(date) {
- const { layers, promiseImageryForTime } = this.props;
- const activeLayers = getLayersActiveAtDate(layers, date);
+ const { promiseImageryForTime } = this.props;
const strDate = util.toISOStringSeconds(date);
if (this.inQueueObject[strDate] || this.preloadObject[strDate]) {
@@ -363,7 +361,7 @@ class PlayAnimation extends React.Component {
this.addToInQueue(date);
this.queue
- .add(() => promiseImageryForTime(date, activeLayers))
+ .add(() => promiseImageryForTime(date))
.then((addedDate) => {
if (this.mounted) {
this.preloadObject[strDate] = addedDate;
@@ -481,7 +479,6 @@ class PlayAnimation extends React.Component {
PlayAnimation.propTypes = {
endDate: PropTypes.object.isRequired,
isPlaying: PropTypes.bool.isRequired,
- layers: PropTypes.array.isRequired,
promiseImageryForTime: PropTypes.func.isRequired,
queueLength: PropTypes.number.isRequired,
selectDate: PropTypes.func.isRequired,
diff --git a/web/js/containers/animation-widget.js b/web/js/containers/animation-widget.js
index f15ff5a26..a020ae71c 100644
--- a/web/js/containers/animation-widget.js
+++ b/web/js/containers/animation-widget.js
@@ -21,7 +21,7 @@ import TimeScaleIntervalChange from '../components/timeline/timeline-controls/in
import CustomIntervalSelectorWidget from '../components/timeline/custom-interval-selector/interval-selector-widget';
import PlayQueue from '../components/animation-widget/play-queue';
import Notify from '../components/image-download/notify';
-import promiseImageryForTime from '../modules/map/selectors';
+import { promiseImageryForTime } from '../modules/map/util';
import GifContainer from './gif';
import {
selectDate,
@@ -576,7 +576,6 @@ class AnimationWidget extends React.Component {
endDate,
onPushPause,
isActive,
- layers,
hasCustomPalettes,
isDistractionFreeModeActive,
promiseImageryForTime,
@@ -623,7 +622,6 @@ class AnimationWidget extends React.Component {
hasCustomPalettes={hasCustomPalettes}
maxQueueLength={maxLength}
queueLength={queueLength}
- layers={layers}
interval={interval}
delta={delta}
speed={speed}
@@ -737,7 +735,6 @@ function mapStateToProps(state) {
customInterval: customInterval || 3,
numberOfFrames,
sliderLabel: 'Frames Per Second',
- layers: getAllActiveLayers(state),
speed,
isPlaying,
looping: loop,
@@ -746,7 +743,7 @@ function mapStateToProps(state) {
proj,
hasNonDownloadableLayer: hasNonDownloadableVisibleLayer(visibleLayersForProj),
visibleLayersForProj,
- promiseImageryForTime: (date, layers) => promiseImageryForTime(date, layers, state),
+ promiseImageryForTime: (date) => promiseImageryForTime(state, date),
isGifActive: gifActive,
isCompareActive: compare.active,
isEmbedModeActive,
@@ -873,7 +870,6 @@ AnimationWidget.propTypes = {
isGifActive: PropTypes.bool,
isPlaying: PropTypes.bool,
isRotated: PropTypes.bool,
- layers: PropTypes.array,
looping: PropTypes.bool,
maxDate: PropTypes.object,
minDate: PropTypes.object,
diff --git a/web/js/containers/timeline/timeline.js b/web/js/containers/timeline/timeline.js
index e4189eea5..2193ad1d2 100644
--- a/web/js/containers/timeline/timeline.js
+++ b/web/js/containers/timeline/timeline.js
@@ -38,7 +38,7 @@ import {
getActiveLayers,
} from '../../modules/layers/selectors';
import {
- selectDate,
+ selectDate as selectDateAction,
changeTimeScale,
selectInterval,
changeCustomInterval,
@@ -49,6 +49,7 @@ import {
import {
checkHasFutureLayers,
filterProjLayersWithStartDate,
+ getNextTimeSelection,
} from '../../modules/date/util';
import { toggleActiveCompareState } from '../../modules/compare/actions';
import {
@@ -112,7 +113,7 @@ class Timeline extends React.Component {
};
const {
- changeDate,
+ selectDate,
onUpdateStartDate,
onUpdateEndDate,
onUpdateStartAndEndDate,
@@ -120,7 +121,8 @@ class Timeline extends React.Component {
// left/right arrows
const throttleSettings = { leading: true, trailing: false };
- this.debounceDateUpdate = lodashDebounce(changeDate, 8);
+ this.throttleSelectDate = lodashThrottle(selectDate, 100, throttleSettings);
+ this.debounceDraggerDateUpdate = lodashDebounce(this.onDateChange, 200);
this.throttleDecrementDate = lodashThrottle(
this.handleArrowDateChange.bind(this, -1),
ANIMATION_DELAY,
@@ -806,7 +808,7 @@ class Timeline extends React.Component {
draggerTimeState: newDate || draggerTimeState,
});
if (newDate) {
- this.onDateChange(newDate, 'selected');
+ this.debounceDraggerDateUpdate(newDate, 'selected');
}
} else {
this.setState({
@@ -816,7 +818,7 @@ class Timeline extends React.Component {
draggerTimeStateB: newDate || draggerTimeStateB,
});
if (newDate) {
- this.onDateChange(newDate, 'selectedB');
+ this.debounceDraggerDateUpdate(newDate, 'selectedB');
}
}
}
@@ -945,7 +947,7 @@ class Timeline extends React.Component {
draggerTimeStateB: dateISOFormatted,
});
}
- this.debounceDateUpdate(dateObj, draggerSelected);
+ this.throttleSelectDate(dateObj, draggerSelected);
}
handleSelectNowButton = () => {
@@ -1524,8 +1526,8 @@ const mapDispatchToProps = (dispatch) => ({
dispatch(triggerTodayButton());
},
// changes date of active dragger 'selected' or 'selectedB'
- changeDate: (val) => {
- dispatch(selectDate(val));
+ selectDate: (val) => {
+ dispatch(selectDateAction(val));
},
// changes/sets custom delta and timescale interval
changeCustomInterval: (delta, timeScale) => {
@@ -1578,7 +1580,6 @@ Timeline.propTypes = {
animStartLocationDate: PropTypes.object,
axisWidth: PropTypes.number,
changeCustomInterval: PropTypes.func,
- changeDate: PropTypes.func,
changeTimeScale: PropTypes.func,
closeAnimation: PropTypes.func,
customIntervalValue: PropTypes.number,
@@ -1611,6 +1612,7 @@ Timeline.propTypes = {
parentOffset: PropTypes.number,
rightArrowDisabled: PropTypes.bool,
screenWidth: PropTypes.number,
+ selectDate: PropTypes.func,
selectedDate: PropTypes.object,
selectInterval: PropTypes.func,
timelineCustomModalOpen: PropTypes.bool,
@@ -1631,53 +1633,6 @@ const getOffsetValues = (innerWidth, hasSubDaily) => {
return { width, parentOffset };
};
-/**
- * @param {Number} delta Date and direction to change
- * @param {Number} increment Zoom level of change
- * e.g. months, minutes, years, days
- * @param {Object} prevDate JS Date Object
- * @param {Object} minDate timelineStartDateLimit JS Date Object
- * @param {Object} maxDate timelineEndDateLimit JS Date Object
- * @return {Object} JS Date Object
- */
-const getNextTimeSelection = (delta, increment, prevDate, minDate, maxDate) => {
- let date;
- // eslint-disable-next-line default-case
- switch (increment) {
- case 'year':
- date = new Date(
- new Date(prevDate).setUTCFullYear(prevDate.getUTCFullYear() + delta),
- );
- break;
- case 'month':
- date = new Date(
- new Date(prevDate).setUTCMonth(prevDate.getUTCMonth() + delta),
- );
- break;
- case 'day':
- date = new Date(
- new Date(prevDate).setUTCDate(prevDate.getUTCDate() + delta),
- );
- break;
- case 'hour':
- date = new Date(
- new Date(prevDate).setUTCHours(prevDate.getUTCHours() + delta),
- );
- break;
- case 'minute':
- date = new Date(
- new Date(prevDate).setUTCMinutes(prevDate.getUTCMinutes() + delta),
- );
- break;
- }
- if (date < minDate) {
- return minDate;
- } if (date > maxDate) {
- return maxDate;
- }
- return date;
-};
-
// check if left arrow should be disabled on predicted decrement
const checkLeftArrowDisabled = (
date,
diff --git a/web/js/map/ui.js b/web/js/map/ui.js
index 8bf290d03..ffe0f93fa 100644
--- a/web/js/map/ui.js
+++ b/web/js/map/ui.js
@@ -40,7 +40,7 @@ import {
SET_REVERSE_GEOCODE_RESULTS,
TOGGLE_DIALOG_VISIBLE,
} from '../modules/location-search/constants';
-import { SELECT_DATE } from '../modules/date/constants';
+import * as dateConstants from '../modules/date/constants';
import util from '../util/util';
import * as layerConstants from '../modules/layers/constants';
import * as compareConstants from '../modules/compare/constants';
@@ -59,7 +59,9 @@ import { EXIT_ANIMATION, STOP_ANIMATION } from '../modules/animation/constants';
import {
RENDERED, UPDATE_MAP_UI, UPDATE_MAP_EXTENT, UPDATE_MAP_ROTATION, FITTED_TO_LEADING_EXTENT, REFRESH_ROTATE, CLEAR_ROTATE,
} from '../modules/map/constants';
-import { getLeadingExtent } from '../modules/map/util';
+import { getLeadingExtent, promiseImageryForTime } from '../modules/map/util';
+import { getNextTimeSelection } from '../modules/date/util';
+
import { updateVectorSelection } from '../modules/vector-styles/util';
import { hasVectorLayers } from '../modules/layers/util';
import { animateCoordinates, getCoordinatesMarker } from '../modules/location-search/util';
@@ -105,6 +107,7 @@ export default function mapui(models, config, store, ui) {
* specific action types
*/
const subscribeToStore = function(action) {
+ const state = store.getState();
switch (action.type) {
case layerConstants.ADD_LAYER: {
const def = lodashFind(action.layers, { id: action.id });
@@ -138,7 +141,6 @@ export default function mapui(models, config, store, ui) {
return;
}
case LOCATION_POP_ACTION: {
- const state = store.getState();
const newState = util.fromQueryString(action.payload.search);
const extent = lodashGet(state, 'map.extent');
const rotate = lodashGet(state, 'map.rotation') || 0;
@@ -152,8 +154,12 @@ export default function mapui(models, config, store, ui) {
case layerConstants.REMOVE_LAYER:
return removeLayer(action.layersToRemove);
case layerConstants.TOGGLE_LAYER_VISIBILITY:
- case layerConstants.TOGGLE_OVERLAY_GROUP_VISIBILITY:
- return updateLayerVisibilities();
+ case layerConstants.TOGGLE_OVERLAY_GROUP_VISIBILITY: {
+ updateLayerVisibilities();
+ updateDate().then(preloadNextTiles);
+ return;
+ }
+
case layerConstants.UPDATE_OPACITY:
return updateOpacity(action);
case compareConstants.CHANGE_STATE:
@@ -167,7 +173,9 @@ export default function mapui(models, config, store, ui) {
case layerConstants.REORDER_OVERLAY_GROUPS:
case compareConstants.TOGGLE_ON_OFF:
case compareConstants.CHANGE_MODE:
- return reloadLayers();
+ reloadLayers();
+ preloadForCompareMode();
+ return;
case CHANGE_PROJECTION:
return updateProjection();
case paletteConstants.SET_THRESHOLD_RANGE_AND_SQUASH:
@@ -183,7 +191,6 @@ export default function mapui(models, config, store, ui) {
case vectorStyleConstants.SET_SELECTED_VECTORS: {
const type = 'selection';
const newSelection = action.payload;
- const state = store.getState();
updateVectorSelection(
action.payload,
self.selectedVectors,
@@ -195,12 +202,18 @@ export default function mapui(models, config, store, ui) {
case STOP_ANIMATION:
case EXIT_ANIMATION:
return onStopAnimation();
- case SELECT_DATE:
- return updateDate();
+ case dateConstants.CHANGE_CUSTOM_INTERVAL:
+ case dateConstants.CHANGE_INTERVAL:
+ return preloadNextTiles();
+ case dateConstants.SELECT_DATE: {
+ updateDate().then(preloadNextTiles);
+ break;
+ }
default:
break;
}
};
+
const onStopAnimation = function() {
const hasActiveVectors = hasVectorLayers(getActiveLayers(store.getState()));
if (hasActiveVectors) {
@@ -647,6 +660,7 @@ export default function mapui(models, config, store, ui) {
layer.wv.id,
getActiveLayers(state),
getSelectedDate(state),
+ null,
state,
);
layer.setVisible(renderable);
@@ -662,6 +676,7 @@ export default function mapui(models, config, store, ui) {
subLayer.wv.id,
getActiveLayers(state, compareActiveString),
getSelectedDate(state, compareDateString),
+ null,
state,
);
subLayer.setVisible(renderable);
@@ -730,6 +745,7 @@ export default function mapui(models, config, store, ui) {
self.selected.getLayers().insertAt(mapIndex, createLayer(def));
}
updateLayerVisibilities();
+ preloadNextTiles();
}
function removeLayer(layersToRemove) {
@@ -758,71 +774,120 @@ export default function mapui(models, config, store, ui) {
*
* @returns {void}
*/
- const updateDate = self.updateDate = function() {
- const state = store.getState();
- const { embed, compare } = state;
- let activeLayers = getAllActiveLayers(state);
- let layerGroups;
- let layerGroup;
- if (compare && compare.active) {
- layerGroups = self.selected.getLayers().getArray();
- if (layerGroups.length > 1) {
- layerGroup = layerGroups[0].get('group') === compare.activeString
- ? layerGroups[0]
- : layerGroups[1].get('group') === compare.activeString
- ? layerGroups[1]
- : null;
- }
- }
- if (embed.isEmbedModeActive) {
- activeLayers = activeLayers.filter((layer) => layer.visible);
- }
- lodashEach(activeLayers, (def) => {
- const layerName = def.layer || def.id;
-
- if (!['subdaily', 'daily', 'monthly', 'yearly'].includes(def.period)) {
- return;
- }
+ const updateDate = self.updateDate = async function() {
+ return new Promise((resolve) => {
+ const state = store.getState();
+ const { compare } = state;
+ const activeLayers = getAllActiveLayers(state);
+ let layerGroups;
+ let layerGroup;
if (compare && compare.active) {
- if (layerGroup && layerGroup.getLayers().getArray().length) {
- const index = findLayerIndex(def, layerGroup);
- const layerValue = self.selected.getLayers().getArray()[index];
- layerGroup.getLayers().setAt(
- index,
- createLayer(def, {
- group: compare.activeString,
- date: getSelectedDate(state),
- previousLayer: layerValue ? layerValue.wv : null,
- }),
- );
- compareMapUi.update(compare.activeString);
+ layerGroups = self.selected.getLayers().getArray();
+ if (layerGroups.length > 1) {
+ layerGroup = layerGroups[0].get('group') === compare.activeString
+ ? layerGroups[0]
+ : layerGroups[1].get('group') === compare.activeString
+ ? layerGroups[1]
+ : null;
}
- } else {
- const index = findLayerIndex(def);
- const layerValue = self.selected.getLayers().getArray()[index];
- self.selected
- .getLayers()
- .setAt(index, createLayer(def, { previousLayer: layerValue ? layerValue.wv : null }));
}
- if (config.vectorStyles && def.vectorStyle && def.vectorStyle.id) {
- const { vectorStyles } = config;
- let vectorStyleId;
-
- vectorStyleId = def.vectorStyle.id;
- if (getActiveLayers(state)) {
- getActiveLayers(state).forEach((layer) => {
- if (layer.id === layerName && layer.custom) {
- vectorStyleId = layer.custom;
- }
- });
+
+ const group = compare && compare.active ? layerGroup : self.selected;
+ const layers = group.getLayers().getArray();
+ const visibleLayers = activeLayers.filter(
+ ({ id }) => layers
+ .filter((l) => l.getVisible())
+ .map(({ wv }) => wv.def.id)
+ .includes(id),
+ );
+
+ lodashEach(visibleLayers, (def) => {
+ const layerName = def.layer || def.id;
+
+ if (!['subdaily', 'daily', 'monthly', 'yearly'].includes(def.period)) {
+ return;
}
- setStyleFunction(def, vectorStyleId, vectorStyles, null, state);
- }
+
+ if (compare && compare.active) {
+ if (layers.length) {
+ const index = findLayerIndex(def, layerGroup);
+ const layerValue = self.selected.getLayers().getArray()[index];
+ layerGroup.getLayers().setAt(
+ index,
+ createLayer(def, {
+ group: compare.activeString,
+ date: getSelectedDate(state),
+ previousLayer: layerValue ? layerValue.wv : null,
+ }),
+ );
+ compareMapUi.update(compare.activeString);
+ }
+ } else {
+ const index = findLayerIndex(def);
+ const layer = createLayer(def, { previousLayer: layers[index] ? layers[index].wv : null });
+ self.selected.getLayers().setAt(index, layer);
+ }
+
+ if (config.vectorStyles && def.vectorStyle && def.vectorStyle.id) {
+ const { vectorStyles } = config;
+ let vectorStyleId;
+
+ vectorStyleId = def.vectorStyle.id;
+ if (getActiveLayers(state)) {
+ getActiveLayers(state).forEach((layer) => {
+ if (layer.id === layerName && layer.custom) {
+ vectorStyleId = layer.custom;
+ }
+ });
+ }
+ setStyleFunction(def, vectorStyleId, vectorStyles, null, state);
+ }
+ });
+ updateLayerVisibilities();
+ resolve();
});
- updateLayerVisibilities();
};
+ /**
+ * Preload tiles for the next and previous time interval so they are visible
+ * as soon as the user changes the date. We will usually only end up actually requesting
+ * either previous or next interval tiles since tiles are cached.
+ * (e.g. user adjust from July 1 => July 2, we preload July 3 which is "next"
+ * but no requests get made for "previous", July 1, since those are cached already.
+ */
+ async function preloadNextTiles(date, compareString) {
+ const state = store.getState();
+ const { timeScaleFromNumberKey } = dateConstants;
+ const { activeString } = state.compare;
+ const {
+ customSelected, customDelta, delta, customInterval, interval,
+ } = state.date;
+ const useActiveString = compareString || activeString;
+ const useDate = date || getSelectedDate(state);
+ const useDelta = customSelected ? customDelta : delta;
+ const changeUnit = customSelected
+ ? timeScaleFromNumberKey[customInterval]
+ : timeScaleFromNumberKey[interval];
+ const nextDate = getNextTimeSelection(useDelta, changeUnit, useDate);
+ const prevDate = getNextTimeSelection(useDelta * -1, changeUnit, useDate);
+ await promiseImageryForTime(state, nextDate, useActiveString);
+ await promiseImageryForTime(state, prevDate, useActiveString);
+ if (!date) {
+ preloadNextTiles(nextDate, useActiveString);
+ preloadNextTiles(prevDate, useActiveString);
+ }
+ }
+
+ function preloadForCompareMode() {
+ const { date, compare } = store.getState();
+ const { selected, selectedB } = date;
+ preloadNextTiles(selected, 'active');
+ if (compare.active) {
+ preloadNextTiles(selectedB, 'activeB');
+ }
+ }
+
/*
* Update layers for the correct Date
*
@@ -1046,6 +1111,7 @@ export default function mapui(models, config, store, ui) {
ui: self,
rotation: self.selected.getView().getRotation(),
});
+ setTimeout(preloadForCompareMode, 250);
map.un('rendercomplete', onRenderComplete);
};
map.on('rendercomplete', onRenderComplete);
diff --git a/web/js/modules/date/util.js b/web/js/modules/date/util.js
index e70f2eeb7..b74e090c6 100644
--- a/web/js/modules/date/util.js
+++ b/web/js/modules/date/util.js
@@ -231,3 +231,50 @@ export function mapLocationToDateState(
}
return stateFromLocation;
}
+
+/**
+ * @param {Number} delta Date and direction to change
+ * @param {Number} increment Zoom level of change
+ * e.g. months, minutes, years, days
+ * @param {Object} prevDate JS Date Object
+ * @param {Object} minDate timelineStartDateLimit JS Date Object
+ * @param {Object} maxDate timelineEndDateLimit JS Date Object
+ * @return {Object} JS Date Object
+ */
+export const getNextTimeSelection = (delta, increment, prevDate, minDate, maxDate) => {
+ let date;
+ // eslint-disable-next-line default-case
+ switch (increment) {
+ case 'year':
+ date = new Date(
+ new Date(prevDate).setUTCFullYear(prevDate.getUTCFullYear() + delta),
+ );
+ break;
+ case 'month':
+ date = new Date(
+ new Date(prevDate).setUTCMonth(prevDate.getUTCMonth() + delta),
+ );
+ break;
+ case 'day':
+ date = new Date(
+ new Date(prevDate).setUTCDate(prevDate.getUTCDate() + delta),
+ );
+ break;
+ case 'hour':
+ date = new Date(
+ new Date(prevDate).setUTCHours(prevDate.getUTCHours() + delta),
+ );
+ break;
+ case 'minute':
+ date = new Date(
+ new Date(prevDate).setUTCMinutes(prevDate.getUTCMinutes() + delta),
+ );
+ break;
+ }
+ if (date < minDate) {
+ return minDate;
+ } if (date > maxDate) {
+ return maxDate;
+ }
+ return date;
+};
diff --git a/web/js/modules/layers/selectors.js b/web/js/modules/layers/selectors.js
index 4d36604cb..7002eb96c 100644
--- a/web/js/modules/layers/selectors.js
+++ b/web/js/modules/layers/selectors.js
@@ -24,7 +24,6 @@ const getLayerState = ({ layers }) => layers;
*/
export const isGroupingEnabled = ({ compare, layers }) => layers[compare.activeString].groupOverlays;
-
/**
* Return a list of layers for the currently active compare state
* regardless of projection
@@ -126,6 +125,12 @@ export const getAllActiveOverlaysBaselayers = createSelector(
(proj, compare, layers) => getLayers({ proj, compare, layers }, { group: 'all' }),
);
+export const getActiveVisibleLayersAtDate = (state, date, activeString) => {
+ const layers = getActiveLayers(state, activeString);
+ const baseLayers = layers.filter(({ group }) => group === 'baselayers');
+ return layers.filter((l) => isRenderable(l.id, layers, date, baseLayers, {}));
+};
+
export function hasMeasurementSource(current, config, projId) {
let hasSource;
Object.values(current.sources).forEach((source) => {
@@ -307,7 +312,7 @@ function forGroup(group, spec = {}, activeLayers, state) {
lodashEach(defs, (def) => {
const notInProj = !def.projections[projId];
const notRenderable = spec.renderable
- && !isRenderable(def.id, activeLayers, spec.date, state);
+ && !isRenderable(def.id, activeLayers, spec.date, null, state);
if (notInProj || notRenderable) {
return;
}
@@ -454,7 +459,7 @@ export const memoizedAvailable = createSelector(
* @param {*} date
* @param {*} state
*/
-export function isRenderable(id, layers, date, state) {
+export function isRenderable(id, layers, date, bLayers, state) {
const { parameters } = state.config || {};
date = date || getSelectedDate(state);
const def = lodashFind(layers, { id });
@@ -467,7 +472,7 @@ export function isRenderable(id, layers, date, state) {
return true;
}
let obscured = false;
- const baselayers = getLayers(state, { group: 'baselayers' }, layers);
+ const baselayers = bLayers || getLayers(state, { group: 'baselayers' }, layers);
lodashEach(
baselayers,
(otherDef) => {
diff --git a/web/js/modules/map/selectors.js b/web/js/modules/map/selectors.js
deleted file mode 100644
index ab864272f..000000000
--- a/web/js/modules/map/selectors.js
+++ /dev/null
@@ -1,26 +0,0 @@
-import { promiseLayerGroup } from './util';
-/*
- * @method promiseImageryForTime
- * @param {object} time of data to be displayed on the map.
- * @return {object} Promise.all
- */
-export default function promiseImageryForTime(date, layers, state) {
- const { map } = state;
- const { cache } = map.ui;
- const mapUi = map.ui;
- const selectedMap = map.ui.selected;
- const { pixelRatio, viewState } = selectedMap.frameState_; // OL object describing the current map frame
-
- const promiseArray = layers.map((def) => {
- const key = mapUi.layerKey(def, { date }, state);
- let layer = cache.getItem(key);
-
- if (!layer) {
- layer = mapUi.createLayer(def, { date, precache: true });
- }
- return promiseLayerGroup(layer, viewState, pixelRatio, selectedMap, def);
- });
- return new Promise((resolve) => {
- Promise.all(promiseArray).then(() => resolve(date));
- });
-}
diff --git a/web/js/modules/map/util.js b/web/js/modules/map/util.js
index 8b6b711dc..971e0122b 100644
--- a/web/js/modules/map/util.js
+++ b/web/js/modules/map/util.js
@@ -9,6 +9,7 @@ import {
import OlRendererCanvasTileLayer from 'ol/renderer/canvas/TileLayer';
import Promise from 'bluebird';
import { encode } from '../link/util';
+import { getActiveVisibleLayersAtDate } from '../layers/selectors';
export function getMapParameterSetup(
parameters,
@@ -109,6 +110,7 @@ export function mapIsExtentValid(extent) {
});
return valid;
}
+
/*
* Set default extent according to time of day:
*
@@ -144,42 +146,6 @@ export function getLeadingExtent(loadtime) {
return [minLon, minLat, maxLon, maxLat];
}
-/**
- * Once a layer's group of layers (prev, current, next day) are fulfilled,
- * a promise with an array of their fulfilled values is returned.
- *
- * @method promiseLayerGroup
- * @param {object} layer ol_Layer_Group object, contains values.layers for prev, current, next days
- * @param {object} viewState Contains center, projection, resolution, rotation and zoom parameters
- * @param {number} pixelRatio The window.devicePixelRatio, used to detect retina displays
- * @param {object} map _ol_Map_ object
- * @return {object} Promise.all
- */
-export function promiseLayerGroup(layer, viewState, pixelRatio, map, def) {
- let extent;
- return new Promise((resolve, reject) => {
- let layers;
- // Current layer's 3 layer array (prev, current, next days)
- layers = layer.values_.layers;
- if (layer.values_.layers) {
- layers = layer.getLayers().getArray();
- } else {
- layers = [layer];
- }
- // Calculate the extent of each layer in the layer group
- // and create a promiseTileLayer for prev, current, next day
- const layerPromiseArray = layers.map((layer) => {
- extent = calculateExtent(
- layer.getExtent(),
- map.getView().calculateExtent(map.getSize()),
- );
- return promiseTileLayer(layer, extent, viewState, pixelRatio);
- });
- Promise.all(layerPromiseArray).then(() => {
- resolve('resolve layer group');
- });
- });
-}
/**
* Calculate the current extent from the map's extent (boundaries) &
* the viewport extent (boundaries).
@@ -190,26 +156,22 @@ export function promiseLayerGroup(layer, viewState, pixelRatio, map, def) {
* @return {array} An extent array. Used to calculate
* the extent for prev, next & current day
*/
-export function calculateExtent(extent, viewportExtent) {
+function calculateExtent(extent, viewportExtent) {
+ const newExtent = getExtent(viewportExtent, extent);
if (extent[1] < -180) {
// Previous day
- extent = getExtent(viewportExtent, extent);
- extent[1] += 360;
- extent[3] += 360;
+ newExtent[1] += 360;
+ newExtent[3] += 360;
} else if (extent[1] > 180) {
// Next day
- extent = getExtent(viewportExtent, extent);
- extent[1] -= 360;
- extent[3] -= 360;
- } else {
- // Current day (within map extent)
- extent = getExtent(extent, viewportExtent);
- }
+ newExtent[1] -= 360;
+ newExtent[3] -= 360;
+ } else
// eslint-disable-next-line no-restricted-globals
- if (!isFinite(extent[0])) {
+ if (!isFinite(newExtent[0])) {
return null;
}
- return extent;
+ return newExtent;
}
/**
@@ -223,6 +185,7 @@ export function calculateExtent(extent, viewportExtent) {
function getExtent(extent1, extent2) {
return olExtent.getIntersection(extent1, extent2);
}
+
/**
* Returns a promise of the layer tilegrid.
*
@@ -233,55 +196,102 @@ function getExtent(extent1, extent2) {
* @param {number} pixelRatio The window.devicePixelRatio, used to detect retina displays
* @return {object} promise
*/
-function promiseTileLayer(layer, extent, viewState, pixelRatio) {
- let renderer;
+function promiseTileLayer(layer, extent, map) {
let tileSource;
let currentZ;
let i;
let tileGrid;
- let projection;
- return new Promise((resolve, reject) => {
+ return new Promise((resolve) => {
if (!extent) {
resolve('resolve tile layer');
}
- projection = viewState.projection;
- i = 0;
- renderer = new OlRendererCanvasTileLayer(layer);
+ // OL object describing the current map frame
+ const { pixelRatio, viewState } = map.frameState_;
+ const { projection, resolution } = viewState;
+ const { zDirection } = new OlRendererCanvasTileLayer(layer);
tileSource = layer.getSource();
tileGrid = tileSource.getTileGridForProjection(projection);
- currentZ = tileGrid.getZForResolution(
- viewState.resolution,
- renderer.zDirection,
- );
- tileGrid.forEachTileCoord(extent, currentZ, (tileCoord) => {
- const tile = tileSource.getTile(
- tileCoord[0],
- tileCoord[1],
- tileCoord[2],
- pixelRatio,
- projection,
- );
- tile.load();
-
- if (tile.state === 2) resolve();
+ currentZ = tileGrid.getZForResolution(resolution, zDirection);
+ i = 0;
- const loader = function(e) {
- if (e.type === 'tileloadend') {
- i -= 1;
- if (i === 0) {
- resolve();
- }
- } else {
- console.error(`No response for tile request ${layer.wv.key}`);
- resolve(); // some gibs data is not accurate and rejecting this will break the animation if tile doesn't exist
- }
- this.un('tileloadend', loader); // remove event listeners from memory
- this.un('tileloaderror', loader);
+ const onLoad = function onLoad (e) {
+ const complete = function () {
+ tileSource.un('tileloadend', onLoad);
+ tileSource.un('tileloaderror', onLoad);
+ resolve();
};
- tileSource.on('tileloadend', loader);
- tileSource.on('tileloaderror', loader);
+ if (e.type === 'tileloadend') {
+ i -= 1;
+ if (i === 0) {
+ complete();
+ }
+ } else {
+ // eslint-disable-next-line no-console
+ console.error(`No response for tile request ${layer.wv.key}`);
+ // some gibs data is not accurate and rejecting here
+ // will break the animation if tile doesn't exist
+ complete();
+ }
+ };
+
+ const loadTile = function ([one, two, three]) {
+ const tile = tileSource.getTile(one, two, three, pixelRatio, projection);
+ tile.load();
+ if (tile.state === 2) resolve();
i += 1;
+ tileSource.on('tileloadend', onLoad);
+ tileSource.on('tileloaderror', onLoad);
+ };
+
+ tileGrid.forEachTileCoord(extent, currentZ, loadTile);
+ });
+}
+
+/**
+ * Once a layer's group of layers (prev, current, next day) are fulfilled,
+ * a promise with an array of their fulfilled values is returned.
+ *
+ * @method promiseLayerGroup
+ * @param {object} layer ol_Layer_Group object, contains values.layers for prev, current, next days
+ * @param {object} viewState Contains center, projection, resolution, rotation and zoom parameters
+ * @param {number} pixelRatio The window.devicePixelRatio, used to detect retina displays
+ * @param {object} map _ol_Map_ object
+ * @return {object} Promise
+ */
+function promiseLayerGroup(layerGroup, map) {
+ return new Promise((resolve, reject) => {
+ // Current layer's 3 layer array (prev, current, next days)
+ const layers = layerGroup.getLayersArray() || [layerGroup];
+ const viewPortExtent = map.getView().calculateExtent(map.getSize());
+
+ const layerPromiseArray = layers.map((layer) => {
+ const layerExtent = layer.getExtent();
+ const extent = calculateExtent(layerExtent, viewPortExtent);
+ return promiseTileLayer(layer, extent, map);
});
+
+ Promise.all(layerPromiseArray).then(resolve);
});
}
+
+/**
+ * @method promiseImageryForTime
+ * @return {object} Promise
+ */
+export async function promiseImageryForTime(state, date, activeString) {
+ const { map } = state;
+ const {
+ cache, selected, createLayer, layerKey,
+ } = map.ui;
+ const options = { date, group: activeString };
+ const layers = getActiveVisibleLayersAtDate(state, date, activeString);
+
+ await Promise.all(layers.map((layer) => {
+ const key = layerKey(layer, options, state);
+ const layerGroup = cache.getItem(key) || createLayer(layer, options);
+ return promiseLayerGroup(layerGroup, selected);
+ }));
+
+ return date;
+}