def test_array_bounds():
with rasterio.open('tests/data/RGB.byte.tif') as src:
w, s, e, n = src.bounds
height = src.height
width = src.width
tr = transform.from_bounds(w, s, e, n, src.width, src.height)
assert (w, s, e, n) == transform.array_bounds(height, width, tr)
def test_array_bounds():
with rasterio.open('tests/data/RGB.byte.tif') as src:
w, s, e, n = src.bounds
height = src.height
width = src.width
tr = transform.from_bounds(w, s, e, n, src.width, src.height)
assert (w, s, e, n) == transform.array_bounds(height, width, tr)
def plot_canopy(canopy_arr,
canopy_transform,
canopy_crs=None,
num_steps=10,
**subplots_kws):
if canopy_crs is None:
canopy_crs = settings.CRS
# reproject the canopy array
height, width = canopy_arr.shape[-2:]
canopy_arr, canopy_transform = _reproject_raster(canopy_crs,
canopy_arr,
transform.array_bounds(
height, width,
canopy_transform),
canopy_transform,
dst_nodata=0)
# prepare the plot
fig, ax = plt.subplots(**subplots_kws)
# use geopandas plotting (with alpha 0) just to set the extent
gpd.GeoSeries([
geometry.box(
*transform.array_bounds(*canopy_arr.shape, canopy_transform))
]).plot(alpha=0, ax=ax)
ctx.add_basemap(ax)
# prepare a colormap for the trees
tree_cmap = np.stack([[0, 0.5, 0, 0] for _ in range(num_steps)])
# set alpha
tree_cmap[:, -1] = np.linspace(0, 1, num_steps)
# create new colormap
tree_cmap = colors.ListedColormap(tree_cmap)
# plot
# if len(canopy_arr.shape) == 3:
# canopy_arr = canopy_arr
plot.show(canopy_arr, transform=canopy_transform, ax=ax, cmap=tree_cmap)
ax.set_axis_off()
return ax
def get_img_bounds(img, jsonFile, dst_crs=None):
"""Get the projected top left and bottom right coordinates of an image
Parameters:
img (ndarray): image to generate bounding coordinates for
jsonFile (str): path to json file defining crs and image size
dst_crs (str): epsg code for output crs
Return:
tpl: [[lat min, lon min],[lat max, lon max]]
"""
# Get a single string w/ newlines from the IPython.utils.text.SList
with open(jsonFile, ) as f:
mixer = json.load(f)
# mixer = json.loads(jsonText.nlstr)
transform = mixer['projection']['affine']['doubleMatrix']
print(transform)
src_crs = CRS.from_string(mixer['projection']['crs'])
print(src_crs)
affine = rio.Affine(transform[0], transform[1], transform[2], transform[3],
transform[4], transform[5])
H, W = [0, 0]
if type(img) == np.ndarray:
print('input image is numpy')
H, W = img.shape
print('image shape is ', H, W)
bounds = array_bounds(H, W, affine)
elif type(img) == str:
print('input image is geotiff')
with rio.open(img) as src:
bounds = src.bounds
# H, W = src.shape
print(bounds)
lon_min, lat_min, lon_max, lat_max = bounds
# if we need to transform the bounds, such as for folium ('EPSG:3857')
if dst_crs:
dst_crs = CRS.from_string(dst_crs)
out_bounds = transform_bounds(src_crs,
dst_crs,
left=lon_min,
bottom=lat_min,
right=lon_max,
top=lat_max,
densify_pts=21)
lon_min, lat_min, lon_max, lat_max = out_bounds
print(out_bounds)
return [[lat_min, lon_min], [lat_max, lon_max]]
def align(self, base_layer, output_path=None):
if self.rescale:
with rasterio.open(base_layer) as src:
crs = src.meta['crs']
cell_size = src.meta['transform'][0]
transform = self.calculate_default_transform(crs)[0]
layer, meta = align_raster(base_layer, self.path, method=self.resample)
self.layer = layer
self.meta = meta
self.bounds = array_bounds(meta['height'], meta['width'],
meta['transform'])
if self.rescale:
self.layer[self.layer == self.meta['nodata']] = np.nan
self.meta['nodata'] = np.nan
factor = (cell_size**2) / (transform[0]**2)
self.layer *= factor
if output_path:
self.save(output_path)
def reproject(source, destination=None, src_transform=None, gcps=None, rpcs=None,
src_crs=None, src_nodata=None, dst_transform=None, dst_crs=None,
dst_nodata=None, dst_resolution=None, src_alpha=0, dst_alpha=0,
resampling=Resampling.nearest, num_threads=1,
init_dest_nodata=True, warp_mem_limit=0, **kwargs):
"""Reproject a source raster to a destination raster.
If the source and destination are ndarrays, coordinate reference
system definitions and affine transformation parameters or ground
control points (gcps) are required for reprojection.
If the source and destination are rasterio Bands, shorthand for
bands of datasets on disk, the coordinate reference systems and
transforms or GCPs will be read from the appropriate datasets.
Parameters
------------
source: ndarray or Band
The source is a 2 or 3-D ndarray, or a single or a multiple
Rasterio Band object. The dimensionality of source
and destination must match, i.e., for multiband reprojection
the lengths of the first axes of the source and destination
must be the same.
destination: ndarray or Band, optional
The destination is a 2 or 3-D ndarray, or a single or a multiple
Rasterio Band object. The dimensionality of source
and destination must match, i.e., for multiband reprojection
the lengths of the first axes of the source and destination
must be the same.
src_transform: affine.Affine(), optional
Source affine transformation. Required if source and
destination are ndarrays. Will be derived from source if it is
a rasterio Band. An error will be raised if this parameter is
defined together with gcps.
gcps: sequence of GroundControlPoint, optional
Ground control points for the source. An error will be raised
if this parameter is defined together with src_transform or rpcs.
rpcs: RPC or dict, optional
Rational polynomial coefficients for the source. An error will
be raised if this parameter is defined together with src_transform
or gcps.
src_crs: CRS or dict, optional
Source coordinate reference system, in rasterio dict format.
Required if source and destination are ndarrays.
Will be derived from source if it is a rasterio Band.
Example: CRS({'init': 'EPSG:4326'})
src_nodata: int or float, optional
The source nodata value. Pixels with this value will not be
used for interpolation. If not set, it will default to the
nodata value of the source image if a masked ndarray or
rasterio band, if available.
dst_transform: affine.Affine(), optional
Target affine transformation. Required if source and
destination are ndarrays. Will be derived from target if it is
a rasterio Band.
dst_crs: CRS or dict, optional
Target coordinate reference system. Required if source and
destination are ndarrays. Will be derived from target if it
is a rasterio Band.
dst_nodata: int or float, optional
The nodata value used to initialize the destination; it will
remain in all areas not covered by the reprojected source.
Defaults to the nodata value of the destination image (if set),
the value of src_nodata, or 0 (GDAL default).
dst_resolution: tuple (x resolution, y resolution) or float, optional
Target resolution, in units of target coordinate reference
system.
src_alpha : int, optional
Index of a band to use as the alpha band when warping.
dst_alpha : int, optional
Index of a band to use as the alpha band when warping.
resampling: int, rasterio.enums.Resampling
Resampling method to use.
Default is :attr:`rasterio.enums.Resampling.nearest`.
An exception will be raised for a method not supported by the running
version of GDAL.
num_threads : int, optional
The number of warp worker threads. Default: 1.
init_dest_nodata: bool
Flag to specify initialization of nodata in destination;
prevents overwrite of previous warps. Defaults to True.
warp_mem_limit : int, optional
The warp operation memory limit in MB. Larger values allow the
warp operation to be carried out in fewer chunks. The amount of
memory required to warp a 3-band uint8 2000 row x 2000 col
raster to a destination of the same size is approximately
56 MB. The default (0) means 64 MB with GDAL 2.2.
kwargs: dict, optional
Additional arguments passed to transformation function.
Returns
---------
destination: ndarray or Band
The transformed narray or Band.
dst_transform: Affine
THe affine transformation matrix of the destination.
"""
# Only one type of georeferencing is permitted.
if (src_transform and gcps) or (src_transform and rpcs) or (gcps and rpcs):
raise ValueError("src_transform, gcps, and rpcs are mutually "
"exclusive parameters and may not be used together.")
# Guard against invalid or unsupported resampling algorithms.
try:
if resampling == 7:
raise ValueError("Gauss resampling is not supported")
Resampling(resampling)
except ValueError:
raise ValueError(
"resampling must be one of: {0}".format(", ".join(
['Resampling.{0}'.format(r.name) for r in
SUPPORTED_RESAMPLING])))
if destination is None and dst_transform is not None:
raise ValueError("Must provide destination if dst_transform is provided.")
# calculate the destination transform if not provided
if dst_transform is None and (destination is None or isinstance(destination, np.ndarray)):
src_bounds = tuple([None] * 4)
if isinstance(source, np.ndarray):
if source.ndim == 3:
src_count, src_height, src_width = source.shape
else:
src_count = 1
src_height, src_width = source.shape
# try to compute src_bounds if we don't have gcps
if not (gcps or rpcs):
src_bounds = array_bounds(src_height, src_width, src_transform)
else:
src_rdr, src_bidx, _, src_shape = source
# dataset.bounds will return raster extents in pixel coordinates
# if dataset does not have geotransform, which is not useful here.
if not (src_rdr.transform.is_identity and src_rdr.crs is None):
src_bounds = src_rdr.bounds
src_crs = src_crs or src_rdr.crs
if isinstance(src_bidx, int):
src_bidx = [src_bidx]
src_count = len(src_bidx)
src_height, src_width = src_shape
gcps = src_rdr.gcps[0] if src_rdr.gcps[0] else None
dst_height = None
dst_width = None
dst_count = src_count
if isinstance(destination, np.ndarray):
if destination.ndim == 3:
dst_count, dst_height, dst_width = destination.shape
else:
dst_count = 1
dst_height, dst_width = destination.shape
left, bottom, right, top = src_bounds
dst_transform, dst_width, dst_height = calculate_default_transform(
src_crs=src_crs, dst_crs=dst_crs, width=src_width, height=src_height,
left=left, bottom=bottom, right=right, top=top,
gcps=gcps, rpcs=rpcs, dst_width=dst_width, dst_height=dst_height,
resolution=dst_resolution)
if destination is None:
destination = np.empty((int(dst_count), int(dst_height), int(dst_width)),
dtype=source.dtype)
# Call the function in our extension module.
_reproject(
source, destination, src_transform=src_transform, gcps=gcps, rpcs=rpcs,
src_crs=src_crs, src_nodata=src_nodata, dst_transform=dst_transform,
dst_crs=dst_crs, dst_nodata=dst_nodata, dst_alpha=dst_alpha,
src_alpha=src_alpha, resampling=resampling,
init_dest_nodata=init_dest_nodata, num_threads=num_threads,
warp_mem_limit=warp_mem_limit, **kwargs)
return destination, dst_transform
def get_file_bounds(filenames,
bounds_by='intersection',
crs=None,
res=None,
return_bounds=False):
"""
Gets the union of all files
Args:
filenames (list): The file names to mosaic.
bounds_by (Optional[str]): How to concatenate the output extent. Choices are ['intersection', 'union'].
crs (Optional[crs]): The CRS to warp to.
res (Optional[tuple]): The cell resolution to warp to.
return_bounds (Optional[bool]): Whether to return the bounds tuple.
Returns:
transform, width, height
"""
with rio.open(filenames[0]) as src:
if not crs:
crs = src.crs
if not res:
res = src.res
# Transform the extent to the reference CRS
bounds_left, bounds_bottom, bounds_right, bounds_top = transform_bounds(
src.crs,
crs,
src.bounds.left,
src.bounds.bottom,
src.bounds.right,
src.bounds.top,
densify_pts=21)
if bounds_by.lower() in ['union', 'intersection']:
for fn in filenames[1:]:
with rio.open(fn) as src:
# Transform the extent to the reference CRS
left, bottom, right, top = transform_bounds(src.crs,
crs,
src.bounds.left,
src.bounds.bottom,
src.bounds.right,
src.bounds.top,
densify_pts=21)
# Update the mosaic bounds
if bounds_by.lower() == 'union':
bounds_left = min(bounds_left, left)
bounds_bottom = min(bounds_bottom, bottom)
bounds_right = max(bounds_right, right)
bounds_top = max(bounds_top, top)
elif bounds_by.lower() == 'intersection':
bounds_left = max(bounds_left, left)
bounds_bottom = max(bounds_bottom, bottom)
bounds_right = min(bounds_right, right)
bounds_top = min(bounds_top, top)
# Align the cells
bounds_transform, bounds_width, bounds_height = align_bounds(
bounds_left, bounds_bottom, bounds_right, bounds_top, res)
else:
bounds_width = int((bounds_right - bounds_left) / abs(res[0]))
bounds_height = int((bounds_top - bounds_bottom) / abs(res[1]))
bounds_transform = from_bounds(bounds_left, bounds_bottom,
bounds_right, bounds_top, bounds_width,
bounds_height)
if return_bounds:
return array_bounds(bounds_height, bounds_width, bounds_transform)
else:
return bounds_transform, bounds_width, bounds_height
def bounds_from_profile(profile):
""" bounds from profile """
a = profile['transform']
h = profile['height']
w = profile['width']
return transform.array_bounds(h, w, a)
def get_array_bounds(self, window):
return array_bounds(window.height, window.width,
self.get_window_transform(window))
def __iter__(self, chunk_size=None, overlap=None):
for window in self.iter_windows(chunk_size, overlap):
bounds = array_bounds(window.height, window.width,
self.get_window_transform(window))
yield window, bounds
DEMmin = resample( rast, dx, method=Resampling.min) npDEM = np.copy(DEMavg['raster']) ## 2. Rasterize streams arr_stream = vtorast( vect, cell_size = dx)['raster'] ### 2i. expand streams to have same dimensions as DEM arr_stream_expand = np.full_like(npDEM,0) arr_stream_expand[0:arr_stream.shape[0],0:arr_stream.shape[1]] = arr_stream arr_stream = np.copy(arr_stream_expand) ## 3. Set elevation to minimum cell elevation where stream cells exist npDEM[arr_stream> 0] = DEMmin['raster'][arr_stream> 0] ### 3.ii Read in basalt and sediment depth rasters region = transform.array_bounds(*npDEM.shape,DEMavg['affine']) dseds = resample(seds, dx, bounds=region, method=Resampling.average) dbasalt = resample(basalts, dx, bounds=region, method=Resampling.average) DEMbottom2 = npDEM - dseds['raster'] - dbasalt['raster'] DEMbottom1 = npDEM - dseds['raster'] #%% ### 3.i. Plot up these DEMs # mask for plotting river elevations only mask = np.zeros(npDEM.shape,dtype=bool) mask[ arr_stream == 0 ] = True cmin = -500 cmax = np.ceil(npDEM.max()/100)*100 fig,ax = plt.subplots(2,3,figsize=(15,10)) ax=ax.ravel() im = ax[0].imshow(DEMavg['raster'],cmap='terrain',vmin=cmin,vmax=cmax)
def warp_ds(ds,
src_crs,
new_cell_size=None,
dst_crs=None,
var_name='rain',
xname='longitude',
yname='latitude',
tname='time',
resampling_alg=gdal.GRA_CubicSpline):
from tqdm import tqdm
# todo: not sure what happens if the order of co-ordinates in the source xarray
# does not match the order expected here (time, latitude, longitude)
x_size, y_size = ds.dims[xname], ds.dims[yname]
if not new_cell_size:
new_cell_size = (x_size, y_size)
if not dst_crs:
dst_crs = src_crs
time_size = ds.dims[tname]
ds_src_transform = get_transform(ds, x_coords=xname, y_coords=yname)
west, south, east, north = array_bounds(height=y_size,
width=x_size,
transform=ds_src_transform)
src_ds = create_mem_src(x_size, y_size, ds_src_transform, src_crs)
dst_transform, dst_width, dst_height = calculate_default_transform(
src_crs=src_crs,
dst_crs=dst_crs,
width=x_size,
height=y_size,
left=west,
bottom=south,
right=east,
top=north,
resolution=(new_cell_size, new_cell_size))
out_bounds = array_bounds(height=dst_height,
width=dst_width,
transform=dst_transform)
wrapopts = gdal.WarpOptions(xRes=new_cell_size,
yRes=new_cell_size,
srcSRS=src_crs.to_wkt(),
dstSRS=dst_crs.to_wkt(),
outputBounds=out_bounds,
resampleAlg=resampling_alg,
dstNodata=np.nan)
new_xs, new_ys = return_coords(dst_transform, dst_width, dst_height)
time_values = times = ds.indexes[tname]
warped_data = np.zeros((time_size, dst_height, dst_width))
for ti, tvalue in tqdm(list(enumerate(ds.indexes[tname]))):
data = ds[var_name][ti, ...].values.copy()
src_ds.GetRasterBand(1).WriteArray(data)
tb = src_ds.GetRasterBand(1)
gdal.FillNodata(tb,
maskBand=None,
maxSearchDist=6,
smoothingIterations=0)
_ = tb.ReadAsArray()
warp_ras = gdal.Warp(r"/vsimem/wrap_singletimestamp.tiff",
src_ds,
options=wrapopts)
warped_slice = warp_ras.GetRasterBand(1).ReadAsArray().copy()
if warped_slice.shape != (dst_height, dst_width):
raise ValueError(warped_slice.shape, (dst_height, dst_width))
warped_data[ti, ...] = warped_slice
del warp_ras
warped_ds = xr.DataArray(warped_data,
coords=[times, new_ys, new_xs],
dims=[tname, yname, xname])
return warped_ds
def polygonize_pred(
image_pred_uint8_bin,
image_crs: str,
image_transform,
classname: str = None,
output_basefilepath: Optional[Path] = None,
prediction_cleanup_params: dict = None,
border_pixels_to_ignore: int = 0) -> Optional[gpd.GeoDataFrame]:
# Polygonize result
try:
# Returns a list of tupples with (geometry, value)
polygonized_records = list(rio_features.shapes(
image_pred_uint8_bin, mask=image_pred_uint8_bin, transform=image_transform))
# If nothing found, we can return
if len(polygonized_records) == 0:
return None
# Convert shapes to geopandas geodataframe
geoms = []
for geom, _ in polygonized_records:
geoms.append(sh_geom.shape(geom))
geoms_gdf = gpd.GeoDataFrame(geoms, columns=['geometry'])
geoms_gdf.crs = image_crs
# Calculate the bounds of the image in projected coordinates
image_shape = image_pred_uint8_bin.shape
image_width = image_shape[0]
image_height = image_shape[1]
image_bounds = rio_transform.array_bounds(
image_height, image_width, image_transform)
x_pixsize = get_pixelsize_x(image_transform)
y_pixsize = get_pixelsize_y(image_transform)
border_bounds = (image_bounds[0]+border_pixels_to_ignore*x_pixsize,
image_bounds[1]+border_pixels_to_ignore*y_pixsize,
image_bounds[2]-border_pixels_to_ignore*x_pixsize,
image_bounds[3]-border_pixels_to_ignore*y_pixsize)
# Calculate the tolerance as half the diagonal of the square formed
# by the min pixel size, rounded up in centimeter
if prediction_cleanup_params is not None:
# If a simplify is asked...
if 'simplify_algorithm' in prediction_cleanup_params:
# Define the bounds of the image as linestring, so points on this
# border are preserved during the simplify
border_polygon = sh_geom.box(*border_bounds)
assert border_polygon.exterior is not None
border_lines = sh_geom.LineString(border_polygon.exterior.coords)
geoms_gdf.geometry = geoms_gdf.geometry.apply(
lambda geom: gfo_vector_util.simplify_ext(
geometry=geom,
algorithm=prediction_cleanup_params['simplify_algorithm'],
tolerance=prediction_cleanup_params['simplify_tolerance'],
keep_points_on=border_lines))
# Remove geom rows that became empty after simplify + explode
geoms_gdf = geoms_gdf[~geoms_gdf.geometry.is_empty]
geoms_gdf = geoms_gdf[~geoms_gdf.geometry.isna()]
if len(geoms_gdf) == 0:
return None
#geoms_gdf.reset_index(drop=True, inplace=True)
geoms_gdf = geoms_gdf.explode(ignore_index=True) # type: ignore
#geoms_gdf.reset_index(drop=True, inplace=True)
# Now we can calculate the "onborder" property
geoms_gdf = vector_util.calc_onborder(geoms_gdf, border_bounds) # type: ignore
# Add the classname if provided and area
if classname is not None:
geoms_gdf['classname'] = classname
geoms_gdf['area'] = geoms_gdf.geometry.area
# Write the geoms to file
if output_basefilepath is not None:
geom_filepath = Path(f"{str(output_basefilepath)}_pred_cleaned_2.geojson")
geofile.to_file(geoms_gdf, geom_filepath, index=False)
return geoms_gdf
except Exception as ex:
message = f"Exception while polygonizing to file {output_basefilepath}"
raise Exception(message) from ex
crs = rasterio.crs.CRS.from_string( crs )
gcps = "-gcp 0 0 -164.510605 57.652809 -gcp 0 298 -172.422668 70.599640 -gcp 298 0 -139.489395 57.652809 -gcp 298 298 -131.577332 70.599640"
# resolution is a real hacky way to do it and not correct
res = np.mean([np.diff(lon).min(), np.diff(lon).max()])
affine = rasterio.transform.from_origin( lon.data.min(), lat.data.max(), res, -res ) # upper left pixel
time, levels, height, width = out_ds[variable].shape
meta = {'res':(res, res), 'affine':affine, 'height':height, 'width':width, 'count':1, 'dtype':'float32', 'driver':'GTiff', 'compress':'lzw', 'crs':crs }
# subset to one of the 29 'levels' no idea what these are...
levelint = 0
out_ds_level = out_ds[variable].isel( level=levelint )
# # warp to 3338
with rasterio.drivers( CHECK_WITH_INVERT_PROJ=True ): # constrain output to legit warp extent -- may want to remove...
src_bounds = array_bounds( width, height, affine )
dst_crs = {'init':'epsg:3338'}
# Calculate the ideal dimensions and transformation in the new crs
dst_affine, dst_width, dst_height = calculate_default_transform(
crs, dst_crs, width, height, *src_bounds)
for band in range(time):
print( 'reprojecting: {}'.format(band) )
# in/out arrays
cur_arr = out_ds_level[ band, ... ].data
out_arr = np.empty_like( cur_arr )
# reproject
reproject( cur_arr, out_arr, src_transform=affine, src_crs=crs, src_nodata=-1,
dst_transform=dst_affine, dst_crs=dst_crs, dst_nodata=-9999, resampling=RESAMPLING.bilinear,
SOURCE_EXTRA=1000, num_threads=4 )
