Interactive interface for browsing global, full-resolution satellite imagery
import { useState, useEffect, useRef } from 'react';
import { useSelector, useDispatch } from 'react-redux';
import {
Spinner,
} from 'reactstrap';
import PropTypes from 'prop-types';
import { selectDate as selectDateAction } from '../../../modules/date/actions';
import { getBaseCmrUrl } from '../../../modules/smart-handoff/selectors';
import { buildGranulesUrl, cmrFetch } from '../../../util/cmr';
const dateOptions = {
year: 'numeric',
month: 'long',
day: 'numeric',
timeZone: 'UTC',
};
const parseGranuleTimestamp = (granule) => new Date(granule.time_start);
const maxExtent = [-180, -90, 180, 90];
export default function ImagerySearch({ layer }) {
const listRef = useRef(null);
const startRef = useRef(null);
const endRef = useRef(null);
const dispatch = useDispatch();
const selectDate = (date) => { dispatch(selectDateAction(date)); };
const date = useSelector((state) => state.date);
const compare = useSelector((state) => state.compare);
const map = useSelector((state) => state.map);
const cmrBaseUrl = useSelector(getBaseCmrUrl);
const [granulesStartStatus, setGranulesStartStatus] = useState(undefined);
const [granulesEndStatus, setGranulesEndStatus] = useState(undefined);
const [olderGranuleDates, setOlderGranuleDates] = useState([]);
const [newerGranuleDates, setNewerGranuleDates] = useState([]);
const [page, setPage] = useState(1);
let selectedDate = date.selected;
if (compare.active && !compare.isCompareA) {
selectedDate = date.selectedB;
}
const conceptID = layer?.conceptIds?.[0]?.value || layer?.collectionConceptID;
const getSmallerExtent = () => {
// clamp extent to maximum extent allowed by the CMR api
const extent = map.extent.map((coord, i) => {
const condition = i <= 1 ? coord > maxExtent[i] : coord < maxExtent[i];
if (condition) {
return coord;
}
return maxExtent[i];
});
const xDiff = Math.abs(extent[0] - extent[2]);
const yDiff = Math.abs(extent[1] - extent[3]);
// Reduce width by 40% and height by 20%, to show only centered data
const smallerExtent = [
extent[0] + (xDiff * 0.2),
extent[1] + (yDiff * 0.1),
extent[2] - (xDiff * 0.2),
extent[3] - (yDiff * 0.1),
];
return smallerExtent;
};
const getOlderGranules = async (layerArg, refDate = selectedDate, pageNum = 1) => {
const smallerExtent = getSmallerExtent();
try {
const olderUrl = buildGranulesUrl(cmrBaseUrl, {
conceptId: conceptID,
bbox: smallerExtent.join(','),
temporal: `,${refDate.toISOString()}`,
sortKey: '-start_date',
pageSize: 25,
pageNum,
});
const olderResponse = await cmrFetch(olderUrl);
const olderGranules = await olderResponse.json();
const olderDates = olderGranules.feed.entry.map(parseGranuleTimestamp);
return olderDates;
} catch {
return [];
}
};
const getNewerGranules = async (layerArg, refDate = selectedDate, pageNum = 1) => {
const smallerExtent = getSmallerExtent();
try {
const newerUrl = buildGranulesUrl(cmrBaseUrl, {
conceptId: conceptID,
bbox: smallerExtent.join(','),
temporal: `${refDate.toISOString()},`,
sortKey: 'start_date',
pageSize: 25,
pageNum,
});
const newerResponse = await cmrFetch(newerUrl);
const newerGranules = await newerResponse.json();
const newerDates = newerGranules.feed.entry.map(parseGranuleTimestamp);
return newerDates;
} catch {
return [];
}
};
const loadNewerDates = async (layerArg, pageNum = 1) => {
setGranulesStartStatus('loading');
const newerDates = await getNewerGranules(layerArg, newerGranuleDates[0], pageNum);
const dates = [
...newerGranuleDates,
...newerDates,
].sort((a, b) => Date.parse(b) - Date.parse(a));
setNewerGranuleDates(dates);
setGranulesStartStatus('loaded');
};
const loadOlderDates = async (layerArg, pageNum = 1) => {
setGranulesEndStatus('loading');
const olderDates = await getOlderGranules(layerArg, olderGranuleDates.at(-1), pageNum);
const dates = [
...olderGranuleDates,
...olderDates,
].sort((a, b) => Date.parse(b) - Date.parse(a));
setOlderGranuleDates(dates);
setGranulesEndStatus('loaded');
};
const handleSelection = (dateArg) => {
selectDate(new Date(dateArg));
};
useEffect(() => {
const asyncFunc = async () => {
if (listRef.current.scrollHeight <= listRef.current.clientHeight) {
await Promise.allSettled([loadOlderDates(layer, page), loadNewerDates(layer, page)]);
setPage(page + 1);
} else {
listRef.current.scrollTop = listRef.current.scrollHeight / 2;
}
};
asyncFunc();
}, [page]);
const renderDates = () => {
const granuleDates = [
...olderGranuleDates,
...newerGranuleDates,
].sort((a, b) => Date.parse(b) - Date.parse(a));
const renderedDates = [
...new Set(granuleDates.map((granuleDate) => granuleDate.toLocaleDateString('en-US', dateOptions))),
].map((granuleDate, i) => (
<li className="lazyload-list-item" key={granuleDate} onClick={() => handleSelection(granuleDate)}>
{granuleDate}
</li>
));
return renderedDates;
};
const handleScroll = (e) => {
const { scrollTop } = e.target;
const position = e.target.scrollHeight - e.target.clientHeight;
const scrollPercentage = scrollTop / position;
if (scrollPercentage <= 0.1) {
loadNewerDates(layer);
}
if (scrollPercentage >= 0.9) {
loadOlderDates(layer);
}
};
return (
<div className="imagery-search-container">
<p className="lazyload-title">Available Imagery Dates</p>
<ul ref={listRef} className="lazyload-list" onScroll={handleScroll}>
<li ref={startRef} className="imagery-search-spinner">
{granulesStartStatus === 'loading' && <Spinner size="sm">Loading...</Spinner>}
</li>
{renderDates()}
<li ref={endRef} className="imagery-search-spinner">
{granulesEndStatus === 'loading' && <Spinner size="sm">Loading...</Spinner>}
</li>
</ul>
<hr />
</div>
);
}
ImagerySearch.propTypes = {
layer: PropTypes.oneOfType([PropTypes.object, PropTypes.oneOf(['null'])]),
};