def clip(self):
""" Clip images based on bounds provided
Implementation is borrowed from
https://github.com/brendan-ward/rasterio/blob/e3687ce0ccf8ad92844c16d913a6482d5142cf48/rasterio/rio/convert.py
"""
self.output("Clipping", normal=True)
# create new folder for clipped images
path = check_create_folder(join(self.scene_path, 'clipped'))
try:
temp_bands = copy(self.bands)
temp_bands.append('QA')
for i, band in enumerate(temp_bands):
band_name = self._get_full_filename(band)
band_path = join(self.scene_path, band_name)
self.output("Band %s" % band,
normal=True,
color='green',
indent=1)
with rasterio.open(band_path) as src:
bounds = transform_bounds(
{
'proj': 'longlat',
'ellps': 'WGS84',
'datum': 'WGS84',
'no_defs': True
}, src.crs, *self.bounds)
if disjoint_bounds(bounds, src.bounds):
bounds = adjust_bounding_box(src.bounds, bounds)
window = src.window(*bounds)
out_kwargs = src.meta.copy()
out_kwargs.update({
'driver': 'GTiff',
'height': window[0][1] - window[0][0],
'width': window[1][1] - window[1][0],
'transform': src.window_transform(window)
})
with rasterio.open(join(path, band_name), 'w',
**out_kwargs) as out:
out.write(src.read(window=window))
# Copy MTL to the clipped folder
copyfile(join(self.scene_path, self.scene + '_MTL.txt'),
join(path, self.scene + '_MTL.txt'))
return path
except IOError as e:
exit(e.message, 1)
def clip(self):
""" Clip images based on bounds provided
Implementation is borrowed from
https://github.com/brendan-ward/rasterio/blob/e3687ce0ccf8ad92844c16d913a6482d5142cf48/rasterio/rio/convert.py
"""
self.output("Clipping", normal=True)
# create new folder for clipped images
path = check_create_folder(join(self.scene_path, 'clipped'))
try:
temp_bands = copy(self.bands)
temp_bands.append('QA')
for i, band in enumerate(temp_bands):
band_name = self._get_full_filename(band)
band_path = join(self.scene_path, band_name)
self.output("Band %s" % band, normal=True, color='green', indent=1)
with rasterio.open(band_path) as src:
bounds = transform_bounds(
{
'proj': 'longlat',
'ellps': 'WGS84',
'datum': 'WGS84',
'no_defs': True
},
src.crs,
*self.bounds
)
if disjoint_bounds(bounds, src.bounds):
bounds = adjust_bounding_box(src.bounds, bounds)
window = src.window(*bounds)
out_kwargs = src.meta.copy()
out_kwargs.update({
'driver': 'GTiff',
'height': window[0][1] - window[0][0],
'width': window[1][1] - window[1][0],
'transform': src.window_transform(window)
})
with rasterio.open(join(path, band_name), 'w', **out_kwargs) as out:
out.write(src.read(window=window))
# Copy MTL to the clipped folder
copyfile(join(self.scene_path, self.scene + '_MTL.txt'), join(path, self.scene + '_MTL.txt'))
return path
except IOError as e:
exit(e.message, 1)
def bbox_intersection(bounds1, bounds2):
if disjoint_bounds(bounds1, bounds2):
raise Exception("Bounds are disjoint, no interseciton exists")
bbox = BoundingBox(
left=max(bounds1.left, bounds2.left),
right=min(bounds1.right, bounds2.right),
top=min(bounds1.top, bounds2.top),
bottom=max(bounds1.bottom, bounds2.bottom)
)
return bbox
def list_files(self, time:pd.Timestamp) -> list:
out = []
if time in self.times:
time = pd.Timestamp(f'{time.year}-{time.month}-01')
time_pattern = time.strftime('%Y%m%d')
files = self.paths.src.ls(recursive=True, include=['JD.tif', time_pattern],
exclude=['.xml'])
# Find windows joint with region bounding box
for f in files:
data = open_tif(f)
if not disjoint_bounds(data.bounds, self.region.bbox):
out.append(f)
return out
def _clip_bounds(self, bounds):
if disjoint_bounds(bounds, self.raster.bounds):
raise Exception("Bounds are disjoint, no interseciton exists")
# Get the new bounds as a window in the original raster
bounds_window = rasterio.windows.from_bounds(*bounds, transform=self.raster.transform)
bounds_window = bounds_window.intersection(self.window)
self.window = bounds_window.round_lengths(op='ceil')
self.height = int(self.window.height)
self.width = int(self.window.width)
self.transform = rasterio.windows.transform(self.window, self.transform)
self._update_profile()
def clip_raster(raster, dst_bounds):
src = read_raster(raster)
src_bounds = src.bounds
if disjoint_bounds(src_bounds, dst_bounds):
msg = 'Raster bounds {} are not covered by clipping bounds {}'.format(src_bounds, dst_bounds)
raise ValueError(msg)
window = src.window(*dst_bounds)
window = window.round_lengths(op='ceil')
transform = src.window_transform(window)
data = src.read(window=window, out_shape=(src.count, window.height, window.width))
src.close()
return data, transform
def clip(
ctx,
files,
output,
bounds,
like,
driver,
nodata,
projection,
overwrite,
creation_options,
with_complement,
):
"""Clips a raster using projected or geographic bounds.
The values of --bounds are presumed to be from the coordinate
reference system of the input dataset unless the --geographic option
is used, in which case the values may be longitude and latitude
bounds. Either JSON, for example "[west, south, east, north]", or
plain text "west south east north" representations of a bounding box
are acceptable.
If using --like, bounds will automatically be transformed to match
the coordinate reference system of the input.
Datasets with non-rectilinear geo transforms (i.e. with rotation
and/or shear) may not be cropped using this command. They must be
processed with rio-warp.
Examples
--------
$ rio clip input.tif output.tif --bounds xmin ymin xmax ymax
$ rio clip input.tif output.tif --like template.tif
"""
from rasterio.warp import transform_bounds
with ctx.obj['env']:
output, files = resolve_inout(files=files, output=output, overwrite=overwrite)
input = files[0]
with rasterio.open(input) as src:
if not src.transform.is_rectilinear:
raise click.BadParameter(
"Non-rectilinear rasters (i.e. with rotation or shear) cannot be clipped"
)
if bounds:
if projection == 'geographic':
bounds = transform_bounds(CRS.from_epsg(4326), src.crs, *bounds)
if disjoint_bounds(bounds, src.bounds):
raise click.BadParameter('must overlap the extent of '
'the input raster',
param='--bounds',
param_hint='--bounds')
elif like:
with rasterio.open(like) as template_ds:
bounds = template_ds.bounds
if template_ds.crs != src.crs:
bounds = transform_bounds(template_ds.crs, src.crs,
*bounds)
if disjoint_bounds(bounds, src.bounds):
raise click.BadParameter('must overlap the extent of '
'the input raster',
param='--like',
param_hint='--like')
else:
raise click.UsageError('--bounds or --like required')
bounds_window = src.window(*bounds)
if not with_complement:
bounds_window = bounds_window.intersection(
Window(0, 0, src.width, src.height)
)
# Get the window with integer height
# and width that contains the bounds window.
out_window = bounds_window.round_lengths(op='ceil')
height = int(out_window.height)
width = int(out_window.width)
out_kwargs = src.profile
if driver:
out_kwargs["driver"] = driver
if nodata is not None:
out_kwargs["nodata"] = nodata
out_kwargs.update({
'height': height,
'width': width,
'transform': src.window_transform(out_window)})
out_kwargs.update(**creation_options)
if "blockxsize" in out_kwargs and int(out_kwargs["blockxsize"]) > width:
del out_kwargs["blockxsize"]
logger.warning(
"Blockxsize removed from creation options to accomodate small output width"
)
if "blockysize" in out_kwargs and int(out_kwargs["blockysize"]) > height:
del out_kwargs["blockysize"]
logger.warning(
"Blockysize removed from creation options to accomodate small output height"
)
with rasterio.open(output, "w", **out_kwargs) as out:
out.write(
src.read(
window=out_window,
out_shape=(src.count, height, width),
boundless=True,
masked=True,
)
)
def rasterize(
ctx,
files,
output,
driver,
like,
bounds,
dimensions,
res,
src_crs,
all_touched,
default_value,
fill,
prop,
overwrite,
nodata,
creation_options):
"""Rasterize GeoJSON into a new or existing raster.
If the output raster exists, rio-rasterize will rasterize feature
values into all bands of that raster. The GeoJSON is assumed to be
in the same coordinate reference system as the output unless
--src-crs is provided.
--default_value or property values when using --property must be
using a data type valid for the data type of that raster.
If a template raster is provided using the --like option, the affine
transform and data type from that raster will be used to create the
output. Only a single band will be output.
The GeoJSON is assumed to be in the same coordinate reference system
unless --src-crs is provided.
--default_value or property values when using --property must be
using a data type valid for the data type of that raster.
--driver, --bounds, --dimensions, --res, --nodata are ignored when
output exists or --like raster is provided
If the output does not exist and --like raster is not provided, the
input GeoJSON will be used to determine the bounds of the output
unless provided using --bounds.
--dimensions or --res are required in this case.
If --res is provided, the bottom and right coordinates of bounds are
ignored.
Note
----
The GeoJSON is not projected to match the coordinate reference
system of the output or --like rasters at this time. This
functionality may be added in the future.
"""
from rasterio.crs import CRS
from rasterio.features import rasterize
from rasterio.features import bounds as calculate_bounds
output, files = resolve_inout(
files=files, output=output, overwrite=overwrite)
bad_param = click.BadParameter('invalid CRS. Must be an EPSG code.',
ctx, param=src_crs, param_hint='--src_crs')
has_src_crs = src_crs is not None
try:
src_crs = CRS.from_string(src_crs) if has_src_crs else CRS.from_string('EPSG:4326')
except CRSError:
raise bad_param
# If values are actually meant to be integers, we need to cast them
# as such or rasterize creates floating point outputs
if default_value == int(default_value):
default_value = int(default_value)
if fill == int(fill):
fill = int(fill)
with ctx.obj['env']:
def feature_value(feature):
if prop and 'properties' in feature:
return feature['properties'].get(prop, default_value)
return default_value
with click.open_file(files.pop(0) if files else '-') as gj_f:
geojson = json.loads(gj_f.read())
if 'features' in geojson:
geometries = []
for f in geojson['features']:
geometries.append((f['geometry'], feature_value(f)))
elif 'geometry' in geojson:
geometries = ((geojson['geometry'], feature_value(geojson)), )
else:
raise click.BadParameter('Invalid GeoJSON', param=input,
param_hint='input')
geojson_bounds = geojson.get('bbox', calculate_bounds(geojson))
if rasterio.shutil.exists(output):
with rasterio.open(output, 'r+') as out:
if has_src_crs and src_crs != out.crs:
raise click.BadParameter('GeoJSON does not match crs of '
'existing output raster',
param='input', param_hint='input')
if disjoint_bounds(geojson_bounds, out.bounds):
click.echo("GeoJSON outside bounds of existing output "
"raster. Are they in different coordinate "
"reference systems?",
err=True)
meta = out.meta
result = rasterize(
geometries,
out_shape=(meta['height'], meta['width']),
transform=meta.get('affine', meta['transform']),
all_touched=all_touched,
dtype=meta.get('dtype', None),
default_value=default_value,
fill=fill)
for bidx in range(1, meta['count'] + 1):
data = out.read(bidx, masked=True)
# Burn in any non-fill pixels, and update mask accordingly
ne = result != fill
data[ne] = result[ne]
if data.mask.any():
data.mask[ne] = False
out.write(data, indexes=bidx)
else:
if like is not None:
template_ds = rasterio.open(like)
if has_src_crs and src_crs != template_ds.crs:
raise click.BadParameter('GeoJSON does not match crs of '
'--like raster',
param='input', param_hint='input')
if disjoint_bounds(geojson_bounds, template_ds.bounds):
click.echo("GeoJSON outside bounds of --like raster. "
"Are they in different coordinate reference "
"systems?",
err=True)
kwargs = template_ds.profile
kwargs['count'] = 1
kwargs['transform'] = template_ds.transform
template_ds.close()
else:
bounds = bounds or geojson_bounds
if src_crs.is_geographic:
if (bounds[0] < -180 or bounds[2] > 180 or
bounds[1] < -80 or bounds[3] > 80):
raise click.BadParameter(
"Bounds are beyond the valid extent for "
"EPSG:4326.",
ctx, param=bounds, param_hint='--bounds')
if dimensions:
width, height = dimensions
res = (
(bounds[2] - bounds[0]) / float(width),
(bounds[3] - bounds[1]) / float(height)
)
else:
if not res:
raise click.BadParameter(
'pixel dimensions are required',
ctx, param=res, param_hint='--res')
elif len(res) == 1:
res = (res[0], res[0])
width = max(int(ceil((bounds[2] - bounds[0]) /
float(res[0]))), 1)
height = max(int(ceil((bounds[3] - bounds[1]) /
float(res[1]))), 1)
kwargs = {
'count': 1,
'crs': src_crs,
'width': width,
'height': height,
'transform': Affine(res[0], 0, bounds[0], 0, -res[1],
bounds[3]),
'driver': driver
}
kwargs.update(**creation_options)
if nodata is not None:
kwargs['nodata'] = nodata
result = rasterize(
geometries,
out_shape=(kwargs['height'], kwargs['width']),
transform=kwargs['transform'],
all_touched=all_touched,
dtype=kwargs.get('dtype', None),
default_value=default_value,
fill=fill)
if 'dtype' not in kwargs:
kwargs['dtype'] = result.dtype
with rasterio.open(output, 'w', **kwargs) as out:
out.write(result, indexes=1)
def rasterize(
geojson,
output,
like=None,
bounds=None,
dimensions=None,
res=None,
src_crs=None,
all_touched=None,
default_value=1,
fill=0,
prop=None,
force_overwrite=None,
creation_options={},
driver='GTiff'):
from rasterio._base import is_geographic_crs, is_same_crs
from rasterio.features import rasterize
from rasterio.features import bounds as calculate_bounds
has_src_crs = src_crs is not None
src_crs = src_crs or 'EPSG:4326'
# If values are actually meant to be integers, we need to cast them
# as such or rasterize creates floating point outputs
if default_value == int(default_value):
default_value = int(default_value)
if fill == int(fill):
fill = int(fill)
with rasterio.drivers():
def feature_value(feature):
if prop and 'properties' in feature:
return feature['properties'].get(prop, default_value)
return default_value
if 'features' in geojson:
geometries = []
for f in geojson['features']:
geometries.append((f['geometry'], feature_value(f)))
elif 'geometry' in geojson:
geometries = ((geojson['geometry'], feature_value(geojson)), )
else:
raise Exception
geojson_bounds = geojson.get('bbox', calculate_bounds(geojson))
if like is not None:
template_ds = rasterio.open(like)
if has_src_crs and not is_same_crs(src_crs, template_ds.crs):
raise Exception
if disjoint_bounds(geojson_bounds, template_ds.bounds):
print "GeoJSON outside bounds of --like raster. "
kwargs = template_ds.meta.copy()
kwargs['count'] = 1
# DEPRECATED
# upgrade transform to affine object or we may get an invalid
# transform set on output
kwargs['transform'] = template_ds.affine
template_ds.close()
else:
bounds = bounds or geojson_bounds
if is_geographic_crs(src_crs):
if (bounds[0] < -180 or bounds[2] > 180 or
bounds[1] < -80 or bounds[3] > 80):
raise Exception
if dimensions:
width, height = dimensions
res = (
(bounds[2] - bounds[0]) / float(width),
(bounds[3] - bounds[1]) / float(height)
)
else:
if not res:
raise Exception
elif len(res) == 1:
res = (res[0], res[0])
width = max(int(ceil((bounds[2] - bounds[0]) /
float(res[0]))), 1)
height = max(int(ceil((bounds[3] - bounds[1]) /
float(res[1]))), 1)
src_crs = src_crs.upper()
if not src_crs.count('EPSG:'):
raise Exception
kwargs = {
'count': 1,
'crs': src_crs,
'width': width,
'height': height,
'transform': Affine(res[0], 0, bounds[0], 0, -res[1],
bounds[3]),
'driver': driver
}
kwargs.update(**creation_options)
result = rasterize(
geometries,
out_shape=(kwargs['height'], kwargs['width']),
transform=kwargs.get('affine', kwargs['transform']),
all_touched=all_touched,
dtype=kwargs.get('dtype', None),
default_value=default_value,
fill = fill)
if 'dtype' not in kwargs:
kwargs['dtype'] = result.dtype
kwargs['nodata'] = fill
with rasterio.open(output, 'w', **kwargs) as out:
out.write_band(1, result)
def clip(ctx, files, output, bounds, like, driver, projection,
creation_options):
"""Clips a raster using projected or geographic bounds.
\b
$ rio clip input.tif output.tif --bounds xmin ymin xmax ymax
$ rio clip input.tif output.tif --like template.tif
The values of --bounds are presumed to be from the coordinate
reference system of the input dataset unless the --geographic option
is used, in which case the values may be longitude and latitude
bounds. Either JSON, for example "[west, south, east, north]", or
plain text "west south east north" representations of a bounding box
are acceptable.
If using --like, bounds will automatically be transformed to match the
coordinate reference system of the input.
It can also be combined to read bounds of a feature dataset using Fiona:
\b
$ rio clip input.tif output.tif --bounds $(fio info features.shp --bounds)
"""
from rasterio.warp import transform_bounds
with ctx.obj['env']:
output, files = resolve_inout(files=files, output=output)
input = files[0]
with rasterio.open(input) as src:
if bounds:
if projection == 'geographic':
bounds = transform_bounds('epsg:4326', src.crs, *bounds)
if disjoint_bounds(bounds, src.bounds):
raise click.BadParameter(
'must overlap the extent of '
'the input raster',
param='--bounds',
param_hint='--bounds')
elif like:
with rasterio.open(like) as template_ds:
bounds = template_ds.bounds
if template_ds.crs != src.crs:
bounds = transform_bounds(template_ds.crs, src.crs,
*bounds)
if disjoint_bounds(bounds, src.bounds):
raise click.BadParameter(
'must overlap the extent of '
'the input raster',
param='--like',
param_hint='--like')
else:
raise click.UsageError('--bounds or --like required')
bounds_window = src.window(*bounds)
bounds_window = bounds_window.intersection(
Window(0, 0, src.width, src.height))
# Get the window with integer height
# and width that contains the bounds window.
out_window = bounds_window.round_lengths(op='ceil')
height = int(out_window.height)
width = int(out_window.width)
out_kwargs = src.profile
out_kwargs.update({
'driver': driver,
'height': height,
'width': width,
'transform': src.window_transform(out_window)
})
out_kwargs.update(**creation_options)
if 'blockxsize' in out_kwargs and out_kwargs['blockxsize'] > width:
del out_kwargs['blockxsize']
logger.warn(
"Blockxsize removed from creation options to accomodate small output width"
)
if 'blockysize' in out_kwargs and out_kwargs['blockysize'] > height:
del out_kwargs['blockysize']
logger.warn(
"Blockysize removed from creation options to accomodate small output height"
)
with rasterio.open(output, 'w', **out_kwargs) as out:
out.write(
src.read(window=out_window,
out_shape=(src.count, height, width)))
def merge(
datasets,
bounds=None,
res=None,
nodata=None,
dtype=None,
precision=None,
indexes=None,
output_count=None,
resampling=Resampling.nearest,
method="first",
target_aligned_pixels=False,
dst_path=None,
dst_kwds=None,
):
"""Copy valid pixels from input files to an output file.
All files must have the same number of bands, data type, and
coordinate reference system.
Input files are merged in their listed order using the reverse
painter's algorithm (default) or another method. If the output file exists,
its values will be overwritten by input values.
Geospatial bounds and resolution of a new output file in the
units of the input file coordinate reference system may be provided
and are otherwise taken from the first input file.
Parameters
----------
datasets : list of dataset objects opened in 'r' mode, filenames or PathLike objects
source datasets to be merged.
bounds: tuple, optional
Bounds of the output image (left, bottom, right, top).
If not set, bounds are determined from bounds of input rasters.
res: tuple, optional
Output resolution in units of coordinate reference system. If not set,
the resolution of the first raster is used. If a single value is passed,
output pixels will be square.
nodata: float, optional
nodata value to use in output file. If not set, uses the nodata value
in the first input raster.
dtype: numpy dtype or string
dtype to use in outputfile. If not set, uses the dtype value in the
first input raster.
precision: float, optional
Number of decimal points of precision when computing inverse transform.
indexes : list of ints or a single int, optional
bands to read and merge
output_count: int, optional
If using callable it may be useful to have additional bands in the output
in addition to the indexes specified for read
resampling : Resampling, optional
Resampling algorithm used when reading input files.
Default: `Resampling.nearest`.
method : str or callable
pre-defined method:
first: reverse painting
last: paint valid new on top of existing
min: pixel-wise min of existing and new
max: pixel-wise max of existing and new
or custom callable with signature:
def function(merged_data, new_data, merged_mask, new_mask, index=None, roff=None, coff=None):
Parameters
----------
merged_data : array_like
array to update with new_data
new_data : array_like
data to merge
same shape as merged_data
merged_mask, new_mask : array_like
boolean masks where merged/new data pixels are invalid
same shape as merged_data
index: int
index of the current dataset within the merged dataset collection
roff: int
row offset in base array
coff: int
column offset in base array
target_aligned_pixels : bool, optional
Whether to adjust output image bounds so that pixel coordinates
are integer multiples of pixel size, matching the ``-tap``
options of GDAL utilities. Default: False.
dst_path : str or PathLike, optional
Path of output dataset
dst_kwds : dict, optional
Dictionary of creation options and other paramters that will be
overlaid on the profile of the output dataset.
Returns
-------
tuple
Two elements:
dest: numpy ndarray
Contents of all input rasters in single array
out_transform: affine.Affine()
Information for mapping pixel coordinates in `dest` to another
coordinate system
"""
if method in MERGE_METHODS:
copyto = MERGE_METHODS[method]
elif callable(method):
copyto = method
else:
raise ValueError(
'Unknown method {0}, must be one of {1} or callable'.format(
method, list(MERGE_METHODS.keys())))
# Create a dataset_opener object to use in several places in this function.
if isinstance(datasets[0], (str, os.PathLike)):
dataset_opener = rasterio.open
else:
@contextmanager
def nullcontext(obj):
try:
yield obj
finally:
pass
dataset_opener = nullcontext
with dataset_opener(datasets[0]) as first:
first_profile = first.profile
first_res = first.res
nodataval = first.nodatavals[0]
dt = first.dtypes[0]
if indexes is None:
src_count = first.count
elif isinstance(indexes, int):
src_count = indexes
else:
src_count = len(indexes)
try:
first_colormap = first.colormap(1)
except ValueError:
first_colormap = None
if not output_count:
output_count = src_count
# Extent from option or extent of all inputs
if bounds:
dst_w, dst_s, dst_e, dst_n = bounds
else:
# scan input files
xs = []
ys = []
for dataset in datasets:
with dataset_opener(dataset) as src:
left, bottom, right, top = src.bounds
xs.extend([left, right])
ys.extend([bottom, top])
dst_w, dst_s, dst_e, dst_n = min(xs), min(ys), max(xs), max(ys)
# Resolution/pixel size
if not res:
res = first_res
elif not np.iterable(res):
res = (res, res)
elif len(res) == 1:
res = (res[0], res[0])
if target_aligned_pixels:
dst_w = math.floor(dst_w / res[0]) * res[0]
dst_e = math.ceil(dst_e / res[0]) * res[0]
dst_s = math.floor(dst_s / res[1]) * res[1]
dst_n = math.ceil(dst_n / res[1]) * res[1]
# Compute output array shape. We guarantee it will cover the output
# bounds completely
output_width = int(round((dst_e - dst_w) / res[0]))
output_height = int(round((dst_n - dst_s) / res[1]))
output_transform = Affine.translation(dst_w, dst_n) * Affine.scale(
res[0], -res[1])
if dtype is not None:
dt = dtype
logger.debug("Set dtype: %s", dt)
out_profile = first_profile
out_profile.update(**(dst_kwds or {}))
out_profile["transform"] = output_transform
out_profile["height"] = output_height
out_profile["width"] = output_width
out_profile["count"] = output_count
if nodata is not None:
out_profile["nodata"] = nodata
# create destination array
dest = np.zeros((output_count, output_height, output_width), dtype=dt)
if nodata is not None:
nodataval = nodata
logger.debug("Set nodataval: %r", nodataval)
if nodataval is not None:
# Only fill if the nodataval is within dtype's range
inrange = False
if np.issubdtype(dt, np.integer):
info = np.iinfo(dt)
inrange = (info.min <= nodataval <= info.max)
elif np.issubdtype(dt, np.floating):
if math.isnan(nodataval):
inrange = True
else:
info = np.finfo(dt)
inrange = (info.min <= nodataval <= info.max)
if inrange:
dest.fill(nodataval)
else:
warnings.warn(
"The nodata value, %s, is beyond the valid "
"range of the chosen data type, %s. Consider overriding it "
"using the --nodata option for better results." %
(nodataval, dt))
else:
nodataval = 0
for idx, dataset in enumerate(datasets):
with dataset_opener(dataset) as src:
# Real World (tm) use of boundless reads.
# This approach uses the maximum amount of memory to solve the
# problem. Making it more efficient is a TODO.
if disjoint_bounds((dst_w, dst_s, dst_e, dst_n), src.bounds):
logger.debug("Skipping source: src=%r, window=%r", src)
continue
# 1. Compute spatial intersection of destination and source
src_w, src_s, src_e, src_n = src.bounds
int_w = src_w if src_w > dst_w else dst_w
int_s = src_s if src_s > dst_s else dst_s
int_e = src_e if src_e < dst_e else dst_e
int_n = src_n if src_n < dst_n else dst_n
# 2. Compute the source window
src_window = windows.from_bounds(int_w,
int_s,
int_e,
int_n,
src.transform,
precision=precision)
# 3. Compute the destination window
dst_window = windows.from_bounds(int_w,
int_s,
int_e,
int_n,
output_transform,
precision=precision)
# 4. Read data in source window into temp
src_window_rnd_shp = src_window.round_shape(pixel_precision=0)
dst_window_rnd_shp = dst_window.round_shape(pixel_precision=0)
dst_window_rnd_off = dst_window_rnd_shp.round_offsets(
pixel_precision=0)
temp_height, temp_width = (
dst_window_rnd_off.height,
dst_window_rnd_off.width,
)
temp_shape = (src_count, temp_height, temp_width)
temp_src = src.read(
out_shape=temp_shape,
window=src_window_rnd_shp,
boundless=False,
masked=True,
indexes=indexes,
resampling=resampling,
)
# 5. Copy elements of temp into dest
roff, coff = (
max(0, dst_window_rnd_off.row_off),
max(0, dst_window_rnd_off.col_off),
)
region = dest[:, roff:roff + temp_height, coff:coff + temp_width]
if math.isnan(nodataval):
region_mask = np.isnan(region)
elif np.issubdtype(region.dtype, np.floating):
region_mask = np.isclose(region, nodataval)
else:
region_mask = region == nodataval
# Ensure common shape, resolving issue #2202.
temp = temp_src[:, :region.shape[1], :region.shape[2]]
temp_mask = np.ma.getmask(temp)
copyto(region,
temp,
region_mask,
temp_mask,
index=idx,
roff=roff,
coff=coff)
if dst_path is None:
return dest, output_transform
else:
with rasterio.open(dst_path, "w", **out_profile) as dst:
dst.write(dest)
if first_colormap:
dst.write_colormap(1, first_colormap)
def test_disjoint_bounds_issue1459_south_up():
a = BoundingBox(left=0.0, bottom=1.0, right=1.0, top=0.0)
b = BoundingBox(left=0.0, bottom=2.0, right=1.0, top=1.01)
assert disjoint_bounds(a, b)
def test_disjoint_bounds_issue1459():
a = BoundingBox(left=478038, bottom=57155, right=703888, top=266344)
b = BoundingBox(left=584184, bottom=469629, right=740727, top=626172)
assert disjoint_bounds(a, b)
def clip(ctx, files, output, bounds, like, driver, projection,
creation_options):
"""Clips a raster using projected or geographic bounds.
\b
$ rio clip input.tif output.tif --bounds xmin ymin xmax ymax
$ rio clip input.tif output.tif --like template.tif
The values of --bounds are presumed to be from the coordinate
reference system of the input dataset unless the --geographic option
is used, in which case the values may be longitude and latitude
bounds. Either JSON, for example "[west, south, east, north]", or
plain text "west south east north" representations of a bounding box
are acceptable.
If using --like, bounds will automatically be transformed to match the
coordinate reference system of the input.
It can also be combined to read bounds of a feature dataset using Fiona:
\b
$ rio clip input.tif output.tif --bounds $(fio info features.shp --bounds)
"""
from rasterio.warp import transform_bounds
with ctx.obj['env']:
output, files = resolve_inout(files=files, output=output)
input = files[0]
with rasterio.open(input) as src:
if bounds:
if projection == 'geographic':
bounds = transform_bounds('epsg:4326', src.crs, *bounds)
if disjoint_bounds(bounds, src.bounds):
raise click.BadParameter(
'must overlap the extent of '
'the input raster',
param='--bounds',
param_hint='--bounds')
elif like:
with rasterio.open(like) as template_ds:
bounds = template_ds.bounds
if template_ds.crs != src.crs:
bounds = transform_bounds(template_ds.crs, src.crs,
*bounds)
if disjoint_bounds(bounds, src.bounds):
raise click.BadParameter(
'must overlap the extent of '
'the input raster',
param='--like',
param_hint='--like')
else:
raise click.UsageError('--bounds or --like required')
window = src.window(*bounds)
out_kwargs = src.meta.copy()
out_kwargs.update({
'driver': driver,
'height': window[0][1] - window[0][0],
'width': window[1][1] - window[1][0],
'transform': src.window_transform(window)
})
out_kwargs.update(**creation_options)
with rasterio.open(output, 'w', **out_kwargs) as out:
out.write(src.read(window=window))
def clip(ctx, files, output, bounds, like, driver, projection,
creation_options):
"""Clips a raster using projected or geographic bounds.
\b
$ rio clip input.tif output.tif --bounds xmin ymin xmax ymax
$ rio clip input.tif output.tif --like template.tif
The values of --bounds are presumed to be from the coordinate
reference system of the input dataset unless the --geographic option
is used, in which case the values may be longitude and latitude
bounds. Either JSON, for example "[west, south, east, north]", or
plain text "west south east north" representations of a bounding box
are acceptable.
If using --like, bounds will automatically be transformed to match the
coordinate reference system of the input.
It can also be combined to read bounds of a feature dataset using Fiona:
\b
$ rio clip input.tif output.tif --bounds $(fio info features.shp --bounds)
"""
from rasterio.warp import transform_bounds
with ctx.obj['env']:
output, files = resolve_inout(files=files, output=output)
input = files[0]
with rasterio.open(input) as src:
if bounds:
if projection == 'geographic':
bounds = transform_bounds('epsg:4326', src.crs, *bounds)
if disjoint_bounds(bounds, src.bounds):
raise click.BadParameter('must overlap the extent of '
'the input raster',
param='--bounds',
param_hint='--bounds')
elif like:
with rasterio.open(like) as template_ds:
bounds = template_ds.bounds
if template_ds.crs != src.crs:
bounds = transform_bounds(template_ds.crs, src.crs,
*bounds)
if disjoint_bounds(bounds, src.bounds):
raise click.BadParameter('must overlap the extent of '
'the input raster',
param='--like',
param_hint='--like')
else:
raise click.UsageError('--bounds or --like required')
bounds_window = src.window(*bounds)
bounds_window = bounds_window.intersection(
Window(0, 0, src.width, src.height))
# Get the window with integer height
# and width that contains the bounds window.
out_window = bounds_window.round_lengths(op='ceil')
height = int(out_window.height)
width = int(out_window.width)
out_kwargs = src.meta.copy()
out_kwargs.update({
'driver': driver,
'height': height,
'width': width,
'transform': src.window_transform(out_window)})
out_kwargs.update(**creation_options)
with rasterio.open(output, 'w', **out_kwargs) as out:
out.write(src.read(window=out_window,
out_shape=(src.count, height, width)))
def rasterize(
ctx,
files,
output,
driver,
like,
bounds,
dimensions,
res,
src_crs,
all_touched,
default_value,
fill,
property,
creation_options):
"""Rasterize GeoJSON into a new or existing raster.
If the output raster exists, rio-rasterize will rasterize feature values
into all bands of that raster. The GeoJSON is assumed to be in the same
coordinate reference system as the output unless --src-crs is provided.
--default_value or property values when using --property must be using a
data type valid for the data type of that raster.
If a template raster is provided using the --like option, the affine
transform and data type from that raster will be used to create the output.
Only a single band will be output.
The GeoJSON is assumed to be in the same coordinate reference system unless
--src-crs is provided.
--default_value or property values when using --property must be using a
data type valid for the data type of that raster.
--driver, --bounds, --dimensions, and --res are ignored when output exists
or --like raster is provided
If the output does not exist and --like raster is not provided, the input
GeoJSON will be used to determine the bounds of the output unless
provided using --bounds.
--dimensions or --res are required in this case.
If --res is provided, the bottom and right coordinates of bounds are
ignored.
Note:
The GeoJSON is not projected to match the coordinate reference system
of the output or --like rasters at this time. This functionality may be
added in the future.
"""
from rasterio._base import is_geographic_crs, is_same_crs
from rasterio.features import rasterize
from rasterio.features import bounds as calculate_bounds
verbosity = (ctx.obj and ctx.obj.get('verbosity')) or 1
output, files = resolve_inout(files=files, output=output)
has_src_crs = src_crs is not None
src_crs = src_crs or 'EPSG:4326'
# If values are actually meant to be integers, we need to cast them
# as such or rasterize creates floating point outputs
if default_value == int(default_value):
default_value = int(default_value)
if fill == int(fill):
fill = int(fill)
with rasterio.drivers(CPL_DEBUG=verbosity > 2):
def feature_value(feature):
if property and 'properties' in feature:
return feature['properties'].get(property, default_value)
return default_value
with click.open_file(files.pop(0) if files else '-') as gj_f:
geojson = json.loads(gj_f.read())
if 'features' in geojson:
geometries = []
for f in geojson['features']:
geometries.append((f['geometry'], feature_value(f)))
elif 'geometry' in geojson:
geometries = ((geojson['geometry'], feature_value(geojson)), )
else:
raise click.BadParameter('Invalid GeoJSON', param=input,
param_hint='input')
geojson_bounds = geojson.get('bbox', calculate_bounds(geojson))
if os.path.exists(output):
with rasterio.open(output, 'r+') as out:
if has_src_crs and not is_same_crs(src_crs, out.crs):
raise click.BadParameter('GeoJSON does not match crs of '
'existing output raster',
param='input', param_hint='input')
if disjoint_bounds(geojson_bounds, out.bounds):
click.echo("GeoJSON outside bounds of existing output "
"raster. Are they in different coordinate "
"reference systems?",
err=True)
meta = out.meta.copy()
result = rasterize(
geometries,
out_shape=(meta['height'], meta['width']),
transform=meta.get('affine', meta['transform']),
all_touched=all_touched,
dtype=meta.get('dtype', None),
default_value=default_value,
fill = fill)
for bidx in range(1, meta['count'] + 1):
data = out.read(bidx, masked=True)
# Burn in any non-fill pixels, and update mask accordingly
ne = result != fill
data[ne] = result[ne]
data.mask[ne] = False
out.write_band(bidx, data)
else:
if like is not None:
template_ds = rasterio.open(like)
if has_src_crs and not is_same_crs(src_crs, template_ds.crs):
raise click.BadParameter('GeoJSON does not match crs of '
'--like raster',
param='input', param_hint='input')
if disjoint_bounds(geojson_bounds, template_ds.bounds):
click.echo("GeoJSON outside bounds of --like raster. "
"Are they in different coordinate reference "
"systems?",
err=True)
kwargs = template_ds.meta.copy()
kwargs['count'] = 1
# DEPRECATED
# upgrade transform to affine object or we may get an invalid
# transform set on output
kwargs['transform'] = template_ds.affine
template_ds.close()
else:
bounds = bounds or geojson_bounds
if is_geographic_crs(src_crs):
if (bounds[0] < -180 or bounds[2] > 180 or
bounds[1] < -80 or bounds[3] > 80):
raise click.BadParameter(
"Bounds are beyond the valid extent for "
"EPSG:4326.",
ctx, param=bounds, param_hint='--bounds')
if dimensions:
width, height = dimensions
res = (
(bounds[2] - bounds[0]) / float(width),
(bounds[3] - bounds[1]) / float(height)
)
else:
if not res:
raise click.BadParameter(
'pixel dimensions are required',
ctx, param=res, param_hint='--res')
elif len(res) == 1:
res = (res[0], res[0])
width = max(int(ceil((bounds[2] - bounds[0]) /
float(res[0]))), 1)
height = max(int(ceil((bounds[3] - bounds[1]) /
float(res[1]))), 1)
src_crs = src_crs.upper()
if not src_crs.count('EPSG:'):
raise click.BadParameter(
'invalid CRS. Must be an EPSG code.',
ctx, param=src_crs, param_hint='--src_crs')
kwargs = {
'count': 1,
'crs': src_crs,
'width': width,
'height': height,
'transform': Affine(res[0], 0, bounds[0], 0, -res[1],
bounds[3]),
'driver': driver
}
kwargs.update(**creation_options)
result = rasterize(
geometries,
out_shape=(kwargs['height'], kwargs['width']),
transform=kwargs.get('affine', kwargs['transform']),
all_touched=all_touched,
dtype=kwargs.get('dtype', None),
default_value=default_value,
fill = fill)
if 'dtype' not in kwargs:
kwargs['dtype'] = result.dtype
kwargs['nodata'] = fill
with rasterio.open(output, 'w', **kwargs) as out:
out.write_band(1, result)
def mask(
ctx,
files,
output,
geojson_mask,
driver,
all_touched,
crop,
invert,
creation_options):
"""Masks in raster using GeoJSON features (masks out all areas not covered
by features), and optionally crops the output raster to the extent of the
features. Features are assumed to be in the same coordinate reference
system as the input raster.
GeoJSON must be the first input file or provided from stdin:
> rio mask input.tif output.tif --geojson-mask features.json
> rio mask input.tif output.tif --geojson-mask - < features.json
If the output raster exists, it will be completely overwritten with the
results of this operation.
The result is always equal to or within the bounds of the input raster.
--crop and --invert options are mutually exclusive.
--crop option is not valid if features are completely outside extent of
input raster.
"""
from rasterio.features import geometry_mask
from rasterio.features import bounds as calculate_bounds
verbosity = (ctx.obj and ctx.obj.get('verbosity')) or 1
output, files = resolve_inout(files=files, output=output)
input = files[0]
if geojson_mask is None:
click.echo('No GeoJSON provided, INPUT will be copied to OUTPUT',
err=True)
shutil.copy(input, output)
return
if crop and invert:
click.echo('Invert option ignored when using --crop', err=True)
invert = False
with rasterio.drivers(CPL_DEBUG=verbosity > 2):
try:
with click.open_file(geojson_mask) as f:
geojson = json.loads(f.read())
except ValueError:
raise click.BadParameter('GeoJSON could not be read from '
'--geojson-mask or stdin',
param_hint='--geojson-mask')
if 'features' in geojson:
geometries = (f['geometry'] for f in geojson['features'])
elif 'geometry' in geojson:
geometries = (geojson['geometry'], )
else:
raise click.BadParameter('Invalid GeoJSON', param=input,
param_hint='input')
bounds = geojson.get('bbox', calculate_bounds(geojson))
with rasterio.open(input) as src:
# If y pixel value is positive, then invert y dimension in bounds
invert_y = src.affine.e > 0
src_bounds = src.bounds
if invert_y:
src_bounds = [src.bounds[0], src.bounds[3],
src.bounds[2], src.bounds[1]]
has_disjoint_bounds = disjoint_bounds(bounds, src_bounds)
if crop:
if has_disjoint_bounds:
raise click.BadParameter('not allowed for GeoJSON outside '
'the extent of the input raster',
param=crop, param_hint='--crop')
if invert_y:
bounds = (bounds[0], bounds[3], bounds[2], bounds[1])
window = src.window(*bounds)
transform = src.window_transform(window)
(r1, r2), (c1, c2) = window
mask_shape = (r2 - r1, c2 - c1)
else:
if has_disjoint_bounds:
click.echo('GeoJSON outside bounds of existing output '
'raster. Are they in different coordinate '
'reference systems?',
err=True)
window = None
transform = src.affine
mask_shape = src.shape
mask = geometry_mask(
geometries,
out_shape=mask_shape,
transform=transform,
all_touched=all_touched,
invert=invert)
meta = src.meta.copy()
meta.update(**creation_options)
meta.update({
'driver': driver,
'height': mask.shape[0],
'width': mask.shape[1],
'transform': transform
})
with rasterio.open(output, 'w', **meta) as out:
for bidx in range(1, src.count + 1):
img = src.read(bidx, masked=True, window=window)
img.mask = img.mask | mask
out.write_band(bidx, img.filled(src.nodatavals[bidx-1]))
def clip(
ctx,
files,
output,
bounds,
like,
driver,
creation_options):
"""Clips a raster using bounds input directly or from a template raster.
\b
$ rio clip input.tif output.tif --bounds xmin ymin xmax ymax
$ rio clip input.tif output.tif --like template.tif
If using --bounds, values must be in coordinate reference system of input.
If using --like, bounds will automatically be transformed to match the
coordinate reference system of the input.
It can also be combined to read bounds of a feature dataset using Fiona:
\b
$ rio clip input.tif output.tif --bounds $(fio info features.shp --bounds)
"""
from rasterio.warp import transform_bounds
verbosity = (ctx.obj and ctx.obj.get('verbosity')) or 1
with rasterio.drivers(CPL_DEBUG=verbosity > 2):
output, files = resolve_inout(files=files, output=output)
input = files[0]
with rasterio.open(input) as src:
if bounds:
if disjoint_bounds(bounds, src.bounds):
raise click.BadParameter('must overlap the extent of '
'the input raster',
param='--bounds',
param_hint='--bounds')
elif like:
with rasterio.open(like) as template_ds:
bounds = template_ds.bounds
if template_ds.crs != src.crs:
bounds = transform_bounds(template_ds.crs, src.crs,
*bounds)
if disjoint_bounds(bounds, src.bounds):
raise click.BadParameter('must overlap the extent of '
'the input raster',
param='--like',
param_hint='--like')
else:
raise click.UsageError('--bounds or --like required')
window = src.window(*bounds)
out_kwargs = src.meta.copy()
out_kwargs.update({
'driver': driver,
'height': window[0][1] - window[0][0],
'width': window[1][1] - window[1][0],
'transform': src.window_transform(window)
})
out_kwargs.update(**creation_options)
with rasterio.open(output, 'w', **out_kwargs) as out:
out.write(src.read(window=window))
def clip(ctx, files, output, bounds, like, driver, creation_options):
"""Clips a raster using bounds input directly or from a template raster.
\b
$ rio clip input.tif output.tif --bounds xmin ymin xmax ymax
$ rio clip input.tif output.tif --like template.tif
If using --bounds, values must be in coordinate reference system of input.
If using --like, bounds will automatically be transformed to match the
coordinate reference system of the input.
It can also be combined to read bounds of a feature dataset using Fiona:
\b
$ rio clip input.tif output.tif --bounds $(fio info features.shp --bounds)
"""
from rasterio.warp import transform_bounds
verbosity = (ctx.obj and ctx.obj.get('verbosity')) or 1
with rasterio.drivers(CPL_DEBUG=verbosity > 2):
output, files = resolve_inout(files=files, output=output)
input = files[0]
with rasterio.open(input) as src:
if bounds:
if disjoint_bounds(bounds, src.bounds):
raise click.BadParameter(
'must overlap the extent of '
'the input raster',
param='--bounds',
param_hint='--bounds')
elif like:
with rasterio.open(like) as template_ds:
bounds = template_ds.bounds
if template_ds.crs != src.crs:
bounds = transform_bounds(template_ds.crs, src.crs,
*bounds)
if disjoint_bounds(bounds, src.bounds):
raise click.BadParameter(
'must overlap the extent of '
'the input raster',
param='--like',
param_hint='--like')
else:
raise click.UsageError('--bounds or --like required')
window = src.window(*bounds)
out_kwargs = src.meta.copy()
out_kwargs.update({
'driver': driver,
'height': window[0][1] - window[0][0],
'width': window[1][1] - window[1][0],
'transform': src.window_transform(window)
})
out_kwargs.update(**creation_options)
with rasterio.open(output, 'w', **out_kwargs) as out:
out.write(src.read(window=window))
def mask(ctx, files, output, geojson_mask, driver, all_touched, crop, invert,
force_overwrite, creation_options):
"""Masks in raster using GeoJSON features (masks out all areas not covered
by features), and optionally crops the output raster to the extent of the
features. Features are assumed to be in the same coordinate reference
system as the input raster.
GeoJSON must be the first input file or provided from stdin:
> rio mask input.tif output.tif --geojson-mask features.json
> rio mask input.tif output.tif --geojson-mask - < features.json
If the output raster exists, it will be completely overwritten with the
results of this operation.
The result is always equal to or within the bounds of the input raster.
--crop and --invert options are mutually exclusive.
--crop option is not valid if features are completely outside extent of
input raster.
"""
from rasterio.features import geometry_mask
from rasterio.features import bounds as calculate_bounds
verbosity = (ctx.obj and ctx.obj.get('verbosity')) or 1
output, files = resolve_inout(files=files,
output=output,
force_overwrite=force_overwrite)
input = files[0]
if geojson_mask is None:
click.echo('No GeoJSON provided, INPUT will be copied to OUTPUT',
err=True)
shutil.copy(input, output)
return
if crop and invert:
click.echo('Invert option ignored when using --crop', err=True)
invert = False
with rasterio.drivers(CPL_DEBUG=verbosity > 2):
try:
with click.open_file(geojson_mask) as f:
geojson = json.loads(f.read())
except ValueError:
raise click.BadParameter(
'GeoJSON could not be read from '
'--geojson-mask or stdin',
param_hint='--geojson-mask')
if 'features' in geojson:
geometries = (f['geometry'] for f in geojson['features'])
elif 'geometry' in geojson:
geometries = (geojson['geometry'], )
else:
raise click.BadParameter('Invalid GeoJSON',
param=input,
param_hint='input')
bounds = geojson.get('bbox', calculate_bounds(geojson))
with rasterio.open(input) as src:
# If y pixel value is positive, then invert y dimension in bounds
invert_y = src.affine.e > 0
src_bounds = src.bounds
if invert_y:
src_bounds = [
src.bounds[0], src.bounds[3], src.bounds[2], src.bounds[1]
]
has_disjoint_bounds = disjoint_bounds(bounds, src_bounds)
if crop:
if has_disjoint_bounds:
raise click.BadParameter(
'not allowed for GeoJSON outside '
'the extent of the input raster',
param=crop,
param_hint='--crop')
if invert_y:
bounds = (bounds[0], bounds[3], bounds[2], bounds[1])
window = src.window(*bounds)
transform = src.window_transform(window)
(r1, r2), (c1, c2) = window
mask_shape = (r2 - r1, c2 - c1)
else:
if has_disjoint_bounds:
click.echo(
'GeoJSON outside bounds of existing output '
'raster. Are they in different coordinate '
'reference systems?',
err=True)
window = None
transform = src.affine
mask_shape = src.shape
mask = geometry_mask(geometries,
out_shape=mask_shape,
transform=transform,
all_touched=all_touched,
invert=invert)
meta = src.meta.copy()
meta.update(**creation_options)
meta.update({
'driver': driver,
'height': mask.shape[0],
'width': mask.shape[1],
'transform': transform
})
with rasterio.open(output, 'w', **meta) as out:
for bidx in range(1, src.count + 1):
img = src.read(bidx, masked=True, window=window)
img.mask = img.mask | mask
out.write_band(bidx, img.filled(src.nodatavals[bidx - 1]))