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()