def raster_to_disk( raster: Union[List[Union[str, gdal.Dataset]], str, gdal.Dataset], out_path: Union[List[str], str], overwrite: bool = True, creation_options: Union[list, None] = None, ) -> Union[List[str], str]: """Saves or copies a raster to disk. Can be used to change datatype. Input is either a filepath to a raster or a GDAL.Dataset. The driver is infered from the file extension. Args: raster (path | Dataset): The raster to save to disk. out_path (path): The destination to save to. **kwargs: overwrite (bool): If the file exists, should it be overwritten? creation_options (list): GDAL creation options. Defaults are: "TILED=YES" "NUM_THREADS=ALL_CPUS" "BIGG_TIF=YES" "COMPRESS=LZW" opened (bool): Should the resulting raster be opened or a path. Returns: The filepath for the newly created raster. """ type_check(raster, [list, str, gdal.Dataset], "raster") type_check(out_path, [list, str], "out_path") type_check(overwrite, [bool], "overwrite") type_check(creation_options, [list], "creation_options", allow_none=True) if creation_options is None: creation_options = [] if not os.path.dirname(os.path.abspath(out_path)): raise ValueError( f"Output folder does not exist. Please create first. {out_path}") raster_list, path_list = ready_io_raster(raster, out_path, overwrite) output: List[str] = [] for index, in_raster in enumerate(raster_list): path = _raster_to_disk( in_raster, path_list[index], overwrite=overwrite, creation_options=default_options(creation_options), ) output.append(path) if isinstance(raster, list): return output return output[0]
def raster_set_datatype( raster: Union[List[Union[str, gdal.Dataset]], str, gdal.Dataset], dtype: str, out_path: Optional[Union[List[str], str]], overwrite: bool = True, creation_options: Union[list, None] = None, ) -> Union[List[str], str]: """Changes the datatype of a raster. Args: raster (path | Dataset): The raster(s) to convert. dtype (str): The destination datatype: Can be float32, uint8 etc.. **kwargs: out_path (str | None): The destination of the output. If none, a memory raster with a random name is generated. creation_options (list): A list of options for the GDAL creation. Only used if an outpath is specified. Defaults are: "TILED=YES" "NUM_THREADS=ALL_CPUS" "BIGG_TIF=YES" "COMPRESS=LZW" Returns: A path to the newly created raster. """ type_check(raster, [list, str, gdal.Dataset], "raster") type_check(dtype, [str], "dtype") type_check(out_path, [list, str], "out_path", allow_none=True) type_check(creation_options, [list], "creation_options", allow_none=True) raster_list, path_list = ready_io_raster(raster, out_path, overwrite) output = [] for index, in_raster in enumerate(raster_list): path = _raster_set_datatype( in_raster, dtype, out_path=path_list[index], overwrite=overwrite, creation_options=default_options(creation_options), ) output.append(path) if isinstance(raster, list): return output return output[0]
def _raster_set_datatype( raster: Union[str, gdal.Dataset], dtype: str, out_path: Optional[str], overwrite: bool = True, creation_options: Union[list, None] = None, ) -> str: """OBS: INTERNAL: Single output. Changes the datatype of a raster. """ type_check(raster, [str, gdal.Dataset], "raster") type_check(dtype, [str], "dtype") type_check(out_path, [list, str], "out_path", allow_none=True) type_check(creation_options, [list], "creation_options", allow_none=True) ref = open_raster(raster) metadata = raster_to_metadata(ref) path = out_path if path is None: name = metadata["name"] path = f"/vsimem/{name}_{uuid4().int}.tif" driver = gdal.GetDriverByName(path_to_driver_raster(path)) remove_if_overwrite(path, overwrite) copy = driver.Create( path, metadata["height"], metadata["width"], metadata["band_count"], translate_datatypes(dtype), default_options(creation_options), ) copy.SetProjection(metadata["projection"]) copy.SetGeoTransform(metadata["transform"]) array = raster_to_array(ref) for band_idx in range(metadata["band_count"]): band = copy.GetRasterBand(band_idx + 1) band.WriteArray(array[:, :, band_idx]) band.SetNoDataValue(metadata["nodata_value"]) return path
def add_border_to_raster( input_raster, out_path=None, border_size=100, border_size_unit="px", border_value=0, overwrite: bool = True, creation_options: list = [], ): in_raster = open_raster(input_raster) metadata = raster_to_metadata(in_raster) # Parse the driver driver_name = "GTiff" if out_path is None else path_to_driver_raster( out_path) if driver_name is None: raise ValueError(f"Unable to parse filetype from path: {out_path}") driver = gdal.GetDriverByName(driver_name) if driver is None: raise ValueError( f"Error while creating driver from extension: {out_path}") output_name = None if out_path is None: output_name = f"/vsimem/raster_proximity_{uuid4().int}.tif" else: output_name = out_path in_arr = raster_to_array(in_raster) if border_size_unit == "px": border_size_y = border_size border_size_x = border_size new_shape = ( in_arr.shape[0] + (2 * border_size_y), in_arr.shape[1] + (2 * border_size_x), in_arr.shape[2], ) else: border_size_y = round(border_size / metadata["pixel_height"]) border_size_x = round(border_size / metadata["pixel_width"]) new_shape = ( in_arr.shape[0] + (2 * border_size_y), in_arr.shape[1] + (2 * border_size_x), in_arr.shape[2], ) new_arr = np.full(new_shape, border_value, dtype=in_arr.dtype) new_arr[border_size_y:-border_size_y, border_size_x:-border_size_x, :] = in_arr if isinstance(in_arr, np.ma.MaskedArray): mask = np.zeros(new_shape, dtype=bool) mask[border_size_y:-border_size_y, border_size_x:-border_size_x, :] = in_arr.mask new_arr = np.ma.array(new_arr, mask=mask) new_arr.fill_value = in_arr.fill_value remove_if_overwrite(out_path, overwrite) dest_raster = driver.Create( output_name, new_shape[1], new_shape[0], metadata["band_count"], numpy_to_gdal_datatype(in_arr.dtype), default_options(creation_options), ) og_transform = in_raster.GetGeoTransform() new_transform = [] for i in og_transform: new_transform.append(i) new_transform[0] -= border_size_x * og_transform[1] new_transform[3] -= border_size_y * og_transform[5] dest_raster.SetGeoTransform(new_transform) dest_raster.SetProjection(in_raster.GetProjectionRef()) for band_num in range(1, metadata["band_count"] + 1): dst_band = dest_raster.GetRasterBand(band_num) dst_band.WriteArray(new_arr[:, :, band_num - 1]) if metadata["has_nodata"]: dst_band.SetNoDataValue(metadata["nodata_value"]) return output_name
def internal_reproject_raster( raster: Union[str, gdal.Dataset], projection: Union[int, str, gdal.Dataset, ogr.DataSource, osr.SpatialReference], out_path: Optional[str] = None, resample_alg: str = "nearest", copy_if_already_correct: bool = True, overwrite: bool = True, creation_options: list = [], dst_nodata: Union[str, int, float] = "infer", prefix: str = "", postfix: str = "_reprojected", ) -> str: """OBS: Internal. Single output. Reproject a raster(s) to a target coordinate reference system. """ type_check(raster, [str, gdal.Dataset], "raster") type_check( projection, [int, str, gdal.Dataset, ogr.DataSource, osr.SpatialReference], "projection", ) type_check(out_path, [str], "out_path", allow_none=True) type_check(resample_alg, [str], "resample_alg") type_check(copy_if_already_correct, [bool], "copy_if_already_correct") type_check(overwrite, [bool], "overwrite") type_check(creation_options, [list], "creation_options") type_check(dst_nodata, [str, int, float], "dst_nodata") type_check(prefix, [str], "prefix") type_check(postfix, [str], "postfix") raster_list, path_list = ready_io_raster(raster, out_path, overwrite, prefix, postfix) out_name = path_list[0] ref = open_raster(raster_list[0]) metadata = raster_to_metadata(ref) out_creation_options = default_options(creation_options) out_format = path_to_driver_raster(out_name) original_projection = parse_projection(ref) target_projection = parse_projection(projection) if not isinstance(original_projection, osr.SpatialReference): raise Exception("Error while parsing input projection.") if not isinstance(target_projection, osr.SpatialReference): raise Exception("Error while parsing target projection.") if original_projection.IsSame(target_projection): if not copy_if_already_correct: return get_raster_path(ref) src_nodata = metadata["nodata_value"] out_nodata = None if src_nodata is not None: out_nodata = src_nodata else: if dst_nodata == "infer": out_nodata = gdal_nodata_value_from_type( metadata["datatype_gdal_raw"]) elif isinstance(dst_nodata, str): raise TypeError(f"dst_nodata is in a wrong format: {dst_nodata}") else: out_nodata = dst_nodata remove_if_overwrite(out_path, overwrite) reprojected = gdal.Warp( out_name, ref, format=out_format, srcSRS=original_projection, dstSRS=target_projection, resampleAlg=translate_resample_method(resample_alg), creationOptions=out_creation_options, srcNodata=metadata["nodata_value"], dstNodata=out_nodata, multithread=True, ) if reprojected is None: raise Exception(f"Error while reprojecting raster: {raster}") return out_name
def _warp_raster( raster: Union[str, gdal.Dataset], out_path: Optional[str] = None, projection: Optional[Union[int, str, gdal.Dataset, ogr.DataSource, osr.SpatialReference]] = None, clip_geom: Optional[Union[str, ogr.DataSource]] = None, target_size: Optional[Union[Tuple[Number], Number]] = None, target_in_pixels: bool = False, resample_alg: str = "nearest", crop_to_geom: bool = True, all_touch: bool = True, adjust_bbox: bool = True, overwrite: bool = True, creation_options: Union[list, None] = None, src_nodata: Union[str, int, float] = "infer", dst_nodata: Union[str, int, float] = "infer", layer_to_clip: int = 0, prefix: str = "", postfix: str = "_resampled", ) -> str: """WARNING: INTERNAL. DO NOT USE.""" raster_list, path_list = ready_io_raster(raster, out_path, overwrite, prefix, postfix) origin = open_raster(raster_list[0]) out_name = path_list[0] raster_metadata = raster_to_metadata(origin, create_geometry=True) # options warp_options = [] if all_touch: warp_options.append("CUTLINE_ALL_TOUCHED=TRUE") else: warp_options.append("CUTLINE_ALL_TOUCHED=FALSE") origin_projection: osr.SpatialReference = raster_metadata["projection_osr"] origin_extent: ogr.Geometry = raster_metadata["extent_geom_latlng"] target_projection = origin_projection if projection is not None: target_projection = parse_projection(projection) if clip_geom is not None: if is_raster(clip_geom): opened_raster = open_raster(clip_geom) clip_metadata_raster = raster_to_metadata(opened_raster, create_geometry=True) clip_ds = clip_metadata_raster["extent_datasource"] clip_metadata = internal_vector_to_metadata(clip_ds, create_geometry=True) elif is_vector(clip_geom): clip_ds = open_vector(clip_geom) clip_metadata = internal_vector_to_metadata(clip_ds, create_geometry=True) else: if file_exists(clip_geom): raise ValueError(f"Unable to parse clip geometry: {clip_geom}") else: raise ValueError(f"Unable to find clip geometry {clip_geom}") if layer_to_clip > (clip_metadata["layer_count"] - 1): raise ValueError("Requested an unable layer_to_clip.") clip_projection = clip_metadata["projection_osr"] clip_extent = clip_metadata["extent_geom_latlng"] # Fast check: Does the extent of the two inputs overlap? if not origin_extent.Intersects(clip_extent): raise Exception("Clipping geometry did not intersect raster.") # Check if projections match, otherwise reproject target geom. if not target_projection.IsSame(clip_projection): clip_metadata["extent"] = reproject_extent( clip_metadata["extent"], clip_projection, target_projection, ) # The extent needs to be reprojected to the target. # this ensures that adjust_bbox works. x_min_og, y_max_og, x_max_og, y_min_og = reproject_extent( raster_metadata["extent"], origin_projection, target_projection, ) output_bounds = (x_min_og, y_min_og, x_max_og, y_max_og ) # gdal_warp format if crop_to_geom: if adjust_bbox: output_bounds = align_bbox( raster_metadata["extent"], clip_metadata["extent"], raster_metadata["pixel_width"], raster_metadata["pixel_height"], warp_format=True, ) else: x_min_og, y_max_og, x_max_og, y_min_og = clip_metadata[ "extent"] output_bounds = ( x_min_og, y_min_og, x_max_og, y_max_og, ) # gdal_warp format if clip_metadata["layer_count"] > 1: clip_ds = vector_to_memory( clip_ds, memory_path=f"clip_geom_{uuid4().int}.gpkg", layer_to_extract=layer_to_clip, ) elif not isinstance(clip_ds, str): clip_ds = vector_to_memory( clip_ds, memory_path=f"clip_geom_{uuid4().int}.gpkg", ) if clip_ds is None: raise ValueError(f"Unable to parse input clip geom: {clip_geom}") x_res, y_res, x_pixels, y_pixels = raster_size_from_list( target_size, target_in_pixels) out_format = path_to_driver_raster(out_name) out_creation_options = default_options(creation_options) # nodata out_nodata = None if src_nodata is not None: out_nodata = raster_metadata["nodata_value"] else: if dst_nodata == "infer": out_nodata = gdal_nodata_value_from_type( raster_metadata["datatype_gdal_raw"]) else: out_nodata = dst_nodata # Removes file if it exists and overwrite is True. remove_if_overwrite(out_path, overwrite) warped = gdal.Warp( out_name, origin, xRes=x_res, yRes=y_res, width=x_pixels, height=y_pixels, cutlineDSName=clip_ds, outputBounds=output_bounds, format=out_format, srcSRS=origin_projection, dstSRS=target_projection, resampleAlg=translate_resample_method(resample_alg), creationOptions=out_creation_options, warpOptions=warp_options, srcNodata=src_nodata, dstNodata=out_nodata, targetAlignedPixels=False, cropToCutline=False, multithread=True, ) if warped is None: raise Exception(f"Error while warping raster: {raster}") return out_name
def internal_resample_raster( raster: Union[str, gdal.Dataset], target_size: Union[tuple, int, float, str, gdal.Dataset], target_in_pixels: bool = False, out_path: Optional[str] = None, resample_alg: str = "nearest", overwrite: bool = True, creation_options: list = [], dtype=None, dst_nodata: Union[str, int, float] = "infer", prefix: str = "", postfix: str = "_resampled", add_uuid: bool = False, ) -> str: """OBS: Internal. Single output. Reprojects a raster given a target projection. Beware if your input is in latitude and longitude, you'll need to specify the target_size in degrees as well. """ type_check(raster, [str, gdal.Dataset], "raster") type_check(target_size, [tuple, int, float, str, gdal.Dataset], "target_size") type_check(target_in_pixels, [bool], "target_in_pixels") type_check(out_path, [list, str], "out_path", allow_none=True) type_check(resample_alg, [str], "resample_alg") type_check(overwrite, [bool], "overwrite") type_check(creation_options, [list], "creation_options") type_check(dst_nodata, [str, int, float], "dst_nodata") type_check(prefix, [str], "prefix") type_check(postfix, [str], "postfix") raster_list, path_list = ready_io_raster( raster, out_path, overwrite=overwrite, prefix=prefix, postfix=postfix, uuid=add_uuid, ) ref = open_raster(raster_list[0]) metadata = raster_to_metadata(ref) out_name = path_list[0] x_res, y_res, x_pixels, y_pixels = raster_size_from_list( target_size, target_in_pixels) out_creation_options = default_options(creation_options) out_format = path_to_driver_raster(out_name) src_nodata = metadata["nodata_value"] out_nodata = None if src_nodata is not None: out_nodata = src_nodata else: if dst_nodata == "infer": out_nodata = gdal_nodata_value_from_type( metadata["datatype_gdal_raw"]) elif isinstance(dst_nodata, str): raise TypeError(f"dst_nodata is in a wrong format: {dst_nodata}") else: out_nodata = dst_nodata remove_if_overwrite(out_path, overwrite) resampled = gdal.Warp( out_name, ref, width=x_pixels, height=y_pixels, xRes=x_res, yRes=y_res, format=out_format, outputType=translate_datatypes(dtype), resampleAlg=translate_resample_method(resample_alg), creationOptions=out_creation_options, srcNodata=metadata["nodata_value"], dstNodata=out_nodata, multithread=True, ) if resampled is None: raise Exception(f"Error while resampling raster: {out_name}") return out_name
def array_to_raster( array: Union[np.ndarray, np.ma.MaskedArray], reference: Union[str, gdal.Dataset], out_path: Optional[str] = None, overwrite: bool = True, creation_options: Union[list, None] = None, ) -> str: """Turns a numpy array into a GDAL dataset or exported as a raster using a reference raster. Args: array (np.ndarray): The numpy array to convert reference (path or Dataset): A reference on which to base the geographical extent and projection of the raster. **kwargs: out_path (path): The location to save the raster. If None is supplied an in memory raster is returned. filetype is infered from the extension. overwrite (bool): Specifies if the file already exists, should it be overwritten? creation_options (list): A list of options for the GDAL creation. Only used if an outpath is specified. Defaults are: "TILED=YES" "NUM_THREADS=ALL_CPUS" "BIGG_TIF=YES" "COMPRESS=LZW" Returns: If an out_path has been specified, it returns the path to the newly created raster file. """ type_check(array, [np.ndarray, np.ma.MaskedArray], "array") type_check(reference, [str, gdal.Dataset], "reference") type_check(out_path, [str], "out_path", allow_none=True) type_check(overwrite, [bool], "overwrite") type_check(creation_options, [list], "creation_options", allow_none=True) # Verify the numpy array if (not isinstance(array, (np.ndarray, np.ma.MaskedArray)) or array.size == 0 or array.ndim < 2 or array.ndim > 3): raise ValueError(f"Input array is invalid {array}") # Parse the driver driver_name = "GTiff" if out_path is None else path_to_driver_raster( out_path) if driver_name is None: raise ValueError(f"Unable to parse filetype from path: {out_path}") driver = gdal.GetDriverByName(driver_name) if driver is None: raise ValueError( f"Error while creating driver from extension: {out_path}") # How many bands? bands = 1 if array.ndim == 3: bands = array.shape[2] overwrite_required(out_path, overwrite) metadata = raster_to_metadata(reference) reference_nodata = metadata["nodata_value"] # handle nodata. GDAL python throws error if conversion in not explicit. if reference_nodata is not None: reference_nodata = float(reference_nodata) if (reference_nodata).is_integer() is True: reference_nodata = int(reference_nodata) # Handle nodata input_nodata = None if np.ma.is_masked(array) is True: input_nodata = array.get_fill_value( ) # type: ignore (because it's a masked array.) destination_dtype = numpy_to_gdal_datatype(array.dtype) # Weird double issue with GDAL and numpy. Cast to float or int if input_nodata is not None: input_nodata = float(input_nodata) if (input_nodata).is_integer() is True: input_nodata = int(input_nodata) output_name = None if out_path is None: output_name = f"/vsimem/array_to_raster_{uuid4().int}.tif" else: output_name = out_path if metadata["width"] != array.shape[1] or metadata[ "height"] != array.shape[0]: print("WARNING: Input array and raster are not of equal size.") remove_if_overwrite(out_path, overwrite) destination = driver.Create( output_name, array.shape[1], array.shape[0], bands, destination_dtype, default_options(creation_options), ) destination.SetProjection(metadata["projection"]) destination.SetGeoTransform(metadata["transform"]) for band_idx in range(bands): band = destination.GetRasterBand(band_idx + 1) if bands > 1 or array.ndim == 3: band.WriteArray(array[:, :, band_idx]) else: band.WriteArray(array) if input_nodata is not None: band.SetNoDataValue(input_nodata) elif reference_nodata is not None: band.SetNoDataValue(reference_nodata) return output_name
def stack_rasters( rasters: List[Union[str, gdal.Dataset]], out_path: Optional[str] = None, overwrite: bool = True, dtype: Optional[str] = None, creation_options: Union[list, None] = None, ) -> str: """Stacks a list of rasters. Must be aligned.""" type_check(rasters, [list], "rasters") type_check(out_path, [str], "out_path", allow_none=True) type_check(overwrite, [bool], "overwrite") type_check(dtype, [str], "dtype", allow_none=True) type_check(creation_options, [list], "creation_options", allow_none=True) if not rasters_are_aligned(rasters, same_extent=True): raise ValueError("Rasters are not aligned. Try running align_rasters.") overwrite_required(out_path, overwrite) # Ensures that all the input rasters are valid. raster_list = get_raster_path(rasters, return_list=True) if out_path is not None and path_to_ext(out_path) == ".vrt": raise ValueError("Please use stack_rasters_vrt to create vrt files.") # Parse the driver driver_name = "GTiff" if out_path is None else path_to_driver_raster( out_path) if driver_name is None: raise ValueError(f"Unable to parse filetype from path: {out_path}") driver = gdal.GetDriverByName(driver_name) if driver is None: raise ValueError( f"Error while creating driver from extension: {out_path}") output_name = None if out_path is None: output_name = f"/vsimem/stacked_rasters_{uuid4().int}.tif" else: output_name = out_path raster_dtype = raster_to_metadata(raster_list[0])["datatype_gdal_raw"] datatype = translate_datatypes( dtype) if dtype is not None else raster_dtype nodata_values: List[Union[int, float, None]] = [] nodata_missmatch = False nodata_value = None total_bands = 0 metadatas = [] for raster in raster_list: metadata = raster_to_metadata(raster) metadatas.append(metadata) nodata_value = metadata["nodata_value"] total_bands += metadata["band_count"] if nodata_missmatch is False: for ndv in nodata_values: if nodata_missmatch: continue if metadata["nodata_value"] != ndv: print( "WARNING: NoDataValues of input rasters do not match. Removing nodata." ) nodata_missmatch = True nodata_values.append(metadata["nodata_value"]) if nodata_missmatch: nodata_value = None remove_if_overwrite(out_path, overwrite) destination = driver.Create( output_name, metadatas[0]["width"], metadatas[0]["height"], total_bands, datatype, default_options(creation_options), ) destination.SetProjection(metadatas[0]["projection"]) destination.SetGeoTransform(metadatas[0]["transform"]) bands_added = 0 for index, raster in enumerate(raster_list): metadata = metadatas[index] band_count = metadata["band_count"] array = raster_to_array(raster) for band_idx in range(band_count): dst_band = destination.GetRasterBand(bands_added + 1) dst_band.WriteArray(array[:, :, band_idx]) if nodata_value is not None: dst_band.SetNoDataValue(nodata_value) bands_added += 1 return output_name
def shift_raster( raster: Union[gdal.Dataset, str], shift: Union[Number, Tuple[Number, Number], List[Number]], out_path: Optional[str] = None, overwrite: bool = True, creation_options: list = [], ) -> Union[gdal.Dataset, str]: """Shifts a raster in a given direction. Returns: An in-memory raster. If an out_path is given the output is a string containing the path to the newly created raster. """ type_check(raster, [list, str, gdal.Dataset], "raster") type_check(shift, [tuple, list], "shift") type_check(out_path, [list, str], "out_path", allow_none=True) type_check(overwrite, [bool], "overwrite") type_check(creation_options, [list], "creation_options") ref = open_raster(raster) metadata = raster_to_metadata(ref) x_shift: float = 0.0 y_shift: float = 0.0 if isinstance(shift, tuple) or isinstance(shift, list): if len(shift) == 1: if is_number(shift[0]): x_shift = float(shift[0]) y_shift = float(shift[0]) else: raise ValueError( "shift is not a number or a list/tuple of numbers.") elif len(shift) == 2: if is_number(shift[0]) and is_number(shift[1]): x_shift = float(shift[0]) y_shift = float(shift[1]) else: raise ValueError("shift is either empty or larger than 2.") elif is_number(shift): x_shift = float(shift) y_shift = float(shift) else: raise ValueError("shift is invalid.") out_name = None out_format = None out_creation_options = [] if out_path is None: raster_name = metadata["basename"] out_name = f"/vsimem/{raster_name}_{uuid4().int}_resampled.tif" out_format = "GTiff" else: out_creation_options = default_options(creation_options) out_name = out_path out_format = path_to_driver_raster(out_path) remove_if_overwrite(out_path, overwrite) driver = gdal.GetDriverByName(out_format) shifted = driver.Create( out_name, # Location of the saved raster, ignored if driver is memory. metadata["width"], # Dataframe width in pixels (e.g. 1920px). metadata["height"], # Dataframe height in pixels (e.g. 1280px). metadata["band_count"], # The number of bands required. metadata["datatype_gdal_raw"], # Datatype of the destination. out_creation_options, ) new_transform = list(metadata["transform"]) new_transform[0] += x_shift new_transform[3] += y_shift shifted.SetGeoTransform(new_transform) shifted.SetProjection(metadata["projection"]) src_nodata = metadata["nodata_value"] for band in range(metadata["band_count"]): origin_raster_band = ref.GetRasterBand(band + 1) target_raster_band = shifted.GetRasterBand(band + 1) target_raster_band.WriteArray(origin_raster_band.ReadAsArray()) target_raster_band.SetNoDataValue(src_nodata) if out_path is not None: shifted = None return out_path else: return shifted
def align_rasters( rasters: List[Union[str, gdal.Dataset]], out_path: Optional[Union[List[str], str]] = None, master: Optional[Union[gdal.Dataset, str]] = None, postfix: str = "_aligned", bounding_box: Union[str, gdal.Dataset, ogr.DataSource, list, tuple] = "intersection", resample_alg: str = "nearest", target_size: Optional[Union[tuple, list, int, float, str, gdal.Dataset]] = None, target_in_pixels: bool = False, projection: Optional[Union[int, str, gdal.Dataset, ogr.DataSource, osr.SpatialReference]] = None, overwrite: bool = True, creation_options: list = [], src_nodata: Optional[Union[str, int, float]] = "infer", dst_nodata: Optional[Union[str, int, float]] = "infer", prefix: str = "", ram=8000, skip_existing=False, ) -> List[str]: type_check(rasters, [list], "rasters") type_check(out_path, [list, str], "out_path", allow_none=True) type_check(master, [list, str], "master", allow_none=True) type_check(bounding_box, [str, gdal.Dataset, ogr.DataSource, list, tuple], "bounding_box") type_check(resample_alg, [str], "resample_alg") type_check( target_size, [tuple, list, int, float, str, gdal.Dataset], "target_size", allow_none=True, ) type_check( target_in_pixels, [int, str, gdal.Dataset, ogr.DataSource, osr.SpatialReference], "target_in_pixels", allow_none=True, ) type_check(overwrite, [bool], "overwrite") type_check(creation_options, [list], "creation_options") type_check(src_nodata, [str, int, float], "src_nodata", allow_none=True) type_check(dst_nodata, [str, int, float], "dst_nodata", allow_none=True) type_check(prefix, [str], "prefix") type_check(postfix, [str], "postfix") raster_list, path_list = ready_io_raster( rasters, out_path, overwrite=overwrite, prefix=prefix, postfix=postfix, uuid=False, ) x_pixels = None y_pixels = None x_res = None y_res = None target_projection = None target_bounds = None reprojected_rasters: List[str] = [] # Read the metadata for each raster. # Catalogue the used projections, to choose the most common one if necessary. used_projections: List[dict] = [] metadata: List[str] = [] for raster in rasters: meta = raster_to_metadata(raster) metadata.append(meta) used_projections.append(meta["projection"]) # If there is a master layer, copy information from that layer. if master is not None: master_metadata = raster_to_metadata(master) target_projection = master_metadata["projection_osr"] x_min, y_max, x_max, y_min = master_metadata["extent"] # Set the target values. target_bounds = (x_min, y_min, x_max, y_max) x_res = master_metadata["pixel_width"] y_res = master_metadata["pixel_height"] x_pixels = master_metadata["width"] y_pixels = master_metadata["height"] target_size = (x_res, y_res) target_in_pixels = False # We allow overwrite of parameters specifically set. # Handle projection if projection is not None: target_projection = parse_projection(projection) # If no projection is specified, other from master or parameters. The most common one is chosen. elif target_projection is None: # Sort and count the projections projection_counter: dict = {} for proj in used_projections: if proj in projection_counter: projection_counter[proj] += 1 else: projection_counter[proj] = 1 # Choose most common projection most_common_projection = sorted(projection_counter, key=projection_counter.get, reverse=True) target_projection = parse_projection(most_common_projection[0]) if target_size is not None: # If a raster is input, use it's pixel size as target values. if isinstance(target_size, (gdal.Dataset, str)): if isinstance(target_size, str) and not is_raster(target_size): raise ValueError( f"Unable to parse the raster used for target_size: {target_size}" ) # Reprojection is necessary to ensure the correct pixel_size reprojected_target_size = internal_reproject_raster( target_size, target_projection) target_size_raster = raster_to_metadata(reprojected_target_size) # Set the target values. x_res = target_size_raster["width"] y_res = target_size_raster["height"] else: # If a list, tuple, int or float is passed. Turn them into target values. x_res, y_res, x_pixels, y_pixels = raster_size_from_list( target_size, target_in_pixels) # If nothing has been specified, we will infer the pixel_size based on the median of all input rasters. elif x_res is None and y_res is None and x_pixels is None and y_pixels is None: # Ready numpy arrays for insertion x_res_arr = np.empty(len(raster_list), dtype="float32") y_res_arr = np.empty(len(raster_list), dtype="float32") for index, raster in enumerate(raster_list): # It is necessary to reproject each raster, as pixel height and width might be different after projection. reprojected = internal_reproject_raster(raster, target_projection) target_size_raster = raster_to_metadata(reprojected) # Add the pixel sizes to the numpy arrays x_res_arr[index] = target_size_raster["pixel_width"] y_res_arr[index] = target_size_raster["pixel_height"] # Keep track of the reprojected arrays so we only reproject rasters once. reprojected_rasters.append(reprojected) # Use the median values of pixel sizes as target values. x_res = np.median(x_res_arr) y_res = np.median(y_res_arr) if target_bounds is None: # If a bounding box is supplied, simply use that one. It must be in the target projection. if isinstance(bounding_box, (list, tuple)): if len(bounding_box) != 4: raise ValueError( "bounding_box as a list/tuple must have 4 values.") target_bounds = bounding_box # If the bounding box is a raster. Take the extent and reproject it to the target projection. elif is_raster(bounding_box): reprojected_bbox_raster = raster_to_metadata( internal_reproject_raster(bounding_box, target_projection)) x_min, y_max, x_max, y_min = reprojected_bbox_raster["extent"] # add to target values. target_bounds = (x_min, y_min, x_max, y_max) # If the bounding box is a raster. Take the extent and reproject it to the target projection. elif is_vector(bounding_box): reprojected_bbox_vector = internal_vector_to_metadata( internal_reproject_vector(bounding_box, target_projection)) x_min, y_max, x_max, y_min = reprojected_bbox_vector["extent"] # add to target values. target_bounds = (x_min, y_min, x_max, y_max) # If the bounding box is a string, we either take the union or the intersection of all the # bounding boxes of the input rasters. elif isinstance(bounding_box, str): if bounding_box == "intersection" or bounding_box == "union": extents = [] # If the rasters have not been reprojected, reproject them now. if len(reprojected_rasters) != len(raster_list): reprojected_rasters = [] for raster in raster_list: raster_metadata = raster_to_metadata(raster) if raster_metadata["projection_osr"].IsSame( target_projection): reprojected_rasters.append(raster) else: reprojected = internal_reproject_raster( raster, target_projection) reprojected_rasters.append(reprojected) # Add the extents of the reprojected rasters to the extents list. for reprojected_raster in reprojected_rasters: reprojected_raster_metadata = dict( raster_to_metadata(reprojected_raster)) extents.append(reprojected_raster_metadata["extent"]) # Placeholder values x_min, y_max, x_max, y_min = extents[0] # Loop the extents. Narrowing if intersection, expanding if union. for index, extent in enumerate(extents): if index == 0: continue if bounding_box == "intersection": if extent[0] > x_min: x_min = extent[0] if extent[1] < y_max: y_max = extent[1] if extent[2] < x_max: x_max = extent[2] if extent[3] > y_min: y_min = extent[3] elif bounding_box == "union": if extent[0] < x_min: x_min = extent[0] if extent[1] > y_max: y_max = extent[1] if extent[2] > x_max: x_max = extent[2] if extent[3] < y_min: y_min = extent[3] # Add to target values. target_bounds = (x_min, y_min, x_max, y_max) else: raise ValueError( f"Unable to parse or infer target_bounds: {target_bounds}") else: raise ValueError( f"Unable to parse or infer target_bounds: {target_bounds}") """ If the rasters have not been reprojected, we reproject them now. The reprojection is necessary as warp has to be a two step process in order to align the rasters properly. This might not be necessary in a future version of gdal. """ if len(reprojected_rasters) != len(raster_list): reprojected_rasters = [] for raster in raster_list: raster_metadata = raster_to_metadata(raster) # If the raster is already the correct projection, simply append the raster. if raster_metadata["projection_osr"].IsSame(target_projection): reprojected_rasters.append(raster) else: reprojected = internal_reproject_raster( raster, target_projection) reprojected_rasters.append(reprojected) # If any of the target values are still undefined. Throw an error! if target_projection is None or target_bounds is None: raise Exception( "Error while preparing the target projection or bounds.") if x_res is None and y_res is None and x_pixels is None and y_pixels is None: raise Exception("Error while preparing the target pixel size.") # This is the list of rasters to return. If output is not memory, it's a list of paths. return_list: List[str] = [] for index, raster in enumerate(reprojected_rasters): raster_metadata = raster_to_metadata(raster) out_name = path_list[index] out_format = path_to_driver_raster(out_name) if skip_existing and os.path.exists(out_name): return_list.append(out_name) continue # Handle nodata. out_src_nodata = None out_dst_nodata = None if src_nodata == "infer": out_src_nodata = raster_metadata["nodata_value"] if out_src_nodata is None: out_src_nodata = gdal_nodata_value_from_type( raster_metadata["datatype_gdal_raw"]) elif src_nodata == None: out_src_nodata = None elif not isinstance(src_nodata, str): out_src_nodata = src_nodata if dst_nodata == "infer": out_dst_nodata = out_src_nodata elif dst_nodata == False or dst_nodata == None: out_dst_nodata = None elif src_nodata == None: out_dst_nodata = None elif not isinstance(dst_nodata, str): out_dst_nodata = dst_nodata # Removes file if it exists and overwrite is True. remove_if_overwrite(out_name, overwrite) # Hand over to gdal.Warp to do the heavy lifting! warped = gdal.Warp( out_name, raster, xRes=x_res, yRes=y_res, width=x_pixels, height=y_pixels, dstSRS=target_projection, outputBounds=target_bounds, format=out_format, resampleAlg=translate_resample_method(resample_alg), creationOptions=default_options(creation_options), srcNodata=out_src_nodata, dstNodata=out_dst_nodata, targetAlignedPixels=False, cropToCutline=False, multithread=True, warpMemoryLimit=ram, ) if warped == None: raise Exception("Error while warping rasters.") return_list.append(out_name) if not rasters_are_aligned(return_list, same_extent=True): raise Exception("Error while aligning rasters. Output is not aligned") return return_list
def _clip_raster( raster: Union[str, gdal.Dataset], clip_geom: Union[str, ogr.DataSource, gdal.Dataset], out_path: Optional[str] = None, resample_alg: str = "nearest", crop_to_geom: bool = True, adjust_bbox: bool = True, all_touch: bool = True, overwrite: bool = True, creation_options: list = [], dst_nodata: Union[str, int, float] = "infer", layer_to_clip: int = 0, prefix: str = "", postfix: str = "_clipped", verbose: int = 1, uuid: bool = False, ram: int = 8000, ) -> str: """OBS: Internal. Single output. Clips a raster(s) using a vector geometry or the extents of a raster. """ type_check(raster, [str, gdal.Dataset], "raster") type_check(clip_geom, [str, ogr.DataSource, gdal.Dataset], "clip_geom") type_check(out_path, [str], "out_path", allow_none=True) type_check(resample_alg, [str], "resample_alg") type_check(crop_to_geom, [bool], "crop_to_geom") type_check(adjust_bbox, [bool], "adjust_bbox") type_check(all_touch, [bool], "all_touch") type_check(dst_nodata, [str, int, float], "dst_nodata") type_check(layer_to_clip, [int], "layer_to_clip") type_check(overwrite, [bool], "overwrite") type_check(creation_options, [list], "creation_options") type_check(prefix, [str], "prefix") type_check(postfix, [str], "postfix") type_check(verbose, [int], "verbose") type_check(uuid, [bool], "uuid") _, path_list = ready_io_raster(raster, out_path, overwrite=overwrite, prefix=prefix, postfix=postfix, uuid=uuid) if out_path is not None: if "vsimem" not in out_path: if not os.path.isdir(os.path.split(os.path.normpath(out_path))[0]): raise ValueError( f"out_path folder does not exists: {out_path}") # Input is a vector. if is_vector(clip_geom): clip_ds = open_vector(clip_geom) clip_metadata = internal_vector_to_metadata( clip_ds, process_layer=layer_to_clip) if clip_metadata["layer_count"] > 1: clip_ds = internal_vector_to_memory(clip_ds, layer_to_extract=layer_to_clip) if isinstance(clip_ds, ogr.DataSource): clip_ds = clip_ds.GetName() # Input is a raster (use extent) elif is_raster(clip_geom): clip_metadata = raster_to_metadata(clip_geom, create_geometry=True) clip_metadata["layer_count"] = 1 clip_ds = clip_metadata["extent_datasource"].GetName() else: if file_exists(clip_geom): raise ValueError(f"Unable to parse clip geometry: {clip_geom}") else: raise ValueError(f"Unable to locate clip geometry {clip_geom}") if layer_to_clip > (clip_metadata["layer_count"] - 1): raise ValueError("Requested an unable layer_to_clip.") if clip_ds is None: raise ValueError(f"Unable to parse input clip geom: {clip_geom}") clip_projection = clip_metadata["projection_osr"] clip_extent = clip_metadata["extent"] # options warp_options = [] if all_touch: warp_options.append("CUTLINE_ALL_TOUCHED=TRUE") else: warp_options.append("CUTLINE_ALL_TOUCHED=FALSE") origin_layer = open_raster(raster) raster_metadata = raster_to_metadata(raster) origin_projection = raster_metadata["projection_osr"] origin_extent = raster_metadata["extent"] # Check if projections match, otherwise reproject target geom. if not origin_projection.IsSame(clip_projection): clip_metadata["extent"] = reproject_extent( clip_metadata["extent"], clip_projection, origin_projection, ) # Fast check: Does the extent of the two inputs overlap? if not gdal_bbox_intersects(origin_extent, clip_extent): raise Exception("Geometries did not intersect.") output_bounds = raster_metadata["extent_gdal_warp"] if crop_to_geom: if adjust_bbox: output_bounds = align_bbox( raster_metadata["extent"], clip_metadata["extent"], raster_metadata["pixel_width"], raster_metadata["pixel_height"], warp_format=True, ) else: output_bounds = clip_metadata["extent_gdal_warp"] # formats out_name = path_list[0] out_format = path_to_driver_raster(out_name) out_creation_options = default_options(creation_options) # nodata src_nodata = raster_metadata["nodata_value"] out_nodata = None if src_nodata is not None: out_nodata = src_nodata else: if dst_nodata == "infer": out_nodata = gdal_nodata_value_from_type( raster_metadata["datatype_gdal_raw"]) elif dst_nodata is None: out_nodata = None elif isinstance(dst_nodata, (int, float)): out_nodata = dst_nodata else: raise ValueError(f"Unable to parse nodata_value: {dst_nodata}") # Removes file if it exists and overwrite is True. remove_if_overwrite(out_path, overwrite) if verbose == 0: gdal.PushErrorHandler("CPLQuietErrorHandler") clipped = gdal.Warp( out_name, origin_layer, format=out_format, resampleAlg=translate_resample_method(resample_alg), targetAlignedPixels=False, outputBounds=output_bounds, xRes=raster_metadata["pixel_width"], yRes=raster_metadata["pixel_height"], cutlineDSName=clip_ds, cropToCutline= False, # GDAL does this incorrectly when targetAlignedPixels is True. creationOptions=out_creation_options, warpMemoryLimit=ram, warpOptions=warp_options, srcNodata=raster_metadata["nodata_value"], dstNodata=out_nodata, multithread=True, ) if verbose == 0: gdal.PopErrorHandler() if clipped is None: raise Exception("Error while clipping raster.") return out_name
def rasterize_vector( vector, pixel_size, out_path=None, extent=None, all_touch=False, dtype="uint8", optim="raster", band=1, fill_value=0, nodata_value=None, check_memory=True, burn_value=1, attribute=None, ): vector_fn = vector if out_path is None: raster_fn = f"/vsimem/{str(uuid4())}.tif" else: raster_fn = out_path # Open the data source and read in the extent source_ds = open_vector(vector_fn) source_meta = internal_vector_to_metadata(vector_fn) source_layer = source_ds.GetLayer() x_min, x_max, y_min, y_max = source_layer.GetExtent() # Create the destination data source x_res = int((x_max - x_min) / pixel_size) y_res = int((y_max - y_min) / pixel_size) if extent is not None: extent_vector = internal_vector_to_metadata(extent) extent_dict = extent_vector["extent_dict"] x_res = int((extent_dict["right"] - extent_dict["left"]) / pixel_size) y_res = int((extent_dict["top"] - extent_dict["bottom"]) / pixel_size) x_min = extent_dict["left"] y_max = extent_dict["top"] if check_memory is False: gdal.SetConfigOption("CHECK_DISK_FREE_SPACE", "FALSE") try: target_ds = gdal.GetDriverByName("GTiff").Create( raster_fn, x_res, y_res, 1, numpy_to_gdal_datatype2(dtype), ) finally: gdal.SetConfigOption("CHECK_DISK_FREE_SPACE", "TRUE") if target_ds is None: raise Exception("Unable to rasterize.") target_ds.SetGeoTransform((x_min, pixel_size, 0, y_max, 0, -pixel_size)) target_ds.SetProjection(source_meta["projection"]) band = target_ds.GetRasterBand(1) if nodata_value is not None: band.SetNoDataValue(nodata_value) else: band.Fill(fill_value) options = [] if all_touch == True: options.append("ALL_TOUCHED=TRUE") else: options.append("ALL_TOUCHED=FALSE") if optim == "raster": options.append("OPTIM=RASTER") elif optim == "vector": options.append("OPTIM=VECTOR") else: options.append("OPTIM=AUTO") if attribute is None: gdal.RasterizeLayer( target_ds, [1], source_layer, burn_values=[burn_value], options=options, ) else: options.append(f"ATTRIBUTE={attribute}") gdal.RasterizeLayer(target_ds, [1], source_layer, options=default_options(options)) return raster_fn
def raster_to_grid( raster: Union[str, gdal.Dataset], grid: Union[str, ogr.DataSource], out_dir: str, use_field: Optional[str] = None, generate_vrt: bool = True, overwrite: bool = True, process_layer: int = 0, creation_options: list = [], verbose: int = 1, ) -> Union[List[str], Tuple[Optional[List[str]], Optional[str]]]: """Clips a raster to a grid. Generate .vrt. Returns: The filepath for the newly created raster. """ type_check(raster, [str, gdal.Dataset], "raster") type_check(grid, [str, ogr.DataSource], "grid") type_check(out_dir, [str], "out_dir") type_check(overwrite, [bool], "overwrite") type_check(process_layer, [int], "process_layer") type_check(creation_options, [list], "creation_options") type_check(verbose, [int], "verbose") use_grid = open_vector(grid) grid_metadata = internal_vector_to_metadata(use_grid) raster_metadata = raster_to_metadata(raster, create_geometry=True) # Reproject raster if necessary. if not raster_metadata["projection_osr"].IsSame(grid_metadata["projection_osr"]): use_grid = reproject_vector(grid, raster_metadata["projection_osr"]) grid_metadata = internal_vector_to_metadata(use_grid) if not isinstance(grid_metadata, dict): raise Exception("Error while parsing metadata.") # Only use the polygons in the grid that intersect the extent of the raster. use_grid = intersect_vector(use_grid, raster_metadata["extent_datasource"]) ref = open_raster(raster) use_grid = open_vector(use_grid) layer = use_grid.GetLayer(process_layer) feature_count = layer.GetFeatureCount() raster_extent = raster_metadata["extent_ogr"] filetype = path_to_ext(raster) name = raster_metadata["name"] geom_type = grid_metadata["layers"][process_layer]["geom_type_ogr"] if use_field is not None: if use_field not in grid_metadata["layers"][process_layer]["field_names"]: names = grid_metadata["layers"][process_layer]["field_names"] raise ValueError( f"Requested field not found. Fields available are: {names}" ) generated = [] # For the sake of good reporting - lets first establish how many features intersect # the raster. if verbose: print("Finding intersections.") intersections = 0 for _ in range(feature_count): feature = layer.GetNextFeature() geom = feature.GetGeometryRef() if not ogr_bbox_intersects(raster_extent, geom.GetEnvelope()): continue intersections += 1 layer.ResetReading() if verbose: print(f"Found {intersections} intersections.") if intersections == 0: print("Warning: Found 0 intersections. Returning empty list.") return ([], None) # TODO: Replace this in gdal. 3.1 driver = ogr.GetDriverByName("Esri Shapefile") clipped = 0 for _ in range(feature_count): feature = layer.GetNextFeature() geom = feature.GetGeometryRef() if not ogr_bbox_intersects(raster_extent, geom.GetEnvelope()): continue if verbose == 1: progress(clipped, intersections - 1, "clip_grid") fid = feature.GetFID() test_ds_path = f"/vsimem/grid_{uuid4().int}.shp" test_ds = driver.CreateDataSource(test_ds_path) test_ds_lyr = test_ds.CreateLayer( "mem_layer_grid", geom_type=geom_type, srs=raster_metadata["projection_osr"], ) test_ds_lyr.CreateFeature(feature.Clone()) test_ds.FlushCache() out_name = None if use_field is not None: out_name = f"{out_dir}{feature.GetField(use_field)}{filetype}" else: out_name = f"{out_dir}{name}_{fid}{filetype}" clip_raster( ref, test_ds_path, out_path=out_name, adjust_bbox=True, crop_to_geom=True, all_touch=False, postfix="", prefix="", creation_options=default_options(creation_options), verbose=0, ) generated.append(out_name) clipped += 1 if generate_vrt: vrt_name = f"{out_dir}{name}.vrt" stack_rasters_vrt(generated, vrt_name, seperate=False) return (generated, vrt_name) return generated