def metadata(sceneid):
"""Create footprint from metadata."""
geom = {"type": "FeatureCollection", "features": []}
metadata = _landsat_get_mtl(sceneid)
m = metadata["L1_METADATA_FILE"]["PRODUCT_METADATA"]
bbox_geometry = {
"type": "Feature",
"properties": {"type": "data bbox"},
"geometry": {
"type": "Polygon",
"coordinates": [
[
[m["CORNER_UL_LON_PRODUCT"], m["CORNER_UL_LAT_PRODUCT"]],
[m["CORNER_UR_LON_PRODUCT"], m["CORNER_UR_LAT_PRODUCT"]],
[m["CORNER_LR_LON_PRODUCT"], m["CORNER_LR_LAT_PRODUCT"]],
[m["CORNER_LL_LON_PRODUCT"], m["CORNER_LL_LAT_PRODUCT"]],
[m["CORNER_UL_LON_PRODUCT"], m["CORNER_UL_LAT_PRODUCT"]],
]
],
},
}
geom["features"].append(bbox_geometry)
nlines = m["REFLECTIVE_LINES"]
nSamps = m["REFLECTIVE_SAMPLES"]
bounds = _get_bounds_from_metadata(m)
ang = landsat_get_ang(sceneid)
linesBounds = ang["RPC_BAND01"]["BAND01_L1T_IMAGE_CORNER_LINES"]
sampsBounds = ang["RPC_BAND01"]["BAND01_L1T_IMAGE_CORNER_SAMPS"]
dlon = bounds[2] - bounds[0]
dlat = bounds[3] - bounds[1]
lons = [c / nSamps * dlon + bounds[0] for c in sampsBounds]
lats = [((nlines - c) / nlines) * dlat + bounds[1] for c in linesBounds]
data_geometry = {
"type": "Feature",
"properties": {"type": "data bounds"},
"geometry": {
"type": "Polygon",
"coordinates": [
[
[lons[0], lats[0]],
[lons[1], lats[1]],
[lons[2], lats[2]],
[lons[3], lats[3]],
[lons[0], lats[0]],
]
],
},
}
geom["features"].append(data_geometry)
click.echo(json.dumps(geom))
def __enter__(self):
"""Support using with Context Managers."""
self.scene_params = sceneid_parser(self.sceneid)
prefix = self._prefix.format(**self.scene_params)
basename = f"{self.sceneid}_MTL.txt"
self.mtl_metadata = toa_utils._parse_mtl_txt(
get_object(self._hostname, f"{prefix}/{basename}").decode())
self.bounds = tuple(
toa_utils._get_bounds_from_metadata(
self.mtl_metadata["L1_METADATA_FILE"]["PRODUCT_METADATA"]))
return self
def test_sun_angle3(test_data):
# South, Winter
mtl = test_data[2]
mtl_sun = mtl['L1_METADATA_FILE']['IMAGE_ATTRIBUTES']['SUN_ELEVATION']
bbox = BoundingBox(*toa_utils._get_bounds_from_metadata(
mtl['L1_METADATA_FILE']['PRODUCT_METADATA']))
sunangles = sun_utils.sun_elevation(
bbox, (100, 100),
mtl['L1_METADATA_FILE']['PRODUCT_METADATA']['DATE_ACQUIRED'],
mtl['L1_METADATA_FILE']['PRODUCT_METADATA']['SCENE_CENTER_TIME'])
assert sunangles[49][49] - mtl_sun < 5
def test_sun_angle2(test_data):
# North, Summer
mtl = test_data[1]
mtl_sun = mtl['L1_METADATA_FILE']['IMAGE_ATTRIBUTES']['SUN_ELEVATION']
bbox = BoundingBox(*toa_utils._get_bounds_from_metadata(
mtl['L1_METADATA_FILE']['PRODUCT_METADATA']))
sunangles = sun_utils.sun_elevation(
bbox, (100, 100),
mtl['L1_METADATA_FILE']['PRODUCT_METADATA']['DATE_ACQUIRED'],
mtl['L1_METADATA_FILE']['PRODUCT_METADATA']['SCENE_CENTER_TIME'])
assert np.mean(sunangles[0, :]) < np.mean(
sunangles[-1, :]), "In N, Nrow should < Srow"
assert sunangles.max() > mtl_sun
assert sunangles.min() < mtl_sun
def metadata(sceneid, pmin=2, pmax=98):
"""
Retrieve image bounds and histogram info.
Attributes
----------
sceneid : str
Landsat sceneid. For scenes after May 2017,
sceneid have to be LANDSAT_PRODUCT_ID.
pmin : int, optional, (default: 2)
Histogram minimum cut.
pmax : int, optional, (default: 98)
Histogram maximum cut.
Returns
-------
out : dict
dictionary with image bounds and bands histogram cuts.
"""
scene_params = utils.landsat_parse_scene_id(sceneid)
meta_data = utils.landsat_get_mtl(sceneid).get("L1_METADATA_FILE")
landsat_address = "{}/{}".format(LANDSAT_BUCKET, scene_params["key"])
info = {"sceneid": sceneid}
info["bounds"] = toa_utils._get_bounds_from_metadata(
meta_data["PRODUCT_METADATA"])
bands = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11"]
_min_max_worker = partial(
utils.landsat_min_max_worker,
address=landsat_address,
metadata=meta_data,
pmin=pmin,
pmax=pmax,
)
with futures.ThreadPoolExecutor(max_workers=5) as executor:
responses = list(executor.map(_min_max_worker, bands))
info["rgbMinMax"] = dict(zip(bands, responses))
return info
def metadata(sceneid, pmin=2, pmax=98):
"""Retrieve image bounds and histogram info.
Attributes
----------
sceneid : str
Landsat sceneid. For scenes after May 2017,
sceneid have to be LANDSAT_PRODUCT_ID.
pmin : int, optional, (default: 2)
Histogram minimum cut.
pmax : int, optional, (default: 98)
Histogram maximum cut.
Returns
-------
out : dict
dictionary with image bounds and bands histogram cuts.
"""
scene_params = utils.landsat_parse_scene_id(sceneid)
meta_data = utils.landsat_get_mtl(sceneid).get('L1_METADATA_FILE')
landsat_address = '{}/{}'.format(LANDSAT_BUCKET, scene_params['key'])
info = {'sceneid': sceneid}
info['bounds'] = toa_utils._get_bounds_from_metadata(
meta_data['PRODUCT_METADATA'])
bands = ['1', '2', '3', '4', '5', '6', '7']
_min_max_worker = partial(utils.landsat_min_max_worker,
address=landsat_address,
metadata=meta_data,
pmin=pmin,
pmax=pmax)
with futures.ThreadPoolExecutor(max_workers=7) as executor:
responses = list(executor.map(_min_max_worker, bands))
info['rgbMinMax'] = dict(zip(bands, responses))
return info
def bounds(sceneid: str) -> Dict:
"""
Retrieve image bounds.
Attributes
----------
sceneid : str
Landsat sceneid. For scenes after May 2017,
sceneid have to be LANDSAT_PRODUCT_ID.
Returns
-------
out : dict
dictionary with image bounds.
"""
meta: Dict = _landsat_get_mtl(sceneid)["L1_METADATA_FILE"]
return dict(
sceneid=sceneid,
bounds=toa_utils._get_bounds_from_metadata(meta["PRODUCT_METADATA"]),
)
def bounds(sceneid):
"""Retrieve image bounds.
Attributes
----------
sceneid : str
Landsat sceneid. For scenes after May 2017,
sceneid have to be LANDSAT_PRODUCT_ID.
Returns
-------
out : dict
dictionary with image bounds.
"""
meta_data = utils.landsat_get_mtl(sceneid).get('L1_METADATA_FILE')
info = {'sceneid': sceneid}
info['bounds'] = toa_utils._get_bounds_from_metadata(meta_data['PRODUCT_METADATA'])
return info
def test_calculate_reflectance2(test_data):
tif_b, tif_shape, mtl = test_data[0], test_data[4], test_data[-1]
M = toa_utils._load_mtl_key(mtl, [
'L1_METADATA_FILE', 'RADIOMETRIC_RESCALING', 'REFLECTANCE_MULT_BAND_'
], 5)
A = toa_utils._load_mtl_key(
mtl,
['L1_METADATA_FILE', 'RADIOMETRIC_RESCALING', 'REFLECTANCE_ADD_BAND_'],
5)
date_collected = toa_utils._load_mtl_key(
mtl, ['L1_METADATA_FILE', 'PRODUCT_METADATA', 'DATE_ACQUIRED'])
time_collected_utc = toa_utils._load_mtl_key(
mtl, ['L1_METADATA_FILE', 'PRODUCT_METADATA', 'SCENE_CENTER_TIME'])
bounds = BoundingBox(*toa_utils._get_bounds_from_metadata(
mtl['L1_METADATA_FILE']['PRODUCT_METADATA']))
E = sun_utils.sun_elevation(bounds, tif_shape, date_collected,
time_collected_utc)
toa = reflectance.reflectance(tif_b, M, A, E)
toa_rescaled = toa_utils.rescale(toa, 55000.0, np.uint16)
assert toa_rescaled.dtype == np.uint16
assert np.all(toa_rescaled) < 1.5
assert np.all(toa_rescaled) >= 0.0
def tile(
sceneid: str,
tile_x: int,
tile_y: int,
tile_z: int,
bands: Union[Sequence[str], str] = ["4", "3", "2"],
tilesize: int = 256,
pan: bool = False,
**kwargs: Any,
) -> Tuple[numpy.ndarray, numpy.ndarray]:
"""
Create mercator tile from Landsat-8 data.
Attributes
----------
sceneid : str
Landsat sceneid. For scenes after May 2017,
sceneid have to be LANDSAT_PRODUCT_ID.
tile_x : int
Mercator tile X index.
tile_y : int
Mercator tile Y index.
tile_z : int
Mercator tile ZOOM level.
bands : tuple, str, optional (default: ("4", "3", "2"))
Bands index for the RGB combination.
tilesize : int, optional (default: 256)
Output image size.
pan : boolean, optional (default: False)
If True, apply pan-sharpening.
kwargs: dict, optional
These will be passed to the 'rio_tiler.utils._tile_read' function.
Returns
-------
data : numpy ndarray
mask: numpy array
"""
if isinstance(bands, str):
bands = (bands,)
for band in bands:
if band not in LANDSAT_BANDS:
raise InvalidBandName("{} is not a valid Landsat band name".format(band))
scene_params = landsat_parser(sceneid)
meta: Dict = _landsat_get_mtl(sceneid)["L1_METADATA_FILE"]
landsat_prefix = "{scheme}://{bucket}/{prefix}/{scene}".format(**scene_params)
bounds = toa_utils._get_bounds_from_metadata(meta["PRODUCT_METADATA"])
if not tile_exists(bounds, tile_z, tile_x, tile_y):
raise TileOutsideBounds(
"Tile {}/{}/{} is outside image bounds".format(tile_z, tile_x, tile_y)
)
def worker(band: str):
asset = f"{landsat_prefix}_B{band}.TIF"
if band == "QA":
nodata = 1
resamp = "nearest"
else:
nodata = 0
resamp = "bilinear"
with rasterio.open(asset) as src_dst:
tile, mask = reader.tile(
src_dst,
tile_x,
tile_y,
tile_z,
tilesize=tilesize,
nodata=nodata,
resampling_method=resamp,
)
return tile, mask
with futures.ThreadPoolExecutor(max_workers=constants.MAX_THREADS) as executor:
data, masks = zip(*list(executor.map(worker, bands)))
data = numpy.concatenate(data)
mask = numpy.all(masks, axis=0).astype(numpy.uint8) * 255
if pan:
pan_data, mask = worker("8")
data = pansharpening_brovey(data, pan_data, 0.2, pan_data.dtype)
if bands[0] != "QA" or len(bands) != 1:
for bdx, band in enumerate(bands):
data[bdx] = _convert(data[bdx], band, meta)
return data, mask
def tile(sceneid,
tile_x,
tile_y,
tile_z,
rgb=(4, 3, 2),
r_bds=(0, 16000),
g_bds=(0, 16000),
b_bds=(0, 16000),
tilesize=256,
pan=False):
"""Create mercator tile from Landsat-8 data and encodes it in base64.
Attributes
----------
sceneid : str
Landsat sceneid. For scenes after May 2017,
sceneid have to be LANDSAT_PRODUCT_ID.
tile_x : int
Mercator tile X index.
tile_y : int
Mercator tile Y index.
tile_z : int
Mercator tile ZOOM level.
rgb : tuple, int, optional (default: (4, 3, 2))
Bands index for the RGB combination.
r_bds : tuple, int, optional (default: (0, 16000))
First band (red) DN min and max values (DN * 10,000)
used for the linear rescaling.
g_bds : tuple, int, optional (default: (0, 16000))
Second band (green) DN min and max values (DN * 10,000)
used for the linear rescaling.
b_bds : tuple, int, optional (default: (0, 16000))
Third band (blue) DN min and max values (DN * 10,000)
used for the linear rescaling.
tilesize : int, optional (default: 256)
Output image size.
pan : boolean, optional (default: False)
If True, apply pan-sharpening.
Returns
-------
out : numpy ndarray (type: uint8)
"""
scene_params = utils.landsat_parse_scene_id(sceneid)
meta_data = utils.landsat_get_mtl(sceneid).get('L1_METADATA_FILE')
landsat_address = '{}/{}'.format(LANDSAT_BUCKET, scene_params['key'])
wgs_bounds = toa_utils._get_bounds_from_metadata(
meta_data['PRODUCT_METADATA'])
if not utils.tile_exists(wgs_bounds, tile_z, tile_x, tile_y):
raise TileOutsideBounds('Tile {}/{}/{} is outside image bounds'.format(
tile_z, tile_x, tile_y))
mercator_tile = mercantile.Tile(x=tile_x, y=tile_y, z=tile_z)
tile_bounds = mercantile.xy_bounds(mercator_tile)
# define a list of bands Min and Max Values (from input)
histo_cuts = dict(zip(rgb, [r_bds, g_bds, b_bds]))
ms_tile_size = int(tilesize / 2) if pan else tilesize
addresses = ['{}_B{}.TIF'.format(landsat_address, band) for band in rgb]
_tiler = partial(utils.tile_band_worker,
bounds=tile_bounds,
tilesize=ms_tile_size)
with futures.ThreadPoolExecutor(max_workers=3) as executor:
out = np.stack(list(executor.map(_tiler, addresses)))
if pan:
pan_address = '{}_B8.TIF'.format(landsat_address)
matrix_pan = utils.tile_band_worker(pan_address, tile_bounds,
tilesize)
w, s, e, n = tile_bounds
pan_transform = transform.from_bounds(w, s, e, n, tilesize,
tilesize)
vis_transform = pan_transform * Affine.scale(2.)
out = pansharpen(out,
vis_transform,
matrix_pan,
pan_transform,
np.int16,
'EPSG:3857',
'EPSG:3857',
0.2,
method='Brovey',
src_nodata=0)
sun_elev = meta_data['IMAGE_ATTRIBUTES']['SUN_ELEVATION']
for bdx, band in enumerate(rgb):
multi_reflect = meta_data['RADIOMETRIC_RESCALING'].get(
'REFLECTANCE_MULT_BAND_{}'.format(band))
add_reflect = meta_data['RADIOMETRIC_RESCALING'].get(
'REFLECTANCE_ADD_BAND_{}'.format(band))
out[bdx] = 10000 * reflectance.reflectance(
out[bdx], multi_reflect, add_reflect, sun_elev, src_nodata=0)
out[bdx] = np.where(
out[bdx] > 0,
utils.linear_rescale(out[bdx],
in_range=histo_cuts.get(band),
out_range=[1, 255]), 0)
return out.astype(np.uint8)
def tile(sceneid, tile_x, tile_y, tile_z, rgb=(4, 3, 2), tilesize=256, pan=False):
"""Create mercator tile from Landsat-8 data.
Attributes
----------
sceneid : str
Landsat sceneid. For scenes after May 2017,
sceneid have to be LANDSAT_PRODUCT_ID.
tile_x : int
Mercator tile X index.
tile_y : int
Mercator tile Y index.
tile_z : int
Mercator tile ZOOM level.
rgb : tuple, int, optional (default: (4, 3, 2))
Bands index for the RGB combination.
tilesize : int, optional (default: 256)
Output image size.
pan : boolean, optional (default: False)
If True, apply pan-sharpening.
Returns
-------
data : numpy ndarray
mask: numpy array
"""
if not isinstance(rgb, tuple):
rgb = tuple((rgb, ))
scene_params = utils.landsat_parse_scene_id(sceneid)
meta_data = utils.landsat_get_mtl(sceneid).get('L1_METADATA_FILE')
landsat_address = '{}/{}'.format(LANDSAT_BUCKET, scene_params['key'])
wgs_bounds = toa_utils._get_bounds_from_metadata(
meta_data['PRODUCT_METADATA'])
if not utils.tile_exists(wgs_bounds, tile_z, tile_x, tile_y):
raise TileOutsideBounds(
'Tile {}/{}/{} is outside image bounds'.format(
tile_z, tile_x, tile_y))
mercator_tile = mercantile.Tile(x=tile_x, y=tile_y, z=tile_z)
tile_bounds = mercantile.xy_bounds(mercator_tile)
ms_tile_size = int(tilesize / 2) if pan else tilesize
addresses = ['{}_B{}.TIF'.format(landsat_address, band) for band in rgb]
_tiler = partial(utils.tile_band_worker, bounds=tile_bounds, tilesize=ms_tile_size, nodata=0)
with futures.ThreadPoolExecutor(max_workers=3) as executor:
data, masks = zip(*list(executor.map(_tiler, addresses)))
data = np.concatenate(data)
mask = np.all(masks, axis=0).astype(np.uint8) * 255
if pan:
pan_address = '{}_B8.TIF'.format(landsat_address)
matrix_pan, mask = utils.tile_band_worker(pan_address, tile_bounds, tilesize, nodata=0)
w, s, e, n = tile_bounds
pan_transform = transform.from_bounds(w, s, e, n, tilesize, tilesize)
vis_transform = pan_transform * Affine.scale(2.)
data = pansharpen(data, vis_transform, matrix_pan, pan_transform,
np.int16, 'EPSG:3857', 'EPSG:3857', 0.2,
method='Brovey', src_nodata=0)
sun_elev = meta_data['IMAGE_ATTRIBUTES']['SUN_ELEVATION']
for bdx, band in enumerate(rgb):
if int(band) > 9: # TIRS
multi_rad = meta_data['RADIOMETRIC_RESCALING'].get(
'RADIANCE_MULT_BAND_{}'.format(band))
add_rad = meta_data['RADIOMETRIC_RESCALING'].get(
'RADIANCE_ADD_BAND_{}'.format(band))
k1 = meta_data['TIRS_THERMAL_CONSTANTS'].get(
'K1_CONSTANT_BAND_{}'.format(band))
k2 = meta_data['TIRS_THERMAL_CONSTANTS'].get(
'K2_CONSTANT_BAND_{}'.format(band))
data[bdx] = brightness_temp.brightness_temp(
data[bdx], multi_rad, add_rad, k1, k2)
else:
multi_reflect = meta_data['RADIOMETRIC_RESCALING'].get(
'REFLECTANCE_MULT_BAND_{}'.format(band))
add_reflect = meta_data['RADIOMETRIC_RESCALING'].get(
'REFLECTANCE_ADD_BAND_{}'.format(band))
data[bdx] = 10000 * reflectance.reflectance(
data[bdx], multi_reflect, add_reflect, sun_elev)
return data, mask
def tile(sceneid,
tile_x,
tile_y,
tile_z,
bands=("4", "3", "2"),
tilesize=256,
pan=False,
**kwargs):
"""
Create mercator tile from Landsat-8 data.
Attributes
----------
sceneid : str
Landsat sceneid. For scenes after May 2017,
sceneid have to be LANDSAT_PRODUCT_ID.
tile_x : int
Mercator tile X index.
tile_y : int
Mercator tile Y index.
tile_z : int
Mercator tile ZOOM level.
bands : tuple, str, optional (default: ("4", "3", "2"))
Bands index for the RGB combination.
tilesize : int, optional (default: 256)
Output image size.
pan : boolean, optional (default: False)
If True, apply pan-sharpening.
kwargs: dict, optional
These will be passed to the 'rio_tiler.utils._tile_read' function.
Returns
-------
data : numpy ndarray
mask: numpy array
"""
if not isinstance(bands, tuple):
bands = tuple((bands, ))
for band in bands:
if band not in LANDSAT_BANDS:
raise InvalidBandName(
"{} is not a valid Landsat band name".format(band))
scene_params = _landsat_parse_scene_id(sceneid)
meta_data = _landsat_get_mtl(sceneid).get("L1_METADATA_FILE")
landsat_address = "{}/{}".format(LANDSAT_BUCKET, scene_params["key"])
wgs_bounds = toa_utils._get_bounds_from_metadata(
meta_data["PRODUCT_METADATA"])
if not utils.tile_exists(wgs_bounds, tile_z, tile_x, tile_y):
raise TileOutsideBounds("Tile {}/{}/{} is outside image bounds".format(
tile_z, tile_x, tile_y))
mercator_tile = mercantile.Tile(x=tile_x, y=tile_y, z=tile_z)
tile_bounds = mercantile.xy_bounds(mercator_tile)
def _tiler(band):
address = "{}_B{}.TIF".format(landsat_address, band)
if band == "QA":
nodata = 1
else:
nodata = 0
return utils.tile_read(address,
bounds=tile_bounds,
tilesize=tilesize,
nodata=nodata,
**kwargs)
with futures.ThreadPoolExecutor(max_workers=MAX_THREADS) as executor:
data, masks = zip(*list(executor.map(_tiler, bands)))
data = np.concatenate(data)
mask = np.all(masks, axis=0).astype(np.uint8) * 255
if pan:
pan_address = "{}_B8.TIF".format(landsat_address)
matrix_pan, mask = utils.tile_read(pan_address,
tile_bounds,
tilesize,
nodata=0)
data = utils.pansharpening_brovey(data, matrix_pan, 0.2,
matrix_pan.dtype)
sun_elev = meta_data["IMAGE_ATTRIBUTES"]["SUN_ELEVATION"]
for bdx, band in enumerate(bands):
if band in ["1", "2", "3", "4", "5", "6", "7", "8", "9"]: # OLI
multi_reflect = meta_data["RADIOMETRIC_RESCALING"].get(
"REFLECTANCE_MULT_BAND_{}".format(band))
add_reflect = meta_data["RADIOMETRIC_RESCALING"].get(
"REFLECTANCE_ADD_BAND_{}".format(band))
data[bdx] = 10000 * reflectance.reflectance(
data[bdx], multi_reflect, add_reflect, sun_elev)
elif band in ["10", "11"]: # TIRS
multi_rad = meta_data["RADIOMETRIC_RESCALING"].get(
"RADIANCE_MULT_BAND_{}".format(band))
add_rad = meta_data["RADIOMETRIC_RESCALING"].get(
"RADIANCE_ADD_BAND_{}".format(band))
k1 = meta_data["TIRS_THERMAL_CONSTANTS"].get(
"K1_CONSTANT_BAND_{}".format(band))
k2 = meta_data["TIRS_THERMAL_CONSTANTS"].get(
"K2_CONSTANT_BAND_{}".format(band))
data[bdx] = brightness_temp.brightness_temp(
data[bdx], multi_rad, add_rad, k1, k2)
return data, mask
def tile(sceneid,
tile_x,
tile_y,
tile_z,
bands=("4", "3", "2"),
tilesize=256,
pan=False):
"""
Create mercator tile from Landsat-8 data.
Attributes
----------
sceneid : str
Landsat sceneid. For scenes after May 2017,
sceneid have to be LANDSAT_PRODUCT_ID.
tile_x : int
Mercator tile X index.
tile_y : int
Mercator tile Y index.
tile_z : int
Mercator tile ZOOM level.
bands : tuple, str, optional (default: ("4", "3", "2"))
Bands index for the RGB combination.
tilesize : int, optional (default: 256)
Output image size.
pan : boolean, optional (default: False)
If True, apply pan-sharpening.
Returns
-------
data : numpy ndarray
mask: numpy array
"""
if not isinstance(bands, tuple):
bands = tuple((bands, ))
for band in bands:
if band not in LANDSAT_BANDS:
raise InvalidBandName(
"{} is not a valid Landsat band name".format(band))
scene_params = _landsat_parse_scene_id(sceneid)
meta_data = _landsat_get_mtl(sceneid).get("L1_METADATA_FILE")
landsat_address = "{}/{}".format(LANDSAT_BUCKET, scene_params["key"])
wgs_bounds = toa_utils._get_bounds_from_metadata(
meta_data["PRODUCT_METADATA"])
if not utils.tile_exists(wgs_bounds, tile_z, tile_x, tile_y):
raise TileOutsideBounds("Tile {}/{}/{} is outside image bounds".format(
tile_z, tile_x, tile_y))
mercator_tile = mercantile.Tile(x=tile_x, y=tile_y, z=tile_z)
tile_bounds = mercantile.xy_bounds(mercator_tile)
ms_tile_size = int(tilesize / 2) if pan else tilesize
addresses = ["{}_B{}.TIF".format(landsat_address, band) for band in bands]
_tiler = partial(utils.tile_read,
bounds=tile_bounds,
tilesize=ms_tile_size,
nodata=0)
with futures.ThreadPoolExecutor(max_workers=MAX_THREADS) as executor:
data, masks = zip(*list(executor.map(_tiler, addresses)))
data = np.concatenate(data)
mask = np.all(masks, axis=0).astype(np.uint8) * 255
if pan:
pan_address = "{}_B8.TIF".format(landsat_address)
matrix_pan, mask = utils.tile_read(pan_address,
tile_bounds,
tilesize,
nodata=0)
w, s, e, n = tile_bounds
pan_transform = transform.from_bounds(w, s, e, n, tilesize,
tilesize)
vis_transform = pan_transform * Affine.scale(2.0)
data = pansharpen(
data,
vis_transform,
matrix_pan,
pan_transform,
np.int16,
"EPSG:3857",
"EPSG:3857",
0.2,
method="Brovey",
src_nodata=0,
)
sun_elev = meta_data["IMAGE_ATTRIBUTES"]["SUN_ELEVATION"]
for bdx, band in enumerate(bands):
if int(band) > 9: # TIRS
multi_rad = meta_data["RADIOMETRIC_RESCALING"].get(
"RADIANCE_MULT_BAND_{}".format(band))
add_rad = meta_data["RADIOMETRIC_RESCALING"].get(
"RADIANCE_ADD_BAND_{}".format(band))
k1 = meta_data["TIRS_THERMAL_CONSTANTS"].get(
"K1_CONSTANT_BAND_{}".format(band))
k2 = meta_data["TIRS_THERMAL_CONSTANTS"].get(
"K2_CONSTANT_BAND_{}".format(band))
data[bdx] = brightness_temp.brightness_temp(
data[bdx], multi_rad, add_rad, k1, k2)
else:
multi_reflect = meta_data["RADIOMETRIC_RESCALING"].get(
"REFLECTANCE_MULT_BAND_{}".format(band))
add_reflect = meta_data["RADIOMETRIC_RESCALING"].get(
"REFLECTANCE_ADD_BAND_{}".format(band))
data[bdx] = 10000 * reflectance.reflectance(
data[bdx], multi_reflect, add_reflect, sun_elev)
return data, mask
def landsat8_tile(sceneid,
tile_x,
tile_y,
tile_z,
bands=("4", "3", "2"),
tilesize=256,
pan=False,
percents="",
**kwargs):
"""
Create mercator tile from Landsat-8 data.
Attributes
----------
sceneid : str
Landsat sceneid. For scenes after May 2017,
sceneid have to be LANDSAT_PRODUCT_ID.
tile_x : int
Mercator tile X index.
tile_y : int
Mercator tile Y index.
tile_z : int
Mercator tile ZOOM level.
bands : tuple, str, optional (default: ("4", "3", "2"))
Bands index for the RGB combination.
tilesize : int, optional (default: 256)
Output image size.
pan : boolean, optional (default: False)
If True, apply pan-sharpening.
kwargs: dict, optional
These will be passed to the 'rio_tiler.utils._tile_read' function.
Returns
-------
data : numpy ndarray
mask: numpy array
"""
if not isinstance(bands, tuple):
bands = tuple((bands, ))
for band in bands:
if band not in LANDSAT_BANDS:
raise InvalidBandName(
"{} is not a valid Landsat band name".format(band))
scene_params = landsat8._landsat_parse_scene_id(sceneid)
meta_data = landsat8._landsat_get_mtl(sceneid).get("L1_METADATA_FILE")
landsat_address = "{}/{}".format(LANDSAT_BUCKET, scene_params["key"])
wgs_bounds = toa_utils._get_bounds_from_metadata(
meta_data["PRODUCT_METADATA"])
addresses = ["{}_B{}.TIF".format(landsat_address, band) for band in bands]
values = []
percents = percents.split(',')
i = 0
for address in addresses:
with rasterio.open(address) as src:
if int(percents[i]) != 0 and int(percents[i + 1]) != 100:
overviews = src.overviews(1)
if len(overviews) > 0:
d = src.read(
out_shape=(1,
int(src.height /
overviews[len(overviews) - 1]),
int(src.width /
overviews[len(overviews) - 1])))
else:
d = src.read()
dflatten = numpy.array(d.flatten())
p_start, p_end = numpy.percentile(dflatten[dflatten > 0],
(int(percents[i]),
(int(percents[i + 1]))))
values.append([p_start, p_end])
else:
values.append([None, None])
i += 2
if not utils.tile_exists(wgs_bounds, tile_z, tile_x, tile_y):
# raise TileOutsideBounds(
# "Tile {}/{}/{} is outside image bounds".format(tile_z, tile_x, tile_y)
# )
return None, None
mercator_tile = mercantile.Tile(x=tile_x, y=tile_y, z=tile_z)
tile_bounds = mercantile.xy_bounds(mercator_tile)
def _tiler(band):
address = "{}_B{}.TIF".format(landsat_address, band)
if band == "QA":
nodata = 1
else:
nodata = 0
return utils.tile_read(address,
bounds=tile_bounds,
tilesize=tilesize,
nodata=nodata,
**kwargs)
with futures.ThreadPoolExecutor(max_workers=MAX_THREADS) as executor:
data, masks = zip(*list(executor.map(_tiler, bands)))
mask = numpy.all(masks, axis=0).astype(numpy.uint8) * 255
new_data = list(data)
has_modification = False
for ds in range(0, len(new_data)):
if values[ds][0] is not None and values[ds][1] is not None:
has_modification = True
new_data[ds] = rescale_intensity(new_data[ds],
in_range=(values[ds][0],
values[ds][1]),
out_range=(0, 255))
if has_modification == True:
data = numpy.array(new_data).astype(numpy.uint8)
data = numpy.concatenate(data)
if pan:
pan_address = "{}_B8.TIF".format(landsat_address)
matrix_pan, mask = utils.tile_read(pan_address,
tile_bounds,
tilesize,
nodata=0)
data = utils.pansharpening_brovey(data, matrix_pan, 0.2,
matrix_pan.dtype)
sun_elev = meta_data["IMAGE_ATTRIBUTES"]["SUN_ELEVATION"]
for bdx, band in enumerate(bands):
if band in ["1", "2", "3", "4", "5", "6", "7", "8", "9"]: # OLI
multi_reflect = meta_data["RADIOMETRIC_RESCALING"].get(
"REFLECTANCE_MULT_BAND_{}".format(band))
add_reflect = meta_data["RADIOMETRIC_RESCALING"].get(
"REFLECTANCE_ADD_BAND_{}".format(band))
data[bdx] = 10000 * reflectance.reflectance(
data[bdx], multi_reflect, add_reflect, sun_elev)
elif band in ["10", "11"]: # TIRS
multi_rad = meta_data["RADIOMETRIC_RESCALING"].get(
"RADIANCE_MULT_BAND_{}".format(band))
add_rad = meta_data["RADIOMETRIC_RESCALING"].get(
"RADIANCE_ADD_BAND_{}".format(band))
k1 = meta_data["TIRS_THERMAL_CONSTANTS"].get(
"K1_CONSTANT_BAND_{}".format(band))
k2 = meta_data["TIRS_THERMAL_CONSTANTS"].get(
"K2_CONSTANT_BAND_{}".format(band))
data[bdx] = brightness_temp.brightness_temp(
data[bdx], multi_rad, add_rad, k1, k2)
return data, mask
