def test_apply_discrete_cmap():
"""Should return valid data and mask."""
cm = {1: (0, 0, 0, 255), 2: (255, 255, 255, 255)}
data = numpy.zeros(shape=(1, 10, 10), dtype=numpy.uint16)
data[0, 0:2, 0:2] = 1000
data[0, 2:5, 2:5] = 1
data[0, 5:, 5:] = 2
d, m = colormap.apply_discrete_cmap(data, cm)
assert d.shape == (3, 10, 10)
assert m.shape == (10, 10)
mask = numpy.zeros(shape=(10, 10), dtype=numpy.uint8)
mask[2:5, 2:5] = 255
mask[5:, 5:] = 255
numpy.testing.assert_array_equal(m, mask)
data = data.astype("uint16")
d, m = colormap.apply_discrete_cmap(data, cm)
assert d.dtype == numpy.uint8
assert m.dtype == numpy.uint8
cm = {1: (0, 0, 0, 255), 1000: (255, 255, 255, 255)}
d, m = colormap.apply_cmap(data, cm)
dd, mm = colormap.apply_discrete_cmap(data, cm)
numpy.testing.assert_array_equal(dd, d)
numpy.testing.assert_array_equal(mm, m)
cm = deepcopy(colormap.EMPTY_COLORMAP)
cm.pop(255)
cm[1000] = (255, 255, 255, 255)
d, m = colormap.apply_cmap(data, cm)
dd, mm = colormap.apply_discrete_cmap(data, cm)
cm = {1: (0, 0, 0, 255), 256: (255, 255, 255, 255)}
assert colormap.apply_cmap(data, cm)
def test_apply_cmap():
"""Should return valid data and mask."""
cm = {1: [0, 0, 0, 255], 2: [255, 255, 255, 255]}
data = numpy.zeros(shape=(1, 10, 10), dtype=numpy.uint8)
data[0, 2:5, 2:5] = 1
data[0, 5:, 5:] = 2
d, m = colormap.apply_cmap(data, cm)
assert d.shape == (3, 10, 10)
assert m.shape == (10, 10)
mask = numpy.zeros(shape=(10, 10), dtype=numpy.uint8)
mask[2:5, 2:5] = 255
mask[5:, 5:] = 255
numpy.testing.assert_array_equal(m, mask)
with pytest.raises(InvalidFormat):
data = numpy.repeat(data, 3, axis=0)
colormap.apply_cmap(data, cm)
def get(self,
request,
pk=None,
project_pk=None,
tile_type="",
z="",
x="",
y="",
scale=1):
"""
Get a tile image
"""
task = self.get_and_check_task(request, pk)
z = int(z)
x = int(x)
y = int(y)
scale = int(scale)
ext = "png"
driver = "jpeg" if ext == "jpg" else ext
indexes = None
nodata = None
rgb_tile = None
formula = self.request.query_params.get('formula')
bands = self.request.query_params.get('bands')
rescale = self.request.query_params.get('rescale')
color_map = self.request.query_params.get('color_map')
hillshade = self.request.query_params.get('hillshade')
boundaries_feature = self.request.query_params.get('boundaries')
if boundaries_feature == '':
boundaries_feature = None
if boundaries_feature is not None:
try:
boundaries_feature = json.loads(boundaries_feature)
except json.JSONDecodeError:
raise exceptions.ValidationError(
_("Invalid boundaries parameter"))
if formula == '': formula = None
if bands == '': bands = None
if rescale == '': rescale = None
if color_map == '': color_map = None
if hillshade == '' or hillshade == '0': hillshade = None
try:
expr, _discard_ = lookup_formula(formula, bands)
except ValueError as e:
raise exceptions.ValidationError(str(e))
if tile_type in ['dsm', 'dtm'] and rescale is None:
rescale = "0,1000"
if tile_type == 'orthophoto' and rescale is None:
rescale = "0,255"
if tile_type in ['dsm', 'dtm'] and color_map is None:
color_map = "gray"
if tile_type == 'orthophoto' and formula is not None:
if color_map is None:
color_map = "gray"
if rescale is None:
rescale = "-1,1"
if nodata is not None:
nodata = np.nan if nodata == "nan" else float(nodata)
tilesize = scale * 256
url = get_raster_path(task, tile_type)
if not os.path.isfile(url):
raise exceptions.NotFound()
with COGReader(url) as src:
if not src.tile_exists(z, x, y):
raise exceptions.NotFound(_("Outside of bounds"))
with COGReader(url) as src:
minzoom, maxzoom = get_zoom_safe(src)
has_alpha = has_alpha_band(src.dataset)
if z < minzoom - ZOOM_EXTRA_LEVELS or z > maxzoom + ZOOM_EXTRA_LEVELS:
raise exceptions.NotFound()
if boundaries_feature is not None:
try:
boundaries_cutline = create_cutline(
src.dataset, boundaries_feature,
CRS.from_string('EPSG:4326'))
except:
raise exceptions.ValidationError(_("Invalid boundaries"))
else:
boundaries_cutline = None
# Handle N-bands datasets for orthophotos (not plant health)
if tile_type == 'orthophoto' and expr is None:
ci = src.dataset.colorinterp
# More than 4 bands?
if len(ci) > 4:
# Try to find RGBA band order
if ColorInterp.red in ci and \
ColorInterp.green in ci and \
ColorInterp.blue in ci:
indexes = (
ci.index(ColorInterp.red) + 1,
ci.index(ColorInterp.green) + 1,
ci.index(ColorInterp.blue) + 1,
)
else:
# Fallback to first three
indexes = (
1,
2,
3,
)
elif has_alpha:
indexes = non_alpha_indexes(src.dataset)
# Workaround for https://github.com/OpenDroneMap/WebODM/issues/894
if nodata is None and tile_type == 'orthophoto':
nodata = 0
resampling = "nearest"
padding = 0
if tile_type in ["dsm", "dtm"]:
resampling = "bilinear"
padding = 16
try:
with COGReader(url) as src:
if expr is not None:
if boundaries_cutline is not None:
tile = src.tile(
x,
y,
z,
expression=expr,
tilesize=tilesize,
nodata=nodata,
padding=padding,
resampling_method=resampling,
vrt_options={'cutline': boundaries_cutline})
else:
tile = src.tile(x,
y,
z,
expression=expr,
tilesize=tilesize,
nodata=nodata,
padding=padding,
resampling_method=resampling)
else:
if boundaries_cutline is not None:
tile = src.tile(
x,
y,
z,
tilesize=tilesize,
nodata=nodata,
padding=padding,
resampling_method=resampling,
vrt_options={'cutline': boundaries_cutline})
else:
tile = src.tile(x,
y,
z,
indexes=indexes,
tilesize=tilesize,
nodata=nodata,
padding=padding,
resampling_method=resampling)
except TileOutsideBounds:
raise exceptions.NotFound(_("Outside of bounds"))
if color_map:
try:
colormap.get(color_map)
except InvalidColorMapName:
raise exceptions.ValidationError(
_("Not a valid color_map value"))
intensity = None
try:
rescale_arr = list(map(float, rescale.split(",")))
except ValueError:
raise exceptions.ValidationError(_("Invalid rescale value"))
options = img_profiles.get(driver, {})
if hillshade is not None:
try:
hillshade = float(hillshade)
if hillshade <= 0:
hillshade = 1.0
except ValueError:
raise exceptions.ValidationError(_("Invalid hillshade value"))
if tile.data.shape[0] != 1:
raise exceptions.ValidationError(
_("Cannot compute hillshade of non-elevation raster (multiple bands found)"
))
delta_scale = (maxzoom + ZOOM_EXTRA_LEVELS + 1 - z) * 4
dx = src.dataset.meta["transform"][0] * delta_scale
dy = -src.dataset.meta["transform"][4] * delta_scale
ls = LightSource(azdeg=315, altdeg=45)
# Hillshading is not a local tile operation and
# requires neighbor tiles to be rendered seamlessly
elevation = get_elevation_tiles(tile.data[0], url, x, y, z,
tilesize, nodata, resampling,
padding)
intensity = ls.hillshade(elevation,
dx=dx,
dy=dy,
vert_exag=hillshade)
intensity = intensity[tilesize:tilesize * 2, tilesize:tilesize * 2]
if intensity is not None:
rgb = tile.post_process(in_range=(rescale_arr, ))
if colormap:
rgb, _discard_ = apply_cmap(rgb.data, colormap.get(color_map))
if rgb.data.shape[0] != 3:
raise exceptions.ValidationError(
_("Cannot process tile: intensity image provided, but no RGB data was computed."
))
intensity = intensity * 255.0
rgb = hsv_blend(rgb, intensity)
if rgb is not None:
return HttpResponse(render(rgb,
tile.mask,
img_format=driver,
**options),
content_type="image/{}".format(ext))
if color_map is not None:
return HttpResponse(
tile.post_process(in_range=(rescale_arr, )).render(
img_format=driver,
colormap=colormap.get(color_map),
**options),
content_type="image/{}".format(ext))
return HttpResponse(tile.post_process(in_range=(rescale_arr, )).render(
img_format=driver, **options),
content_type="image/{}".format(ext))
def export_raster(input, output, **opts):
epsg = opts.get('epsg')
expression = opts.get('expression')
export_format = opts.get('format')
rescale = opts.get('rescale')
color_map = opts.get('color_map')
hillshade = opts.get('hillshade')
asset_type = opts.get('asset_type')
name = opts.get('name', 'raster') # KMZ specific
dem = asset_type in ['dsm', 'dtm']
with COGReader(input) as ds_src:
src = ds_src.dataset
profile = src.meta.copy()
# Output format
driver = "GTiff"
compress = None
max_bands = 9999
with_alpha = True
rgb = False
indexes = src.indexes
output_raster = output
jpg_background = 255 # white
# KMZ is special, we just export it as jpg with EPSG:4326
# and then call GDAL to tile/package it
kmz = export_format == "kmz"
if kmz:
export_format = "jpg"
epsg = 4326
path_base, _ = os.path.splitext(output)
output_raster = path_base + ".jpg"
jpg_background = 0 # black
if export_format == "jpg":
driver = "JPEG"
profile.update(quality=90)
band_count = 3
with_alpha = False
rgb = True
elif export_format == "png":
driver = "PNG"
band_count = 4
rgb = True
elif export_format == "gtiff-rgb":
compress = "JPEG"
profile.update(jpeg_quality=90)
band_count = 4
rgb = True
else:
compress = "DEFLATE"
band_count = src.count
if compress is not None:
profile.update(compress=compress)
profile.update(predictor=2 if compress == "DEFLATE" else 1)
if rgb and rescale is None:
# Compute min max
nodata = None
if asset_type == 'orthophoto':
nodata = 0
md = ds_src.metadata(pmin=2.0, pmax=98.0, hist_options={"bins": 255}, nodata=nodata)
rescale = [md['statistics']['1']['min'], md['statistics']['1']['max']]
ci = src.colorinterp
if rgb and expression is None:
# More than 4 bands?
if len(ci) > 4:
# Try to find RGBA band order
if ColorInterp.red in ci and \
ColorInterp.green in ci and \
ColorInterp.blue in ci and \
ColorInterp.alpha in ci:
indexes = (ci.index(ColorInterp.red) + 1,
ci.index(ColorInterp.green) + 1,
ci.index(ColorInterp.blue) + 1,
ci.index(ColorInterp.alpha) + 1)
if ColorInterp.alpha in ci:
mask = src.read(ci.index(ColorInterp.alpha) + 1)
else:
mask = src.dataset_mask()
cmap = None
if color_map:
try:
cmap = colormap.get(color_map)
except InvalidColorMapName:
logger.warning("Invalid colormap {}".format(color_map))
def process(arr, skip_rescale=False, skip_alpha=False, skip_type=False):
if not skip_rescale and rescale is not None:
arr = linear_rescale(arr, in_range=rescale)
if not skip_alpha and not with_alpha:
arr[mask==0] = jpg_background
if not skip_type and rgb and arr.dtype != np.uint8:
arr = arr.astype(np.uint8)
return arr
def update_rgb_colorinterp(dst):
if with_alpha:
dst.colorinterp = [ColorInterp.red, ColorInterp.green, ColorInterp.blue, ColorInterp.alpha]
else:
dst.colorinterp = [ColorInterp.red, ColorInterp.green, ColorInterp.blue]
profile.update(driver=driver, count=band_count)
if rgb:
profile.update(dtype=rasterio.uint8)
if dem and rgb and profile.get('nodata') is not None:
profile.update(nodata=None)
# Define write band function
# Reprojection needed?
if src.crs is not None and epsg is not None and src.crs.to_epsg() != epsg:
dst_crs = "EPSG:{}".format(epsg)
transform, width, height = calculate_default_transform(
src.crs, dst_crs, src.width, src.height, *src.bounds)
profile.update(
crs=dst_crs,
transform=transform,
width=width,
height=height
)
def write_band(arr, dst, band_num):
reproject(source=arr,
destination=rasterio.band(dst, band_num),
src_transform=src.transform,
src_crs=src.crs,
dst_transform=transform,
dst_crs=dst_crs,
resampling=Resampling.nearest)
else:
# No reprojection needed
def write_band(arr, dst, band_num):
dst.write(arr, band_num)
if expression is not None:
# Apply band math
if rgb:
profile.update(dtype=rasterio.uint8, count=band_count)
else:
profile.update(dtype=rasterio.float32, count=1, nodata=-9999)
bands_names = ["b{}".format(b) for b in tuple(sorted(set(re.findall(r"b(?P<bands>[0-9]{1,2})", expression))))]
rgb_expr = expression.split(",")
indexes = tuple([int(b.replace("b", "")) for b in bands_names])
alpha_index = None
if has_alpha_band(src):
try:
alpha_index = src.colorinterp.index(ColorInterp.alpha) + 1
indexes += (alpha_index, )
except ValueError:
pass
data = src.read(indexes=indexes, out_dtype=np.float32)
arr = dict(zip(bands_names, data))
arr = np.array([np.nan_to_num(ne.evaluate(bloc.strip(), local_dict=arr)) for bloc in rgb_expr])
# Set nodata values
index_band = arr[0]
if alpha_index is not None:
# -1 is the last band = alpha
index_band[data[-1] == 0] = -9999
# Remove infinity values
index_band[index_band>1e+30] = -9999
index_band[index_band<-1e+30] = -9999
# Make sure this is float32
arr = arr.astype(np.float32)
with rasterio.open(output_raster, 'w', **profile) as dst:
# Apply colormap?
if rgb and cmap is not None:
rgb_data, _ = apply_cmap(process(arr, skip_alpha=True), cmap)
band_num = 1
for b in rgb_data:
write_band(process(b, skip_rescale=True), dst, band_num)
band_num += 1
if with_alpha:
write_band(mask, dst, band_num)
update_rgb_colorinterp(dst)
else:
# Raw
write_band(process(arr)[0], dst, 1)
elif dem:
# Apply hillshading, colormaps to elevation
with rasterio.open(output_raster, 'w', **profile) as dst:
arr = src.read()
intensity = None
if hillshade is not None and hillshade > 0:
delta_scale = (ZOOM_EXTRA_LEVELS + 1) * 4
dx = src.meta["transform"][0] * delta_scale
dy = -src.meta["transform"][4] * delta_scale
ls = LightSource(azdeg=315, altdeg=45)
intensity = ls.hillshade(arr[0], dx=dx, dy=dy, vert_exag=hillshade)
intensity = intensity * 255.0
# Apply colormap?
if rgb and cmap is not None:
rgb_data, _ = apply_cmap(process(arr, skip_alpha=True), cmap)
if intensity is not None:
rgb_data = hsv_blend(rgb_data, intensity)
band_num = 1
for b in rgb_data:
write_band(process(b, skip_rescale=True), dst, band_num)
band_num += 1
if with_alpha:
write_band(mask, dst, band_num)
update_rgb_colorinterp(dst)
else:
# Raw
write_band(process(arr)[0], dst, 1)
else:
# Copy bands as-is
with rasterio.open(output_raster, 'w', **profile) as dst:
band_num = 1
for idx in indexes:
ci = src.colorinterp[idx - 1]
arr = src.read(idx)
if ci == ColorInterp.alpha:
if with_alpha:
write_band(arr, dst, band_num)
band_num += 1
else:
write_band(process(arr), dst, band_num)
band_num += 1
new_ci = [src.colorinterp[idx - 1] for idx in indexes]
if not with_alpha:
new_ci = [ci for ci in new_ci if ci != ColorInterp.alpha]
dst.colorinterp = new_ci
if kmz:
subprocess.check_output(["gdal_translate", "-of", "KMLSUPEROVERLAY",
"-co", "Name={}".format(name),
"-co", "FORMAT=JPEG", output_raster, output])
def render(
tile: numpy.ndarray,
mask: Optional[numpy.ndarray] = None,
img_format: str = "PNG",
colormap: Optional[Dict] = None,
**creation_options: Any,
) -> bytes:
"""
Translate numpy ndarray to image buffer using GDAL.
Usage
-----
tile, mask = rio_tiler.utils.tile_read(......)
with open('test.jpg', 'wb') as f:
f.write(render(tile, mask, img_format="jpeg"))
Attributes
----------
tile : numpy ndarray
Image array to encode.
mask: numpy ndarray, optional
Mask array
img_format: str, optional
Image format to return (default: 'png').
List of supported format by GDAL: https://www.gdal.org/formats_list.html
colormap: dict, optional
GDAL RGBA Color Table dictionary.
creation_options: dict, optional
Image driver creation options to pass to GDAL
Returns
-------
bytes: BytesIO
Reurn image body.
"""
img_format = img_format.upper()
if len(tile.shape) < 3:
tile = numpy.expand_dims(tile, axis=0)
if colormap:
tile, alpha = apply_cmap(tile, colormap)
if mask is not None:
mask = (
mask * alpha * 255
) # This is a special case when we want to mask some valid data
# WEBP doesn't support 1band dataset so we must hack to create a RGB dataset
if img_format == "WEBP" and tile.shape[0] == 1:
tile = numpy.repeat(tile, 3, axis=0)
elif img_format == "JPEG":
mask = None
count, height, width = tile.shape
output_profile = dict(
driver=img_format,
dtype=tile.dtype,
count=count + 1 if mask is not None else count,
height=height,
width=width,
)
output_profile.update(creation_options)
with MemoryFile() as memfile:
with memfile.open(**output_profile) as dst:
dst.write(tile, indexes=list(range(1, count + 1)))
# Use Mask as an alpha band
if mask is not None:
dst.write(mask.astype(tile.dtype), indexes=count + 1)
return memfile.read()