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