rioxarray package 

Merge datasets geospatially.

Uses rasterio.merge.merge()

Added in version 0.2: crs

Parameters:

datasets (list[xarray.Dataset]) – List of multiple xarray.Dataset with all geo attributes. The first one is assumed to have the same CRS, dtype, dimensions, and data_vars as the others in the array.
bounds (tuple, optional) – Bounds of the output image (left, bottom, right, top). If not set, bounds are determined from bounds of input Dataset.
res (tuple, optional) – Output resolution in units of coordinate reference system. If not set, the resolution of the first Dataset 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 Dataset.
precision (float, optional) – Number of decimal points of precision when computing inverse transform.
method (str or callable, optional) – See rasterio docs.
crs (rasterio.crs.CRS, optional) – Output CRS. If not set, the CRS of the first DataArray is used.

Returns:

The geospatially merged data.

Return type:

https://rasterio.readthedocs.io/en/latest/topics/georeferencing.html#ground-control-points

rioxarray.set_options

class rioxarray.set_options(**kwargs)[source]

Set the global rioxarray option.

Added in version 0.3.0.

Added in version 0.7.0: skip_missing_spatial_dims

Parameters:

export_grid_mapping (bool, default=True) – If True, this option will export the full Climate and Forecasts (CF) grid mapping attributes for the CRS. This is useful if you are exporting your file to netCDF using xarray.Dataset.to_netcdf(). When disabled, only the crs_wkt and spatial_ref attributes will be written and the program will be faster due to not needing to use pyproj.CRS.to_cf().
skip_missing_spatial_dims (bool, default=False) – If True, it will not perform spatial operations on variables within a xarray.Dataset if the spatial dimensions are not found.

Usage as a context manager:

with rioxarray.set_options(export_grid_mapping=False):
    rds = rioxarray.open_rasterio(...)

Usage for global settings:

rioxarray.set_options(export_grid_mapping=False)

rioxarray.show_versions

rioxarray.show_versions() → None[source]

Added in version 0.0.26.

Print useful debugging information

Example

> python -c “import rioxarray; rioxarray.show_versions()”

rioxarray rio accessors

rioxarray extends xarray with the rio accessor. The rio accessor is activated by importing rioxarray like so:

import rioxarray

class rioxarray.rioxarray.XRasterBase(xarray_obj: DataArray | Dataset)[source]

Bases: object

This is the base class for the GIS extensions for xarray

bounds(*, recalc: bool = False) → tuple[float, float, float, float][source]

Parameters:: recalc (bool, optional) – Will force the bounds to be recalculated instead of using the transform attribute.
Returns:: left, bottom, right, top – Outermost coordinates of the xarray.DataArray | xarray.Dataset.
Return type:: float

property count: int

Returns the band count (z dimension size)

Type:: int

property crs: CRS | None: rasterio.crs.CRS: Retrieve projection from xarray.Dataset | xarray.DataArray

estimate_utm_crs(datum_name: str = 'WGS 84') → CRS[source]

Returns the estimated UTM CRS based on the bounds of the dataset.

Added in version 0.2.

Note

Requires pyproj 3+

Parameters:: datum_name (str, optional) – The name of the datum to use in the query. Default is WGS 84.
Return type:: rasterio.crs.CRS

get_gcps() → list[GroundControlPoint] | None[source]

Get the GroundControlPoints from the dataset.

Returns:: The Ground Control Points from the dataset or None if not applicable
Return type:: list of rasterio.control.GroundControlPoint or None

property grid_mapping: str

The CF grid_mapping attribute. ‘spatial_ref’ is the default.

Type:: str

property height: int

Returns the height of the dataset (y dimension size)

Type:: int

isel_window(window: Window, *, pad: bool = False) → Dataset | DataArray[source]

Use a rasterio.windows.Window to select a subset of the data.

Added in version 0.6.0: pad

Warning

Float indices are converted to integers.

Parameters:

window (rasterio.windows.Window) – The window of the dataset to read.
pad (bool, default=False) – Set to True to expand returned DataArray to dimensions of the window

Returns:

The data in the window.

Return type:

resolution(recalc: bool = False) → tuple[float, float][source]

Determine if the resolution of the grid. If the transformation has rotation, the sign of the resolution is lost.

Parameters:: recalc (bool, optional) – Will force the resolution to be recalculated instead of using the transform attribute.
Returns:: x_resolution, y_resolution – The resolution of the xarray.DataArray | xarray.Dataset
Return type:: float

set_attrs(new_attrs: dict, inplace: bool = False) → Dataset | DataArray[source]

Set the attributes of the dataset/dataarray and reset rioxarray properties to re-search for them.

Parameters:

new_attrs (dict) – A dictionary of new attributes.
inplace (bool, optional) – If True, it will write to the existing dataset. Default is False.

Returns:

Modified dataset with new attributes.

Return type:

set_crs(input_crs: Any, inplace: bool = True) → Dataset | DataArray[source]

Set the CRS value for the Dataset/DataArray without modifying the dataset/data array.

Deprecated since version 0.15.8: It is recommended to use rio.write_crs() instead. This

method will likely be removed in a future release.

Parameters:

input_crs (object) – Anything accepted by rasterio.crs.CRS.from_user_input.
inplace (bool, optional) – If True, it will write to the existing dataset. Default is False.

Returns:

Dataset with crs attribute.

Return type:

set_encoding(new_encoding: dict, inplace: bool = False) → Dataset | DataArray[source]

Set the encoding of the dataset/dataarray and reset rioxarray properties to re-search for them.

Added in version 0.4.

Parameters:

new_encoding (dict) – A dictionary for encoding.
inplace (bool, optional) – If True, it will write to the existing dataset. Default is False.

Returns:

Modified dataset with new attributes.

Return type:

set_spatial_dims(x_dim: str, y_dim: str, inplace: bool = True) → Dataset | DataArray[source]

This sets the spatial dimensions of the dataset.

Parameters:

x_dim (str) – The name of the x dimension.
y_dim (str) – The name of the y dimension.
inplace (bool, optional) – If True, it will modify the dataframe in place. Otherwise it will return a modified copy.

Returns:

Dataset with spatial dimensions set.

Return type:

property shape: tuple[int, int]

Returns the shape (height, width)

Type:: tuple(int, int)

slice_xy(minx: float, miny: float, maxx: float, maxy: float) → Dataset | DataArray[source]

Slice the array by x,y bounds.

Parameters:

minx (float) – Minimum bound for x coordinate.
miny (float) – Minimum bound for y coordinate.
maxx (float) – Maximum bound for x coordinate.
maxy (float) – Maximum bound for y coordinate.

Returns:

The data in the slice.

Return type:

transform(recalc: bool = False) → Affine[source]

Parameters:: recalc (bool, optional) – If True, it will re-calculate the transform instead of using the cached transform.
Returns:: The affine of the xarray.Dataset | xarray.DataArray
Return type:: affine.Affine

transform_bounds(dst_crs: Any, *, densify_pts: int = 21, recalc: bool = False) → tuple[float, float, float, float][source]

Transform bounds from src_crs to dst_crs.

Optionally densifying the edges (to account for nonlinear transformations along these edges) and extracting the outermost bounds.

Note: this does not account for the antimeridian.

Parameters:

dst_crs (str, rasterio.crs.CRS, or dict) – Target coordinate reference system.
densify_pts (uint, optional) – Number of points to add to each edge to account for nonlinear edges produced by the transform process. Large numbers will produce worse performance. Default: 21 (gdal default).
recalc (bool, optional) – Will force the bounds to be recalculated instead of using the transform attribute.

Returns:

left, bottom, right, top – Outermost coordinates in target coordinate reference system.

Return type:

float

update_attrs(new_attrs: dict, inplace: bool = False) → Dataset | DataArray[source]

Update the attributes of the dataset/dataarray and reset rioxarray properties to re-search for them.

Parameters:

new_attrs (dict) – A dictionary of new attributes to update with.
inplace (bool, optional) – If True, it will write to the existing dataset. Default is False.

Returns:

Modified dataset with updated attributes.

Return type:

update_encoding(new_encoding: dict, inplace: bool = False) → Dataset | DataArray[source]

Update the encoding of the dataset/dataarray and reset rioxarray properties to re-search for them.

Added in version 0.4.

Parameters:

new_encoding (dict) – A dictionary with encoding values to update with.
inplace (bool, optional) – If True, it will write to the existing dataset. Default is False.

Returns:

Modified dataset with updated attributes.

Return type:

property width: int

Returns the width of the dataset (x dimension size)

Type:: int

write_coordinate_system(inplace: bool = False) → Dataset | DataArray[source]

Write the coordinate system CF metadata.

Added in version 0.0.30.

Parameters:: inplace (bool, optional) – If True, it will write to the existing dataset. Default is False.
Returns:: The dataset with the CF coordinate system attributes added.
Return type:: xarray.Dataset | xarray.DataArray

write_crs(input_crs: Any | None = None, grid_mapping_name: str | None = None, inplace: bool = False) → Dataset | DataArray[source]

Write the CRS to the dataset in a CF compliant manner.

Warning

The grid_mapping attribute is written to the encoding.

Parameters:

input_crs (Any) – Anything accepted by rasterio.crs.CRS.from_user_input.
grid_mapping_name (str, optional) – Name of the grid_mapping coordinate to store the CRS information in. Default is the grid_mapping name of the dataset.
inplace (bool, optional) – If True, it will write to the existing dataset. Default is False.

Returns:

Modified dataset with CF compliant CRS information.

Return type:

https://rasterio.readthedocs.io/en/latest/topics/georeferencing.html#ground-control-points

Examples

Write the CRS of the current xarray object:

>>> raster.rio.write_crs("epsg:4326", inplace=True)

Write the CRS on a copy:

>>> raster = raster.rio.write_crs("epsg:4326")

write_gcps(gcps: Iterable[GroundControlPoint], gcp_crs: Any, *, grid_mapping_name: str | None = None, inplace: bool = False) → Dataset | DataArray[source]

Write the GroundControlPoints to the dataset.

Parameters:

gcp (list of rasterio.control.GroundControlPoint) – The Ground Control Points to integrate to the dataset.
gcp_crs (str, rasterio.crs.CRS, or dict) – Coordinate reference system for the GCPs.
grid_mapping_name (str, optional) – Name of the grid_mapping coordinate to store the GCPs information in. Default is the grid_mapping name of the dataset.
inplace (bool, optional) – If True, it will write to the existing dataset. Default is False.

Returns:

Modified dataset with Ground Control Points written.

Return type:

write_grid_mapping(grid_mapping_name: str = 'spatial_ref', inplace: bool = False) → Dataset | DataArray[source]

Write the CF grid_mapping attribute to the encoding.

Parameters:

grid_mapping_name (str, optional) – Name of the grid_mapping coordinate.
inplace (bool, optional) – If True, it will write to the existing dataset. Default is False.

Returns:

Modified dataset with CF compliant CRS information.

Return type:

https://gdal.org/drivers/raster/netcdf.html#georeference

write_transform(transform: Affine | None = None, grid_mapping_name: str | None = None, inplace: bool = False) → Dataset | DataArray[source]

Added in version 0.0.30.

Write the GeoTransform to the dataset where GDAL can read it in.

Parameters:

transform (affine.Affine, optional) – The transform of the dataset. If not provided, it will be calculated.
grid_mapping_name (str, optional) – Name of the grid_mapping coordinate to store the transform information in. Default is the grid_mapping name of the dataset.
inplace (bool, optional) – If True, it will write to the existing dataset. Default is False.

Returns:

Modified dataset with Geo Transform written.

Return type:

property x_dim: Hashable

The dimension for the X-axis.

Type:: Hashable

property y_dim: Hashable

The dimension for the Y-axis.

Type:: Hashable

class rioxarray.raster_array.RasterArray(xarray_obj: DataArray)[source]

Bases: XRasterBase

This is the GIS extension for xarray.DataArray

clip(geometries: Iterable, crs: Any | None = None, *, all_touched: bool = False, drop: bool = True, invert: bool = False, from_disk: bool = False) → DataArray[source]

Crops a xarray.DataArray by geojson like geometry dicts.

Powered by rasterio.features.geometry_mask.

Examples

>>> geometry = ''' {"type": "Polygon",
...                 "coordinates": [
...                 [[-94.07955380199459, 41.69085871273774],
...                 [-94.06082436942204, 41.69103313774798],
...                 [-94.06063203899649, 41.67932439500822],
...                 [-94.07935807746362, 41.679150041277325],
...                 [-94.07955380199459, 41.69085871273774]]]}'''
>>> cropping_geometries = [geojson.loads(geometry)]
>>> xds = xarray.open_rasterio('cool_raster.tif')
>>> cropped = xds.rio.clip(geometries=cropping_geometries, crs=4326)

Added in version 0.2: from_disk

Parameters:

geometries (Iterable) – A list of geojson geometry dicts or objects with __geo_interface__ with if you have rasterio 1.2+.
crs (rasterio.crs.CRS, optional) – The CRS of the input geometries. Default is to assume it is the same as the dataset.
all_touched (bool, optional) – If True, all pixels touched by geometries will be burned in. If false, only pixels whose center is within the polygon or that are selected by Bresenham’s line algorithm will be burned in.
drop (bool, optional) – If True, drop the data outside of the extent of the mask geometries Otherwise, it will return the same raster with the data masked. Default is True.
invert (boolean, optional) – If False, pixels that do not overlap shapes will be set as nodata. Otherwise, pixels that overlap the shapes will be set as nodata. False by default.
from_disk (boolean, optional) – If True, it will clip from disk using rasterio.mask.mask if possible. This is beneficial when the size of the data is larger than memory. Default is False.

Returns:

The clipped object.

Return type:

clip_box(minx: float, miny: float, maxx: float, maxy: float, *, auto_expand: bool | int = False, auto_expand_limit: int = 3, crs: Any | None = None, allow_one_dimensional_raster: bool = False) → DataArray[source]

Clip the xarray.DataArray by a bounding box.

Added in version 0.12: crs

Added in version 0.16: allow_one_dimensional_raster

Parameters:

minx (float) – Minimum bound for x coordinate.
miny (float) – Minimum bound for y coordinate.
maxx (float) – Maximum bound for x coordinate.
maxy (float) – Maximum bound for y coordinate.
auto_expand (Union[bool, int]) – If True, it will expand clip search if only 1D raster found with clip.
auto_expand_limit (int) – maximum number of times the clip will be retried before raising an exception.
crs (rasterio.crs.CRS, optional) – The CRS of the bounding box. Default is to assume it is the same as the dataset.
allow_one_dimensional_raster (bool, optional) – If True, allow clipping to/from a one dimensional raster.

Returns:

The clipped object.

Return type:

xarray.DataArray

property encoded_nodata: float | None: Return the encoded nodata value for the dataset if encoded.

interpolate_na(method: Literal['linear', 'nearest', 'cubic'] = 'nearest') → DataArray[source]

This method uses scipy.interpolate.griddata to interpolate missing data.

Warning

scipy is an optional dependency.

Parameters:: method ({'linear', 'nearest', 'cubic'}, optional) – The method to use for interpolation in scipy.interpolate.griddata.
Returns:: An interpolated xarray.DataArray object.
Return type:: xarray.DataArray

property nodata: float | None: Get the nodata value for the dataset.

pad_box(minx: float, miny: float, maxx: float, maxy: float, *, constant_values: float | tuple[int, int] | Mapping[Any, tuple[int, int]] | None = None) → DataArray[source]

Pad the xarray.DataArray to a bounding box

Added in version 0.0.29.

Parameters:

minx (float) – Minimum bound for x coordinate.
miny (float) – Minimum bound for y coordinate.
maxx (float) – Maximum bound for x coordinate.
maxy (float) – Maximum bound for y coordinate.
constant_values (scalar, tuple or mapping of hashable to tuple) – The value used for padding. If None, nodata will be used if it is set, and numpy.nan otherwise.

Returns:

The padded object.

Return type:

pad_xy(minx: float, miny: float, maxx: float, maxy: float, *, constant_values: float | tuple[int, int] | Mapping[Any, tuple[int, int]] | None = None) → DataArray[source]

Pad the array to x,y bounds.

Added in version 0.0.29.

Parameters:

minx (float) – Minimum bound for x coordinate.
miny (float) – Minimum bound for y coordinate.
maxx (float) – Maximum bound for x coordinate.
maxy (float) – Maximum bound for y coordinate.
constant_values (scalar, tuple or mapping of hashable to tuple) – The value used for padding. If None, nodata will be used if it is set, and numpy.nan otherwise.

Returns:

The padded object.

Return type:

reproject(dst_crs: Any, *, resolution: float | tuple[float, float] | None = None, shape: tuple[int, int] | None = None, transform: Affine | None = None, resampling: Resampling = Resampling.nearest, nodata: float | None = None, **kwargs) → DataArray[source]

Reproject xarray.DataArray objects

Powered by rasterio.warp.reproject()

Note

Only 2D/3D arrays with dimensions ‘x’/’y’ are currently supported. Requires either a grid mapping variable with ‘spatial_ref’ or a ‘crs’ attribute to be set containing a valid CRS. If using a WKT (e.g. from spatiareference.org), make sure it is an OGC WKT.

Note

To re-project with dask, see odc-geo & pyresample.

Added in version 0.0.27: shape

Added in version 0.0.28: transform

Added in version 0.5.0: nodata, kwargs

Parameters:

dst_crs (str) – OGC WKT string or Proj.4 string.
resolution (float or tuple(float, float), optional) – Size of a destination pixel in destination projection units (e.g. degrees or metres).
shape (tuple(int, int), optional) – Shape of the destination in pixels (dst_height, dst_width). Cannot be used together with resolution.
transform (Affine, optional) – The destination transform.
resampling (rasterio.enums.Resampling, optional) – See rasterio.warp.reproject() for more details.
nodata (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 source image if none provided and exists or attempts to find an appropriate value by dtype.
**kwargs (dict) – Additional keyword arguments to pass into rasterio.warp.reproject(). To override: - src_transform: rio.write_transform - src_crs: rio.write_crs - src_nodata: rio.write_nodata

Returns:

The reprojected DataArray.

Return type:

reproject_match(match_data_array: DataArray | Dataset, *, resampling: Resampling = Resampling.nearest, **reproject_kwargs) → DataArray[source]

Reproject a DataArray object to match the resolution, projection, and region of another DataArray.

Powered by rasterio.warp.reproject()

Note

Only 2D/3D arrays with dimensions ‘x’/’y’ are currently supported. Requires either a grid mapping variable with ‘spatial_ref’ or a ‘crs’ attribute to be set containing a valid CRS. If using a WKT (e.g. from spatiareference.org), make sure it is an OGC WKT.

Added in version 0.9: reproject_kwargs

Parameters:

match_data_array (xarray.DataArray | xarray.Dataset) – DataArray of the target resolution and projection.
resampling (rasterio.enums.Resampling, optional) – See rasterio.warp.reproject() for more details.
**reproject_kwargs – Other options to pass to rioxarray.raster_array.RasterArray.reproject()

Returns:

Contains the data from the src_data_array, reprojected to match match_data_array.

Return type:

set_nodata(input_nodata: float | None, *, inplace: bool = True) → DataArray[source]

Set the nodata value for the DataArray without modifying the data array.

Parameters:

input_nodata (Optional[float]) – Valid nodata for dtype.
inplace (bool, optional) – If True, it will write to the existing dataset. Default is True.

Returns:

Dataset with nodata attribute set.

Return type:

Export the DataArray to a raster file.

..versionadded:: 0.2 lock

Parameters:

raster_path (Union[str, os.PathLike]) – The path to output the raster to.
driver (str, optional) – The name of the GDAL/rasterio driver to use to export the raster. Default is “GTiff” if rasterio < 1.2 otherwise it will autodetect.
dtype (str, optional) – The data type to write the raster to. Default is the datasets dtype.
tags (dict, optional) – A dictionary of tags to write to the raster.
windowed (bool, optional) – If True, it will write using the windows of the output raster. This is useful for loading data in chunks when writing. Does not do anything when writing with dask. Default is False.
recalc_transform (bool, optional) – If False, it will write the raster with the cached transform from the dataarray rather than recalculating it. Default is True.
lock (boolean or Lock, optional) – Lock to use to write data using dask. If not supplied, it will use a single process for writing.
compute (bool, optional) – If True and data is a dask array, then compute and save the data immediately. If False, return a dask Delayed object. Call “.compute()” on the Delayed object to compute the result later. Call dask.compute(delayed1, delayed2) to save multiple delayed files at once. Default is True.
**profile_kwargs – Additional keyword arguments to pass into writing the raster. The nodata, transform, crs, count, width, and height attributes are ignored.

Returns:

If the data array is a dask array and compute is True. Otherwise None is returned.

Return type:

dask.Delayed

write_nodata(input_nodata: float | None, *, encoded: bool = False, inplace=False) → DataArray[source]

Write the nodata to the DataArray in a CF compliant manner.

Parameters:

input_nodata (Optional[float]) – Nodata value for the DataArray. If input_nodata is None, it will remove the _FillValue attribute.
encoded (bool, optional) – If True, it will write the nodata value in the encoding and remove the fill value from the attributes. This is useful for masking with nodata. Default is False.
inplace (bool, optional) – If True, it will write to the existing DataArray. Default is False.

Returns:

Modified DataArray with CF compliant nodata information.

Return type:

Examples

To write the nodata value if it is missing:

>>> raster.rio.write_nodata(-9999, inplace=True)

To write the nodata value on a copy:

>>> raster = raster.rio.write_nodata(-9999)

To mask with nodata:

>>> nodata = raster.rio.nodata
>>> raster = raster.where(raster != nodata)
>>> raster.rio.write_nodata(nodata, encoded=True, inplace=True)

class rioxarray.raster_dataset.RasterDataset(xarray_obj: DataArray | Dataset)[source]

Bases: XRasterBase

This is the GIS extension for xarray.Dataset

clip(geometries: Iterable, crs: Any | None = None, *, all_touched: bool = False, drop: bool = True, invert: bool = False, from_disk: bool = False) → Dataset[source]

Crops a xarray.Dataset by geojson like geometry dicts in dimensions ‘x’/’y’.

Warning

Clips variables that have dimensions ‘x’/’y’. Others are appended as is.

Powered by rasterio.features.geometry_mask.

Examples

>>> geometry = ''' {"type": "Polygon",
...                 "coordinates": [
...                 [[-94.07955380199459, 41.69085871273774],
...                 [-94.06082436942204, 41.69103313774798],
...                 [-94.06063203899649, 41.67932439500822],
...                 [-94.07935807746362, 41.679150041277325],
...                 [-94.07955380199459, 41.69085871273774]]]}'''
>>> cropping_geometries = [geojson.loads(geometry)]
>>> xds = xarray.open_rasterio('cool_raster.tif')
>>> cropped = xds.rio.clip(geometries=cropping_geometries, crs=4326)

Added in version 0.2: from_disk

Parameters:

geometries (list) – A list of geojson geometry dicts.
crs (rasterio.crs.CRS, optional) – The CRS of the input geometries. Default is to assume it is the same as the dataset.
all_touched (boolean, optional) – If True, all pixels touched by geometries will be burned in. If false, only pixels whose center is within the polygon or that are selected by Bresenham’s line algorithm will be burned in.
drop (bool, optional) – If True, drop the data outside of the extent of the mask geometries Otherwise, it will return the same raster with the data masked. Default is True.
invert (boolean, optional) – If False, pixels that do not overlap shapes will be set as nodata. Otherwise, pixels that overlap the shapes will be set as nodata. False by default.
from_disk (boolean, optional) – If True, it will clip from disk using rasterio.mask.mask if possible. This is beneficial when the size of the data is larger than memory. Default is False.

Returns:

The clipped object.

Return type:

clip_box(minx: float, miny: float, maxx: float, maxy: float, *, auto_expand: bool | int = False, auto_expand_limit: int = 3, crs: Any | None = None, allow_one_dimensional_raster: bool = False) → Dataset[source]

Clip the xarray.Dataset by a bounding box in dimensions ‘x’/’y’.

Warning

Clips variables that have dimensions ‘x’/’y’. Others are appended as is.

Added in version 0.12: crs

Added in version 0.16: allow_one_dimensional_raster

Parameters:

minx (float) – Minimum bound for x coordinate.
miny (float) – Minimum bound for y coordinate.
maxx (float) – Maximum bound for x coordinate.
maxy (float) – Maximum bound for y coordinate.
auto_expand (bool) – If True, it will expand clip search if only 1D raster found with clip.
auto_expand_limit (int) – maximum number of times the clip will be retried before raising an exception.
crs (rasterio.crs.CRS, optional) – The CRS of the bounding box. Default is to assume it is the same as the dataset.
allow_one_dimensional_raster (bool, optional) – If True, allow clipping to/from a one dimensional raster.

Returns:

The clipped object.

Return type:

Dataset

property crs: CRS | None: rasterio.crs.CRS: Retrieve projection from xarray.Dataset

interpolate_na(method: Literal['linear', 'nearest', 'cubic'] = 'nearest') → Dataset[source]

This method uses scipy.interpolate.griddata to interpolate missing data.

Warning

scipy is an optional dependency.

Warning

Interpolates variables that have dimensions ‘x’/’y’. Others are appended as is.

Parameters:: method ({'linear', 'nearest', 'cubic'}, optional) – The method to use for interpolation in scipy.interpolate.griddata.
Returns:: The interpolated object.
Return type:: xarray.DataArray

pad_box(minx: float, miny: float, maxx: float, maxy: float, *, constant_values: float | tuple[int, int] | Mapping[Any, tuple[int, int]] | None = None) → Dataset[source]

Pad the xarray.Dataset to a bounding box.

Warning

Only works if all variables in the dataset have the same coordinates.

Warning

Pads variables that have dimensions ‘x’/’y’. Others are appended as is.

Parameters:

minx (float) – Minimum bound for x coordinate.
miny (float) – Minimum bound for y coordinate.
maxx (float) – Maximum bound for x coordinate.
maxy (float) – Maximum bound for y coordinate.
constant_values (scalar, tuple or mapping of hashable to tuple) – The value used for padding. If None, nodata will be used if it is set, and numpy.nan otherwise.

Returns:

The padded object.

Return type:

reproject(dst_crs: Any, *, resolution: float | tuple[float, float] | None = None, shape: tuple[int, int] | None = None, transform: Affine | None = None, resampling: Resampling = Resampling.nearest, nodata: float | None = None, **kwargs) → Dataset[source]

Reproject xarray.Dataset objects

Note

Only 2D/3D arrays with dimensions ‘x’/’y’ are currently supported. Others are appended as is. Requires either a grid mapping variable with ‘spatial_ref’ or a ‘crs’ attribute to be set containing a valid CRS. If using a WKT (e.g. from spatiareference.org), make sure it is an OGC WKT.

Note

To re-project with dask, see odc-geo & pyresample.

Added in version 0.0.27: shape

Added in version 0.0.28: transform

Added in version 0.5.0: nodata, kwargs

Parameters:

dst_crs (str) – OGC WKT string or Proj.4 string.
resolution (float or tuple(float, float), optional) – Size of a destination pixel in destination projection units (e.g. degrees or metres).
shape (tuple(int, int), optional) – Shape of the destination in pixels (dst_height, dst_width). Cannot be used together with resolution.
transform (Affine, optional) – The destination transform.
resampling (rasterio.enums.Resampling, optional) – See rasterio.warp.reproject() for more details.
nodata (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 source image if none provided and exists or attempts to find an appropriate value by dtype.
**kwargs (dict) – Additional keyword arguments to pass into rasterio.warp.reproject(). To override: - src_transform: rio.write_transform - src_crs: rio.write_crs - src_nodata: rio.write_nodata

Returns:

The reprojected Dataset.

Return type:

reproject_match(match_data_array: DataArray | Dataset, *, resampling: Resampling = Resampling.nearest, **reproject_kwargs) → Dataset[source]

Reproject a Dataset object to match the resolution, projection, and region of another DataArray.

Note

Only 2D/3D arrays with dimensions ‘x’/’y’ are currently supported. Others are appended as is. Requires either a grid mapping variable with ‘spatial_ref’ or a ‘crs’ attribute to be set containing a valid CRS. If using a WKT (e.g. from spatiareference.org), make sure it is an OGC WKT.

Added in version 0.9: reproject_kwargs

Parameters:

match_data_array (xarray.DataArray | xarray.Dataset) – Dataset with the target resolution and projection.
resampling (rasterio.enums.Resampling, optional) – See rasterio.warp.reproject() for more details.
**reproject_kwargs – Other options to pass to rioxarray.raster_dataset.RasterDataset.reproject()

Returns:

Contains the data from the src_data_array, reprojected to match match_data_array.

Return type: