From 52a6c2c98b4739786c257d9fd64179e6beccb01b Mon Sep 17 00:00:00 2001 From: snowman2 Date: Tue, 23 Jul 2019 15:15:03 -0500 Subject: [PATCH 1/9] added xarray.open_rasterio --- .travis.yml | 2 +- LICENSE_xarray | 191 +++++++++ README.rst | 5 + appveyor.yml | 2 +- rioxarray/__init__.py | 1 + rioxarray/_io.py | 392 ++++++++++++++++++ rioxarray/rioxarray.py | 5 +- sphinx/examples/clip_geom.ipynb | 192 +++++++-- sphinx/history.rst | 4 + sphinx/rioxarray.rst | 6 + test/conftest.py | 69 +++ test/integration/test_integration__io.py | 63 +++ .../integration/test_integration_rioxarray.py | 109 ++--- 13 files changed, 917 insertions(+), 124 deletions(-) create mode 100644 LICENSE_xarray create mode 100644 rioxarray/_io.py create mode 100644 test/integration/test_integration__io.py diff --git a/.travis.yml b/.travis.yml index f7a605e2..e72f5e54 100644 --- a/.travis.yml +++ b/.travis.yml @@ -30,7 +30,7 @@ before_install: - conda config --add channels conda-forge - conda config --add channels conda-forge # Create conda environment -- conda create -n test python=$PYTHON_VERSION rasterio=1.0.* scipy xarray netcdf4 +- conda create -n test python=$PYTHON_VERSION rasterio=1.0.* scipy xarray netcdf4 dask - source activate test install: diff --git a/LICENSE_xarray b/LICENSE_xarray new file mode 100644 index 00000000..37ec93a1 --- /dev/null +++ b/LICENSE_xarray @@ -0,0 +1,191 @@ +Apache License +Version 2.0, January 2004 +http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + +"License" shall mean the terms and conditions for use, reproduction, and +distribution as defined by Sections 1 through 9 of this document. + +"Licensor" shall mean the copyright owner or entity authorized by the copyright +owner that is granting the License. + +"Legal Entity" shall mean the union of the acting entity and all other entities +that control, are controlled by, or are under common control with that entity. +For the purposes of this definition, "control" means (i) the power, direct or +indirect, to cause the direction or management of such entity, whether by +contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the +outstanding shares, or (iii) beneficial ownership of such entity. + +"You" (or "Your") shall mean an individual or Legal Entity exercising +permissions granted by this License. + +"Source" form shall mean the preferred form for making modifications, including +but not limited to software source code, documentation source, and configuration +files. + +"Object" form shall mean any form resulting from mechanical transformation or +translation of a Source form, including but not limited to compiled object code, +generated documentation, and conversions to other media types. + +"Work" shall mean the work of authorship, whether in Source or Object form, made +available under the License, as indicated by a copyright notice that is included +in or attached to the work (an example is provided in the Appendix below). + +"Derivative Works" shall mean any work, whether in Source or Object form, that +is based on (or derived from) the Work and for which the editorial revisions, +annotations, elaborations, or other modifications represent, as a whole, an +original work of authorship. For the purposes of this License, Derivative Works +shall not include works that remain separable from, or merely link (or bind by +name) to the interfaces of, the Work and Derivative Works thereof. + +"Contribution" shall mean any work of authorship, including the original version +of the Work and any modifications or additions to that Work or Derivative Works +thereof, that is intentionally submitted to Licensor for inclusion in the Work +by the copyright owner or by an individual or Legal Entity authorized to submit +on behalf of the copyright owner. For the purposes of this definition, +"submitted" means any form of electronic, verbal, or written communication sent +to the Licensor or its representatives, including but not limited to +communication on electronic mailing lists, source code control systems, and +issue tracking systems that are managed by, or on behalf of, the Licensor for +the purpose of discussing and improving the Work, but excluding communication +that is conspicuously marked or otherwise designated in writing by the copyright +owner as "Not a Contribution." + +"Contributor" shall mean Licensor and any individual or Legal Entity on behalf +of whom a Contribution has been received by Licensor and subsequently +incorporated within the Work. + +2. Grant of Copyright License. + +Subject to the terms and conditions of this License, each Contributor hereby +grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, +irrevocable copyright license to reproduce, prepare Derivative Works of, +publicly display, publicly perform, sublicense, and distribute the Work and such +Derivative Works in Source or Object form. + +3. Grant of Patent License. + +Subject to the terms and conditions of this License, each Contributor hereby +grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, +irrevocable (except as stated in this section) patent license to make, have +made, use, offer to sell, sell, import, and otherwise transfer the Work, where +such license applies only to those patent claims licensable by such Contributor +that are necessarily infringed by their Contribution(s) alone or by combination +of their Contribution(s) with the Work to which such Contribution(s) was +submitted. If You institute patent litigation against any entity (including a +cross-claim or counterclaim in a lawsuit) alleging that the Work or a +Contribution incorporated within the Work constitutes direct or contributory +patent infringement, then any patent licenses granted to You under this License +for that Work shall terminate as of the date such litigation is filed. + +4. Redistribution. + +You may reproduce and distribute copies of the Work or Derivative Works thereof +in any medium, with or without modifications, and in Source or Object form, +provided that You meet the following conditions: + +You must give any other recipients of the Work or Derivative Works a copy of +this License; and +You must cause any modified files to carry prominent notices stating that You +changed the files; and +You must retain, in the Source form of any Derivative Works that You distribute, +all copyright, patent, trademark, and attribution notices from the Source form +of the Work, excluding those notices that do not pertain to any part of the +Derivative Works; and +If the Work includes a "NOTICE" text file as part of its distribution, then any +Derivative Works that You distribute must include a readable copy of the +attribution notices contained within such NOTICE file, excluding those notices +that do not pertain to any part of the Derivative Works, in at least one of the +following places: within a NOTICE text file distributed as part of the +Derivative Works; within the Source form or documentation, if provided along +with the Derivative Works; or, within a display generated by the Derivative +Works, if and wherever such third-party notices normally appear. The contents of +the NOTICE file are for informational purposes only and do not modify the +License. You may add Your own attribution notices within Derivative Works that +You distribute, alongside or as an addendum to the NOTICE text from the Work, +provided that such additional attribution notices cannot be construed as +modifying the License. +You may add Your own copyright statement to Your modifications and may provide +additional or different license terms and conditions for use, reproduction, or +distribution of Your modifications, or for any such Derivative Works as a whole, +provided Your use, reproduction, and distribution of the Work otherwise complies +with the conditions stated in this License. + +5. Submission of Contributions. + +Unless You explicitly state otherwise, any Contribution intentionally submitted +for inclusion in the Work by You to the Licensor shall be under the terms and +conditions of this License, without any additional terms or conditions. +Notwithstanding the above, nothing herein shall supersede or modify the terms of +any separate license agreement you may have executed with Licensor regarding +such Contributions. + +6. Trademarks. + +This License does not grant permission to use the trade names, trademarks, +service marks, or product names of the Licensor, except as required for +reasonable and customary use in describing the origin of the Work and +reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. + +Unless required by applicable law or agreed to in writing, Licensor provides the +Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, +including, without limitation, any warranties or conditions of TITLE, +NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are +solely responsible for determining the appropriateness of using or +redistributing the Work and assume any risks associated with Your exercise of +permissions under this License. + +8. Limitation of Liability. + +In no event and under no legal theory, whether in tort (including negligence), +contract, or otherwise, unless required by applicable law (such as deliberate +and grossly negligent acts) or agreed to in writing, shall any Contributor be +liable to You for damages, including any direct, indirect, special, incidental, +or consequential damages of any character arising as a result of this License or +out of the use or inability to use the Work (including but not limited to +damages for loss of goodwill, work stoppage, computer failure or malfunction, or +any and all other commercial damages or losses), even if such Contributor has +been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. + +While redistributing the Work or Derivative Works thereof, You may choose to +offer, and charge a fee for, acceptance of support, warranty, indemnity, or +other liability obligations and/or rights consistent with this License. However, +in accepting such obligations, You may act only on Your own behalf and on Your +sole responsibility, not on behalf of any other Contributor, and only if You +agree to indemnify, defend, and hold each Contributor harmless for any liability +incurred by, or claims asserted against, such Contributor by reason of your +accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS + +APPENDIX: How to apply the Apache License to your work + +To apply the Apache License to your work, attach the following boilerplate +notice, with the fields enclosed by brackets "[]" replaced with your own +identifying information. (Don't include the brackets!) The text should be +enclosed in the appropriate comment syntax for the file format. We also +recommend that a file or class name and description of purpose be included on +the same "printed page" as the copyright notice for easier identification within +third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/README.rst b/README.rst index a0c89c65..cc366cc9 100644 --- a/README.rst +++ b/README.rst @@ -38,6 +38,11 @@ The *reproject* functionality was adopted from https://github.com/opendatacube/d - `datacube is licensed `_ under the Apache License, Version 2.0. The datacube license is included as `LICENSE_datacube `_. +The *open_rasterio* functionality was adopted from https://github.com/pydata/xarray + - Source file: `rasterio_.py `_ + - `xarray is licensed `_ under the Apache License, Version 2.0. + The xarray license is included as `LICENSE_xarray `_. + This package was originally templated with with Cookiecutter_. diff --git a/appveyor.yml b/appveyor.yml index ce67f833..d677a7b6 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -16,7 +16,7 @@ install: #----------------------------------------------------------------------------- # Create conda environment #----------------------------------------------------------------------------- - - conda create -n test python=%PYTHON_VERSION% rasterio=1.0.* scipy xarray netcdf4 + - conda create -n test python=%PYTHON_VERSION% rasterio=1.0.* scipy xarray netcdf4 dask - activate test #------------------------------------------------------------------------------- diff --git a/rioxarray/__init__.py b/rioxarray/__init__.py index e0468b3e..d75dff25 100644 --- a/rioxarray/__init__.py +++ b/rioxarray/__init__.py @@ -7,3 +7,4 @@ import rioxarray.rioxarray # noqa from rioxarray._version import __version__ # noqa +from rioxarray._io import open_rasterio # noqa diff --git a/rioxarray/_io.py b/rioxarray/_io.py new file mode 100644 index 00000000..bdb484ba --- /dev/null +++ b/rioxarray/_io.py @@ -0,0 +1,392 @@ +""" + +Credits: + +This file was adopted from: https://github.com/pydata/xarray # noqa +Source file: https://github.com/pydata/xarray/blob/1d7bcbdc75b6d556c04e2c7d7a042e4379e15303/xarray/backends/rasterio_.py # noqa +""" + +import os +import warnings +from collections import OrderedDict +from distutils.version import LooseVersion + +import numpy as np +from xarray import DataArray +from xarray.core import indexing +from xarray.core.utils import is_scalar +from xarray.backends.common import BackendArray +from xarray.backends.file_manager import CachingFileManager +from xarray.backends.locks import SerializableLock + +from rioxarray.rioxarray import affine_to_coords + + +# TODO: should this be GDAL_LOCK instead? +RASTERIO_LOCK = SerializableLock() + +_ERROR_MSG = ( + "The kind of indexing operation you are trying to do is not " + "valid on rasterio files. Try to load your data with ds.load()" + "first." +) + + +class RasterioArrayWrapper(BackendArray): + """A wrapper around rasterio dataset objects""" + + def __init__(self, manager, lock, vrt_params=None, masked=False): + from rasterio.vrt import WarpedVRT + + self.manager = manager + self.lock = lock + self.masked = masked + + # cannot save riods as an attribute: this would break pickleability + riods = manager.acquire() + if vrt_params is not None: + riods = WarpedVRT(riods, **vrt_params) + self.vrt_params = vrt_params + self._shape = (riods.count, riods.height, riods.width) + + dtypes = riods.dtypes + if not np.all(np.asarray(dtypes) == dtypes[0]): + raise ValueError("All bands should have the same dtype") + if self.masked: + self._dtype = np.dtype("float64") + else: + self._dtype = np.dtype(dtypes[0]) + + @property + def dtype(self): + return self._dtype + + @property + def shape(self): + return self._shape + + def _get_indexer(self, key): + """ Get indexer for rasterio array. + + Parameter + --------- + key: tuple of int + + Returns + ------- + band_key: an indexer for the 1st dimension + window: two tuples. Each consists of (start, stop). + squeeze_axis: axes to be squeezed + np_ind: indexer for loaded numpy array + + See also + -------- + indexing.decompose_indexer + """ + assert len(key) == 3, "rasterio datasets should always be 3D" + + # bands cannot be windowed but they can be listed + band_key = key[0] + np_inds = [] + # bands (axis=0) cannot be windowed but they can be listed + if isinstance(band_key, slice): + start, stop, step = band_key.indices(self.shape[0]) + band_key = np.arange(start, stop, step) + # be sure we give out a list + band_key = (np.asarray(band_key) + 1).tolist() + if isinstance(band_key, list): # if band_key is not a scalar + np_inds.append(slice(None)) + + # but other dims can only be windowed + window = [] + squeeze_axis = [] + for i, (k, n) in enumerate(zip(key[1:], self.shape[1:])): + if isinstance(k, slice): + # step is always positive. see indexing.decompose_indexer + start, stop, step = k.indices(n) + np_inds.append(slice(None, None, step)) + elif is_scalar(k): + # windowed operations will always return an array + # we will have to squeeze it later + squeeze_axis.append(-(2 - i)) + start = k + stop = k + 1 + else: + start, stop = np.min(k), np.max(k) + 1 + np_inds.append(k - start) + window.append((start, stop)) + + if isinstance(key[1], np.ndarray) and isinstance(key[2], np.ndarray): + # do outer-style indexing + np_inds[-2:] = np.ix_(*np_inds[-2:]) + + return band_key, tuple(window), tuple(squeeze_axis), tuple(np_inds) + + def _getitem(self, key): + from rasterio.vrt import WarpedVRT + + band_key, window, squeeze_axis, np_inds = self._get_indexer(key) + + if not band_key or any(start == stop for (start, stop) in window): + # no need to do IO + shape = (len(band_key),) + tuple(stop - start for (start, stop) in window) + out = np.zeros(shape, dtype=self.dtype) + else: + with self.lock: + riods = self.manager.acquire(needs_lock=False) + if self.vrt_params is not None: + riods = WarpedVRT(riods, **self.vrt_params) + out = riods.read(band_key, window=window, masked=self.masked) + if self.masked: + out = np.ma.filled(out.astype(self.dtype), np.nan) + + if squeeze_axis: + out = np.squeeze(out, axis=squeeze_axis) + return out[np_inds] + + def __getitem__(self, key): + return indexing.explicit_indexing_adapter( + key, self.shape, indexing.IndexingSupport.OUTER, self._getitem + ) + + +def _parse_envi(meta): + """Parse ENVI metadata into Python data structures. + + See the link for information on the ENVI header file format: + http://www.harrisgeospatial.com/docs/enviheaderfiles.html + + Parameters + ---------- + meta : dict + Dictionary of keys and str values to parse, as returned by the rasterio + tags(ns='ENVI') call. + + Returns + ------- + parsed_meta : dict + Dictionary containing the original keys and the parsed values + + """ + + def parsevec(s): + return np.fromstring(s.strip("{}"), dtype="float", sep=",") + + def default(s): + return s.strip("{}") + + parse = {"wavelength": parsevec, "fwhm": parsevec} + parsed_meta = {k: parse.get(k, default)(v) for k, v in meta.items()} + return parsed_meta + + +def open_rasterio( + filename, parse_coordinates=None, chunks=None, cache=None, lock=None, masked=False +): + """Open a file with rasterio (experimental). + + This should work with any file that rasterio can open (most often: + geoTIFF). The x and y coordinates are generated automatically from the + file's geoinformation, shifted to the center of each pixel (see + `"PixelIsArea" Raster Space + `_ + for more information). + + You can generate 2D coordinates from the file's attributes with:: + + from affine import Affine + da = xr.open_rasterio('path_to_file.tif') + transform = Affine.from_gdal(*da.attrs['transform']) + nx, ny = da.sizes['x'], da.sizes['y'] + x, y = np.meshgrid(np.arange(nx)+0.5, np.arange(ny)+0.5) * transform + + + Parameters + ---------- + filename : str, rasterio.DatasetReader, or rasterio.WarpedVRT + Path to the file to open. Or already open rasterio dataset. + parse_coordinates : bool, optional + Whether to parse the x and y coordinates out of the file's + ``transform`` attribute or not. The default is to automatically + parse the coordinates only if they are rectilinear (1D). + It can be useful to set ``parse_coordinates=False`` + if your files are very large or if you don't need the coordinates. + chunks : int, tuple or dict, optional + Chunk sizes along each dimension, e.g., ``5``, ``(5, 5)`` or + ``{'x': 5, 'y': 5}``. If chunks is provided, it used to load the new + DataArray into a dask array. Chunks can also be set to + ``True`` or ``"auto"`` to choose sensible chunk sizes according to + ``dask.config.get("array.chunk-size"). + cache : bool, optional + If True, cache data loaded from the underlying datastore in memory as + NumPy arrays when accessed to avoid reading from the underlying data- + store multiple times. Defaults to True unless you specify the `chunks` + argument to use dask, in which case it defaults to False. + lock : False, True or threading.Lock, optional + If chunks is provided, this argument is passed on to + :py:func:`dask.array.from_array`. By default, a global lock is + used to avoid issues with concurrent access to the same file when using + dask's multithreaded backend. + masked : bool, optional + If True, read the mask and to set values to NaN. Defaults to False. +return + Returns + ------- + data : DataArray + The newly created DataArray. + """ + import rasterio + from rasterio.vrt import WarpedVRT + + vrt_params = None + if isinstance(filename, rasterio.io.DatasetReader): + filename = filename.name + elif isinstance(filename, rasterio.vrt.WarpedVRT): + vrt = filename + filename = vrt.src_dataset.name + vrt_params = dict( + crs=vrt.crs.to_string(), + resampling=vrt.resampling, + src_nodata=vrt.src_nodata, + dst_nodata=vrt.dst_nodata, + tolerance=vrt.tolerance, + transform=vrt.transform, + width=vrt.width, + height=vrt.height, + warp_extras=vrt.warp_extras, + ) + + if lock is None: + lock = RASTERIO_LOCK + + manager = CachingFileManager(rasterio.open, filename, lock=lock, mode="r") + riods = manager.acquire() + if vrt_params is not None: + riods = WarpedVRT(riods, **vrt_params) + + if cache is None: + cache = chunks is None + + coords = OrderedDict() + + # Get bands + if riods.count < 1: + raise ValueError("Unknown dims") + coords["band"] = np.asarray(riods.indexes) + + # Get coordinates + if LooseVersion(rasterio.__version__) < "1.0": + transform = riods.affine + else: + transform = riods.transform + if transform.is_rectilinear: + # 1d coordinates + parse = True if parse_coordinates is None else parse_coordinates + if parse: + coords.update(affine_to_coords(riods.transform, riods.width, riods.height)) + else: + # 2d coordinates + parse = False if (parse_coordinates is None) else parse_coordinates + if parse: + warnings.warn( + "The file coordinates' transformation isn't " + "rectilinear: xarray won't parse the coordinates " + "in this case. Set `parse_coordinates=False` to " + "suppress this warning.", + RuntimeWarning, + stacklevel=3, + ) + + # Attributes + attrs = dict() + encoding = dict() + # Affine transformation matrix (always available) + # This describes coefficients mapping pixel coordinates to CRS + # For serialization store as tuple of 6 floats, the last row being + # always (0, 0, 1) per definition (see + # https://github.com/sgillies/affine) + attrs["transform"] = tuple(transform)[:6] + if hasattr(riods, "nodata") and riods.nodata is not None: + # The nodata values for the raster bands + if masked: + encoding["_FillValue"] = riods.nodata + else: + attrs["_FillValue"] = riods.nodata + if hasattr(riods, "scales"): + # The scale values for the raster bands + attrs["scales"] = riods.scales + if hasattr(riods, "offsets"): + # The offset values for the raster bands + attrs["offsets"] = riods.offsets + if hasattr(riods, "descriptions") and any(riods.descriptions): + # Descriptions for each dataset band + attrs["descriptions"] = riods.descriptions + if hasattr(riods, "units") and any(riods.units): + # A list of units string for each dataset band + attrs["units"] = riods.units + + # Parse extra metadata from tags, if supported + parsers = {"ENVI": _parse_envi} + + driver = riods.driver + if driver in parsers: + meta = parsers[driver](riods.tags(ns=driver)) + + for k, v in meta.items(): + # Add values as coordinates if they match the band count, + # as attributes otherwise + if isinstance(v, (list, np.ndarray)) and len(v) == riods.count: + coords[k] = ("band", np.asarray(v)) + else: + attrs[k] = v + + data = indexing.LazilyOuterIndexedArray( + RasterioArrayWrapper(manager, lock, vrt_params, masked=masked) + ) + + # this lets you write arrays loaded with rasterio + data = indexing.CopyOnWriteArray(data) + if cache and chunks is None: + data = indexing.MemoryCachedArray(data) + + result = DataArray(data=data, dims=("band", "y", "x"), coords=coords, attrs=attrs) + result.encoding = encoding + + if hasattr(riods, "crs") and riods.crs: + result.rio.write_crs(riods.crs, inplace=True) + + if chunks is not None: + from dask.base import tokenize + + # augment the token with the file modification time + try: + mtime = os.path.getmtime(filename) + except OSError: + # the filename is probably an s3 bucket rather than a regular file + mtime = None + + if chunks in (True, "auto"): + from dask.array.core import normalize_chunks + import dask + + if dask.__version__ < "0.18.0": + msg = ( + "Automatic chunking requires dask.__version__ >= 0.18.0 . " + "You currently have version %s" % dask.__version__ + ) + raise NotImplementedError(msg) + block_shape = (1,) + riods.block_shapes[0] + chunks = normalize_chunks( + chunks=(1, "auto", "auto"), + shape=(riods.count, riods.height, riods.width), + dtype=riods.dtypes[0], + previous_chunks=tuple((c,) for c in block_shape), + ) + token = tokenize(filename, mtime, chunks) + name_prefix = "open_rasterio-%s" % token + result = result.chunk(chunks, name_prefix=name_prefix, token=token) + + # Make the file closeable + result._file_obj = manager + + return result diff --git a/rioxarray/rioxarray.py b/rioxarray/rioxarray.py index 1c58122e..8f30b619 100644 --- a/rioxarray/rioxarray.py +++ b/rioxarray/rioxarray.py @@ -147,9 +147,12 @@ def _add_attrs_proj(new_data_array, src_data_array): # make sure projection added add_xy_grid_meta(new_data_array.coords) - return add_spatial_ref( + new_data_array = add_spatial_ref( new_data_array, src_data_array.rio.crs, _get_grid_map_name(src_data_array) ) + # make sure encoding added + new_data_array.encoding = src_data_array.encoding.copy() + return new_data_array def _warp_spatial_coords(data_array, affine, width, height): diff --git a/sphinx/examples/clip_geom.ipynb b/sphinx/examples/clip_geom.ipynb index 6d6bcf99..768bde98 100644 --- a/sphinx/examples/clip_geom.ipynb +++ b/sphinx/examples/clip_geom.ipynb @@ -9,23 +9,11 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/snowal/miniconda3/envs/geocube/lib/python3.6/site-packages/dask/config.py:168: YAMLLoadWarning: calling yaml.load() without Loader=... is deprecated, as the default Loader is unsafe. Please read https://msg.pyyaml.org/load for full details.\n", - " data = yaml.load(f.read()) or {}\n", - "/home/snowal/miniconda3/envs/geocube/lib/python3.6/site-packages/distributed/config.py:20: YAMLLoadWarning: calling yaml.load() without Loader=... is deprecated, as the default Loader is unsafe. Please read https://msg.pyyaml.org/load for full details.\n", - " defaults = yaml.load(f)\n" - ] - } - ], + "outputs": [], "source": [ - "import rioxarray # for the extension to load\n", - "import xarray\n", + "import rioxarray\n", "\n", "%matplotlib inline" ] @@ -34,41 +22,45 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Load in xarray dataset" + "## Load in xarray dataset\n", + "\n", + "Notes:\n", + " - `chunks=True` only works if you have a dask installed. Otherwise, you can skip this.\n", + " - `masked=True` will convert from integer to `float64` and fill with `NaN`. If this behavior is not desired, you can skip this." ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ - "xds = xarray.open_rasterio(\"small_dem_3m_merged.tif\")" + "xds = rioxarray.open_rasterio(\"../../test/test_data/compare/small_dem_3m_merged.tif\", masked=True, chunks=True)" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\n", - "[140630 values with dtype=uint16]\n", + "dask.array\n", "Coordinates:\n", - " * band (band) int64 1\n", - " * y (y) float64 4.616e+06 4.616e+06 4.616e+06 ... 4.615e+06 4.615e+06\n", - " * x (x) float64 4.25e+05 4.251e+05 4.251e+05 ... 4.268e+05 4.268e+05\n", + " * band (band) int64 1\n", + " * y (y) float64 4.616e+06 4.616e+06 ... 4.615e+06 4.615e+06\n", + " * x (x) float64 4.25e+05 4.251e+05 ... 4.268e+05 4.268e+05\n", + " spatial_ref int64 0\n", "Attributes:\n", - " transform: (3.0, 0.0, 425047.68381405267, 0.0, -3.0, 4615780.040546387)\n", - " crs: +init=epsg:26915\n", - " res: (3.0, 3.0)\n", - " is_tiled: 0\n", - " nodatavals: (0.0,)" + " transform: (3.0, 0.0, 425047.68381405267, 0.0, -3.0, 4615780.040546387)\n", + " scales: (1.0,)\n", + " offsets: (0.0,)\n", + " grid_mapping: spatial_ref" ] }, - "execution_count": 3, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -85,7 +77,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 4, @@ -94,7 +86,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -106,7 +98,7 @@ } ], "source": [ - "xds.where(xds!=xds.nodatavals[0]).plot()" + "xds.plot()" ] }, { @@ -154,11 +146,7 @@ "data": { "text/plain": [ "\n", - "array([[[30696, 30699, ..., 30703, 30701],\n", - " [30694, 30697, ..., 30703, 30700],\n", - " ...,\n", - " [30614, 30614, ..., 30619, 30621],\n", - " [30611, 30610, ..., 30614, 30616]]], dtype=uint16)\n", + "dask.array\n", "Coordinates:\n", " * band (band) int64 1\n", " * y (y) float64 4.615e+06 4.615e+06 ... 4.615e+06 4.615e+06\n", @@ -166,7 +154,8 @@ " spatial_ref int64 0\n", "Attributes:\n", " transform: (3.0, 0.0, 425500.68381405267, 0.0, -3.0, 4615477.04054638...\n", - " _FillValue: 0.0\n", + " scales: (1.0,)\n", + " offsets: (0.0,)\n", " grid_mapping: spatial_ref" ] }, @@ -187,7 +176,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 8, @@ -196,7 +185,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAEWCAYAAABmE+CbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3de5hcVZn2/+/dhyScTwkYCBoQ0BcYRAQGBTWCIqMIjnJyREH5Xbz4Q3FUBkFHEWcyAh5AB08ZERBEjCCKCCKCgUGBGJAEAigoKIEIhJOEkE66+37/WKuSSqerenenunZX9fO5rn1V1ap9WLuqe6/a61kH2SaEEELoKDsDIYQQxoYoEEIIIQBRIIQQQsiiQAghhABEgRBCCCGLAiGEEAIQBULLkPSwpDe327HGEkmvl/SHguseK+mWUcjDepJ+Juk5ST9q9P5DqCcKhNAUko6Q9FtJyyTNKTs/AJIsaYfKa9v/a/sVZeYJOAzYCtjC9uGN2qmSsyQ9lZezJalR+w/toavsDIRx42ngXOCVwP4l56UUkrps9w6x2suAPxZYb7iOB94JvAowcD3wZ+BbDT5OaGFxh9Ba9pJ0r6RnJF0gaRKApM0kXS3pyfze1ZKmVTaSNEfSf0j6jaTnJf1S0uSq998n6S/5l+OnRyPjtn9lezbw2HC3lbS3pHmS/i7pcUlfyenT86/84yU9JmmxpE8M2O5WSc/m986TNCG/d3Nebb6kpZKOlDRD0qKq7U+V9Kf8md0r6Z9HkHdLOlHSA8ADOe2Vkq6X9LSkP0g6IqefAXwWODLn6bjhHq+OY4Av215k+1Hgy8CxDdx/aANRILSW9wJvBV4O7AT8e07vAC4g/bp8KfAicN6Abf8F+ACwJTABOBlA0s7AN4H3AVsDWwDTqCFfJJ+ttTTmNNfyVeCrtjcmnfvsAe+/CdgROBA4tSr+0Qd8DJgMvBY4APj/AWy/Ia/zKtsb2v7hIMf9E/B6YBPgDOASSVNHkP93Av8I7CxpA9Kv80tJ38V7gG9I2sX26cB/AT/MeTp/4I4k/Uu9z1/SS2vkYRdgftXr+TkthFXGRYEg6eT8S21yjfc3lXS5pPsl3SfptTn9cEkLJfVL2rNq/emSXpR0V16GvO3OdbgzJf0xH+OkEZzKebYfsf00MJN0McH2U7avsL3M9vP5vTcO2PYC23+0/SLpgrp7Tj8MuNr2zbZ7gM8A/bUyYPtM25vWWkZwTkWsBHaQNNn2Utu3DXj/DNsv2L6bVDBWPpc7bN9mu9f2w8C3Wftzqcn2j2w/Zrs/FxgPAHuPIP9fsP10/uwPBh62fUHO153AFaTvoUieLq33+dv+a41NNwSeq3r9HLBhxBFCtbaJIUiaARxr+9gB6dsCbwFq/aNA+gX6C9uH5SqF9XP6PcC7SBeSgf5ke/dB0ms5FtgWeKXtfklbDmPbikeqnv+F9IseSesD5wAHAZvl9zeS1Gm7L7/+W9W2y0gXCPI+Vu3X9guSnhpB3kbTccDngfslPUQqAK6uen/g5/IPAJJ2Ar4C7En6TruAO4oeVNL7gY8D03PShqS7jeGqzt/LgH8ccDfVBVw8gv0Ox1Jg46rXGwNLHaNbhirj4Q7hHOAUUiBtLZI2Bt4AnA9ge4XtZ/Pz+2wXaoZYtb8Dc731nZJ+JKly4f0Q8Hnb/XnfT4zgXLatev5SVtfHfwJ4BfCPuVqlUh1S5Nff4ur95sJli1orS/pUrt8edBnOyRRl+wHb7yFVsZwFXJ6rXipqfS7fBO4Hdsyfy6co9pkg6WXA/wAfJrX42ZT0A2Ekv6ir//YeAW4a8Kt+Q9sfKpiv99b7/OtUGS0kBZQrXpXTQlilrQsESYcAj9qeX2e17YEngQsk/V7SdwZcbGrZLq9/k6TX5+NNJtXrv9n2HsA80i9MSHXfRyoFR6+VtOMITulESdMkbU66uFXqvTcixQ2eze+dPox9Xg4cLGm/fHf0eer8Xdj+r3wBG3SptZ2kTqUgeBfQIWmSpO6q9x+WdGyNbY+WNCUXppVf1n1Vq3xG0vqSdiHFSao/l78DSyW9klQoV3uc9P0PZgPShfzJnIcPALvWOr9huBrYSSmQ352XvST9nyIb2/5+vc+/TpXR94CPS9pG0takHxEXNuB8Qhtp+QJB0u2S7gK+AxxSVa9/KPBpUquNerqAPYBv2n418AJw6hDbLAZemtf/OHBpvtPYB9gZ+E3O0zGkKgKAicBy23uSfnl+d7jnSgpE/pLUXPDPwH/m9HOB9YAlwG3AL4ru0PZC4MS878XAM8CiuhuNzPtIhdY3SYHaF0mfA7kg2oKU98EcBCzMdyBfBY6yvbzq/ZuAB4EbgC/Z/mVOP5kUTH8+H2tg4PhzwEU5GHtE9Ru27yW1xLmVVHD8A/Cb4Z3y2nKM50DgKNKdzN9Idz0T13XfQ/g28DPgbtKdzs8ZvCo0jGNqlyrEgTEESf9AukAsy6tMI/0D7m37b1XbvQS4zfb0/Pr1wKm23161zhzgZNvzahx7DuniMxX4l1y9MXCd+4GDbD+cA3nP2t5kHU65bUjaDzhxsM9tiO2mAw8B3aPQbj+Ecafl7xBqsX237S1tT88X+0XAHtWFQV7vb8Ajkio9VA8A7q23b0lTJHXm59uTmjz+mfQLd1/l3q+5GmOnvNlPWN0h643AH9f1HNuF7VuGWxiEEBqvbQuEeiRtLemaqqSPAN+XtIDUHPO/8nr/rNRR6bXAzyVdl9d/A7BA0nxSHfwJuVnhk6TWRD/I+7qN1DMX4Ezg3ZLuBr4A/H+jepKhKZTGP2pagD2E0dQ2VUYhhBDWzbi8QwghhLC2lu6YtsnmnX7JtO6hV2yw7todeUdNV0n9STtH1Ox+3amk45bBg3eRGXX9pR23HAsWrFxie8q67OOtb9rATz3dN/SKwB0Leq6zfdC6HK/ZWrpAeMm0bmZdVasfzuiZ0vlCCcds+iEB2Fij3RpycN1q6T/NYVlZUgOpnpKOu7Sk424zbfFf1nUfTz3dx9zril1zOqc+MJJe7aUaP/91IYSwjgz0l3aPM/qiQAghhIKMWeliVUatqKULhH538Pf+SU0/7iStLOGYy4deaRRM7Cjn9r6sKqOyqm/Gk+Ut3rIx7hBCCCFgTF+LF2j1RIEQQgjDUFbrrGaIAiGEEAoy0BcFQgghBIg7hDGrlw6e7Vt/6BUbrIyg8kYdK5p+zDKNp7b5PZTTamVlSXXhz/e37mXHNO5zy/OD3Ewa+rwLuNz26XlOkx+SZup7GDjC9jOS3gv8W9UudiMN2HmXpNeQ5rdYD7gG+KhtS5pImgvjNcBTwJF5OtlBxdAVIYRQkDF9BZcCeoD9bb+KNKjmQZL2Ic3HcoPtHUlD+J8KqyZH2j1P3fs+0tzcd+V9fRM4njTy8o6kOUQgTT/7jO0dSLNHnlUvQ1EghBBCUYa+gsuQu0oqo+J258XAocBFOf0i4J2DbP4e4AcAkqYCG9u+Nc+R/b2qbar3dTlwQJ6PZVBRIIQQQkGpp3KxBZicp8ytLMcP3F+eWvYu4Angetu3A1vZXgyQH7ccJCtHkgsEYBvWnOVwUU6rvPdI3lcv8Bx15kxv3co8YKU7Wbxys7Kz0RQTVFbvyOaP2wQwpbN9e4MOVFZdflkdxJa7lS87oq/4wItL8pS5NdnuA3aXtClwpaQh5+2W9I/AMtv3rMrUILsu8N5aWvmbCSGEpkpB5caPxGv72TwV70HA45Km2l6cq4OeGLD6Uay+O4B0RzCt6nVluuDKe9sCiyR1AZsAT9fKR1QZhRBCQakfggotQ8lT8W6an68HvBm4H7gKOCavdgzw06ptOoDDgctW5SlVKz0vaZ8cH3h/1TbV+zoMuNF1ZkWLO4QQQhiG/sbdIUwFLsrzs3cAs21fLelWYLak44C/kgqAijcAi2z/ecC+PsTqZqfX5gXgfOBiSQ+S7gyOqpehKBBCCKGgyh1CQ/ZlLwBePUj6U8ABNbaZA+wzSPo8YK34g+3lrFmg1NXSBcLK/k4e7dm06cftLiHAu7KkQNyK7qdKOe5Kxxz17eqJvo3KzsKIGdHXxjXtLV0ghBBCszWwymjMiQIhhBAKMmKFS5rPtgmiQAghhIJSx7SoMhqxHEGfBzxq++Cc9hHgw0Av8HPbp+T000hjb/QBJ9m+rt6+V7qTvy3fZDSzP6ieEgbn2qK7nA5iZVnu7lKOW8bAhWV1Oizrl+6TvRuXctxGaVRQeSxqxpXto8B9wMYAkt5EGl9jN9s9krbM6TuTmkTtAmwN/ErSTrknXwghlM4WfW7fO4RRPTNJ04C3A9+pSv4QcKbtHgDblV54hwKX2e6x/RDwILD3aOYvhBCGqx8VWlrRaBd15wKnwBqzUu8EvF7S7ZJukrRXTl81CFNWPUBTCCGULgWVuwotrWjUci3pYOAJ23dImjHgmJuROlfsReqRtz0FB2HKIwYeDzBxy41YvKz5bZqX9Ta/fvtRNmWb9Z9t+nEndmze9GPC+IohAGzU+WLTj7m8v5zP+LkSJrVqlAgqj9y+wCGS3gZMAjaWdAnpl/+P83gacyX1A5NZPQhTRfUATavYngXMAtjoFS9p37nsBiijMAjNUUZhEEaur437IYxaUWf7NNvTbE8nBYtvtH008BNgfwBJOwETgCWkQZiOkjRR0nakWX/mjlb+QghhuCo9lYssraiMiq7vAt+VdA+wAjgm3y0slDQbuJfUHPXEaGEUQhhr+tu4lVFTCoQ8INOc/HwFcHSN9WYCM5uRpxBCGK40uF0UCGNSX38Hzy5br+xsNEVXR2t35hmuMjr/AWzS1fz6/CW9rTvY20g819u6/7NGrIyhK0IIIdi0dce0KBBCCKGw1u10VkQUCCGEUJCJO4Qxq79fLO9pfueapZ39Q68U1snEjt5SjtvO9cMDlTHRE8DSvomlHLdRIqgcQggBo5ggJ4QQQqoyKms622Zo3zMLIYSGU8yHEEIIIQ9uF0HlscmG3hXNDwIupbWDYsPRqXIC6BM6mj8TXjpu84PZEzvLCaB3lRRUfmbFBqUct1HiDiGEEAK24g4hhBBCJajcvk2To0AIIYTC2ntO5dYuEPpFf0/zT6GMGt/lXeV8VRO7yplV64kXy6ln3rB7RdOPuX5XObO0laWs77YRUlA5YgghhBCInsohhBCInsoASHodML16fdvfG6U8hRDCmNU/nu8QJF0MvBy4C6g0XDYQBUIIYVyxYWX/OC4QgD2BnfO8xwFwf/veMo4VZbXkWNHf/CaFXf3ldP7rLenC1sqtdFKVUevmfyhFCoR7gJcAi0c5LyGEMOaN957Kk4F7Jc0FeiqJtg8ZtVyFEMIYFM1O4XPrcgBJncA84FHbB1elnwx8EZhie0lOOw04jhSrOMn2dety7BBCaKxxXmVk+yZJWwF75aS5tp8YxjE+CtwHbFxJkLQt8Bbgr1VpOwNHAbsAWwO/krST7bojcLmM6tcS6l57SpgZDqBnQjkDr3V3ljPw2oq+9h2WYKCyznVli3/G7Tyn8pBXNklHAHOBw4EjgNslHVZk55KmAW8HvjPgrXOAU0h3YBWHApfZ7rH9EPAgsHeR44QQQjOkVkadhZahSJokaa6k+ZIWSjojp28u6XpJD+THzaq22U3SrXn9uyVNyunvya8XSPqFpMk5faKkH0p6UNLtkqbXy1ORn7qfBvayfYzt95Mu0p8psB3AuaQL/6rf8ZIOIVUfzR+w7jbAI1WvF+W0NUg6XtI8SfP6nn+hYDZCCGHdVTqmFVkK6AH2t/0qYHfgIEn7AKcCN9jeEbghv0ZSF3AJcILtXYAZwMqc/lXgTbZ3AxYAH87HOA54xvYOpB/iZ9XLUJECoWNAFdFTRbaTdDDwhO07qtLWJxUwnx1sk0HS1mrqanuW7T1t79m5UeuOiRJCaE39qNAyFCdL88vuvJhUW3JRTr8IeGd+fiCwoPJj2vZTuUpdedlAkkjV84/lbar3dTlwQF5nUEWCyr+QdB3wg/z6SOCaAtvtCxwi6W3ApJzJi4HtgPk5T9OAOyXtTboj2LZq+2lVJxVCCKVrdCuj3OjmDmAH4Ou2b5e0le3FALYXS9oyr74T4Hw9nkKqYj/b9kpJHwLuBl4AHgBOzNusqnmx3SvpOWALYMlg+SkSVP43Se8mXeAFzLJ9ZYHtTgNOyyc9AzjZ9rsHfBgPA3vaXiLpKuBSSV8hBZV3JMUu6hxEaEUJEf+O5key+1eW07Jh6bJyZofr7SvnfCd2NT+I3tVZUse0kj7jnt7WHkJtGK2MJkuaV/V6lu1Z1SvkX/i7S9oUuFLSrnX21wXsR2rgswy4QdIdwM3Ah4BXA38G/pt07f1PCta8VB9gSLavAK4osu5I2V4oaTZwL2mE6ROHamEUQgjNZIve4gXCEtt7Ftuvn5U0BzgIeFzS1Hx3MBWoVNkvAm6qaqZ/DbAH8Pe8jz/l9NnkuAOra14W5VjDJsDTtfJR88wk3ZIfn5f096rleUl/L3KSVSc7p7oPQlX69MrJ5dczbb/c9itsXzucY4QQQjM0KqgsaUq+M0DSesCbgfuBq4Bj8mrHAD/Nz68DdpO0fr64v5H0A/pRYGdJU/J6byE19WfAvg4Dbqw3DFHNOwTb++XHjYY8sxBCGAcaHEOYClyU4wgdwGzbV0u6FZgt6ThSX63DAWw/k6vUf5ezco3tnwPkJqs3S1oJ/AU4Nh/jfOBiSQ+S7gyOqpehQqOd2n7fUGnlMHTGmHujqXdFOZ2IejrK+V5Lqc8vqWK0rEHmela2egyhMQWC7QWkev+B6U8BB9TY5hJS09OB6d8CvjVI+nJygVJEkW9ml+oX+VblNUUPEEII7aLdJ8ipF0M4TdLzpDqrVfED4HFW12mFEMK40qh+CGNRvRjCF4AvSPpCbkIaQgjjml3ePBLNUKTKaK6kTWw/B5Cj4jNs/2R0szaGjaO4hcbRuYbm6CyhH08jjcsqoyqnVwoDSO1lgdNHL0shhDA2NXgsozGnyB3CYIVGazcTCCGEEXKLXuyLKHJhn5fbvn6d1Pb1I6SxN0IIYdxp1YBxEUWqjD4CrAB+CMwGXmT1wEkhhDBu2I3rqTwWFRnc7gXgVEkbVg3VOjYI6G5+0FMlBMVUUketzpIGXisr8FjGgG+9hX6XNV5Zg+r1tXQrHbV4/usrMq/B6yTdSxozA0mvkvSNUc9ZCCGMQbYKLa2oSFF3DvBW0sQ45MkZ3jCamQohhLGoMpbRuK0yArD9yIBJdmJY6hDC+OMUR2hXRQqERyS9jjRTzwTgJFYPrVquDtMxsfkTmpTRWauru5wyeGJ38z9fKGeiGihvwLcylDVBjvtb89dzRTu3MipSIJxAmsB5G9JkC78kWhmFEMYht3lQuUgroyXAe5uQlxBCGPPGZZWRpFNsny3pv1l7Dk6TJlu4pDJtWwghjAet2oKoiHp3CJU4wbwa728B/Bh4VUNzFEIIY5Q9TgsE2z/LjxcBSNoovVzdOU3SC6Oewzok6JrQ/GBrGZ3Exltwd70JK0s57sq+5s8QV1Zwt6wOcX0lnW+jtGqT0iKKdEzbVdLvgXuAeyXdIWkXANvfHu0MhhDCWGIXW1pRkaJ6FvBx2y+z/VLgE8D/FD2ApE5Jv5d0dX79RUn3S1og6co8v0Jl3dMkPSjpD5LeOtyTCSGE0WREf39HoaUVFcn1BrZ/XXlhew6wwTCO8VHW7LdwPbCr7d2APwKnAUjaGTiKNIfzQcA3JJUzw3sIIdTggksrKtIP4c+SPgNcnF8fDTxUZOeSpgFvB2YCHwew/cuqVW4DDsvPDwUus90DPCTpQWBv4NZa++/oMJMmNr+uuYxBwTrV2rNMDVcZdflQTn1+WZ3hyhrcrqwBExuizYPKRf4SPwhMIbUo+jEwGfhAwf2fC5wC1PoL+CBwbX6+DfBI1XuLctoaJB0vaZ6keb3PLSuYjRBCaJA2vkWoe4eQq2w+Zfuk4e5Y0sHAE7bvkDRjkPc/DfQC368kDbKbtT5W27NIcQ3W33HrFv3YQwitqp3vEOoWCLb7JL1mhPveFzhE0tuAScDGki6xfbSkY4CDgQPsVfH4RcC2VdtPAx4b4bFDCKHhDPS3+FhM9RSJIfxe0lXAj4BV/Q5s/7jeRrZPY3XAeAZwci4MDgI+CbzRdnWdz1XApXm6zq2BHYG5wziXEEIYXQbG6x1CtjlpLoT9q9JMiieMxHnAROD6PKT2bbZPsL1Q0mzSRDy9wIm26/Y6Ey6l41RZnabGkxdXdJdy3PE02mkYmVbtY1BEkcHtigaQ6+1jDjAnP9+hznozSS2SQghhbGrjAqFIT+XtJf1M0pOSnpD0U0nbNSNzIYQwthSbPrNVA89F7o8vBWYDU0l1+z8CLhvNTIUQwpg1XpudZrJ9cdXrSyR9eLQyNBzS+OkkNqFzfM1aWlbHtDImhy0rblHWoHotza0/41s9RQqEX0s6lXRXYOBI4OeSNgew/fQo5i+EEMaY8V0gHJkf/++A9A+SCojtG5qjEEIYy1q0OqiIIq2MIoAcQggV47lAGMsk011C3fp4q88vQxnfK5RTr96p/lLiCBFDGIHomBZCGE3RGa61tHPHtJp/iZL2zY8Tm5edEEIY4/pVbGlB9X6afC0/1pyPIIQQxhu52DLkfqRJkuZKmi9poaQzcvrmkq6X9EB+3Kxqm90k3ZrXv1vSpJw+QdIsSX/MM1K+O6dPlPTDPBPl7ZKm18tTvSqjlZIuALaR9LWBb45kSOwQQmhpje101gPsb3uppG7gFknXAu8CbrB9Zm7yfyrwSUldwCXA+2zPl7QFUBlY7dOk6QZ2ktRBGoMO4DjgGds7SDoKOIvVLUfXUq9AOBh4M2lQuztGesbtaEVZnabCqCtlFrGS2ihMmtD8gSEBXmjR+YYTNSyonIf+X5pfdufFpNkjZ+T0i0jjwH0SOBBYYHt+3v6pqt19EHhlTu8HluT0Q4HP5eeXA+dJUtW0A2uoWSDYXgJcJum+SgZCCGHcK36HMFnSvKrXs/IEX6vkScjuAHYAvm77dklb2V4MYHuxpC3z6jsBlnQdaRbLy2yfLWnT/P5/5KkG/gR82PbjVM1EabtX0nPAFqwuMNZQpKh+StKVeWC7xyVdkedKDiGE8ae/4AJLbO9ZtcwauCvbfbZ3J00ItrekXescuQvYD3hvfvxnSQfk9GnAb2zvQYr7filvU2gmyooiBcIFpMlrtiaVNj/LaSGEML5U+iEUWYazW/tZUtXQQcDjkqYC5Mcn8mqLgJtsL8mTi10D7EGar2YZcGVe70c5vbLNtnlfXcAmQM3hhor0Q9jSdnUBcKGkfy2wXQgjVsYAgunA5Ry2FCXFLjo7SvpuG6RIC6JC+5GmACttPytpPVLM9izSD/BjgDPz40/zJtcBp0haH1gBvBE4x7Yl/YwUd7gROIA00RhV+7oVOAy4sVb8AIoVCE9KOhr4QX79HlKJFEII40/jWhlNBS7KcYQOYLbtqyXdCsyWdBzwV+BwANvP5CmGf5dzcY3tn+d9fRK4WNK5wJNAZWKz83P6g6Q7g6PqZahIgfBB0rSX5+RM/DanhRBCGCHbC4BXD5L+FOlX/mDbXEJqejow/S/AGwZJX04uUIooMrjdX4FDiu4whBDaWaOqjMaiGMsohBCKMi07LEURo14g5PqxecCjtg/OE+v8EJgOPAwcYfuZvO5ppJ51fcBJtq+rt+++frG0p/lDLW04safpxywtyFqSskaUXVHGYUsKZJc12mkpnf8aqY3vEJrxF/FR4L6q16eSumXvCNyQXyNpZ1LAYxdS06tv5MIkhBDGjEaNZTQWDVkgSNpK0vl5jA0k7Zyj30PKHdjeDnynKvlQUnds8uM7q9Ivs91j+yHgQWDvYqcRQghN4oJLCypyh3Ahqf3r1vn1H4Gi/RDOBU6h0m8vWaNbNlDplr2qi3W2KKetQdLxkuZJmtf73LKC2QghhAZp4wKhSAxhsu3ZuX6/Mh7GkDWtkg4mjb53Rx5fY8hNBklb62PN3b9nAay3w9ZevqL5cfGJXSUMClZS5dl6XSuHXimsk5UxWGLLaOXqoCKKXE1fyMOsGkDSPsBzBbbbFzhE0tuAScDGki4hd8vOgzYN7Ja9bdX204DHCp5HCCE0Rxu3MipSZfRxUvfnl0v6DfA9YMi5EGyfZnua7emkYPGNto9mdVdqWLNb9lXAUXlCh+2AHYG5wzmZEEIYbe0cVC5yh7CQNGbGK0jVOn9g3Vonncng3bIXSppNGoOjFzjRdsxmH0IYW1r0Yl9EkQLh1jyk6sJKgqQ7WT2a3pBszyGN5DdUt+yZwMyi+w0hhKZq4V//RdQsECS9hNTKZz1Jr2Z10HdjYP0m5G1ItujtbX5Arqe3+YHs7tI6akXAM4Q1jMcCAXgrcCwpuPuVqvTngU+NYp5CCGHMaudBA+pNoXkRaWjWd9u+ool5CiGEUIIio51eIentpCElJlWlf340MxZCCGPSOK0yAkDSt0gxgzeRhqA4jDHSHNQWK5c3vz7/hY7m/0WUNbhdWQORlRUzGU/6XM7gdi2tzYPKRf4iXmf7/cAzts8AXsuaHchCCGH8aOOhK4oUCC/mx2WStgZWAtuNXpZCCGEMa+MCoUh9y9WSNgW+CNxJOtXv1N8khBDajxinrYwqbP9HfnqFpKuBSbaLjGUUQgjtpc1jCIUispJeR5rhrCu/xvb3RjFfxfSBlzU/qLyyhKByT3c5s532uZyfQ+NpNq+yzjWM0HguECRdDLwcuIs0tSWkj6T8AiGEEJptPBcIwJ7Azrbb+GMIIYRi2rnKqMi96j3AS0Y7IyGE0BLGeSujycC9kuYCPZVE24eMWq6K6hcdy5o/+FpfZ/O/7eUTupt+TIBJE0uaMa2kMfX6eptfn19WDKGs4/b1t3DMxOO8lRHwudHORAghtIwW/fVfRJFmpzc1IyMhhNAK2jmGUG8+hFts7yfpedYsEwXY9sajnrsQQhhrxmOBYHu//LhR87IzPDJ0Lm/+hNf93c2v4F45sZx+COONSuhjUhaXNFl8Xyv3u2jhgHER9e4QNq+3oe2nG5+dEEIYu8Q4rTIC7iCVhQJeCjyTn28K/JUY4C6EMA61c/RvxZgAABaRSURBVIFQ897N9na2tweuA95he7LtLYCDgR83K4MhhDCmtHE/hCKVeXvZvqbywva1wBuH2kjSJElzJc2XtFDSGTl9d0m3SbpL0jxJe1dtc5qkByX9QdJbR3JCIYQwqtq4QCgSqVwi6d+BS0ineTTwVIHteoD9bS+V1A3cIula4PPAGbavlfQ24GxghqSdgaNIU3VuDfxK0k62a0+d1Q+dPTXfHTX93c0PxvVOKqenVknd0koL7qqETofjjfvKCWY3RJuPdlrkDuE9wBTgyrxMyWl1OVmaX3bnpVJ2VpqsbgI8lp8fClxmu8f2Q8CDwN6EEMJYMl7vECR1AqfZ/uhIdp63vwPYAfi67dsl/StwnaQvkQqk1+XVtwFuq9p8UU4buM/jgeMBujbZbCTZCiGEEWvnoSvq3iHk6prXjHTntvts7w5MA/aWtCvwIeBjtrcFPgacn1cf7D5yrXLW9izbe9res3P9DUaatRBCGBG52NKKisQQfi/pKuBHwAuVRNuFWxrZflbSHOAg4BigcsfxI1ZPx7kI2LZqs2msrk4alAwdJVRyd6xsfh2olpcTQyjrx5DK6rtUQgyho6t2mGw0ldUxzStLGrmwERpYHSRpEnAzMJF0Lb7c9um5D9gPSZOSPQwcYfuZvM1uwLdJ1e79pEY/y6v2eRWwve1d8+uJpLlrXkOK/R5p++FaeSryb7d53tH+wDvycnCBk52S52JG0nrAm4H7SRf5Siul/YEH8vOrgKMkTZS0HbAjMLdA/kIIoXkaF0OoNLx5FbA7cJCkfYBTgRts7wjckF8jqYvUuOcE27sAM6hq9yHpXcBS1nQc8IztHYBzgLPqZajI4HYfKHRqa5sKXJTjCB3AbNtXS3oW+Go+ueXkeIDthZJmA/cCvcCJdVsYhRBCkzWyp3KedGywhjeHki72ABcBc4BPAgcCC2zPz9uvau0paUPg46Tr6eyqwxzK6hGrLwfOk6RaE54VmUJzGvDfwL45s7cAH7W9aIiTXQC8epD0W6gRl7A9E5g5VJ5CCKEs6i9cIkyWNK/q9Szbs9bY1+ANb7ayvRjA9mJJW+bVdwIs6TpSa8/LbJ+d3/sP4MvAsgF52AZ4JO+rV9JzwBbAksEyXCSGcAFwKXB4fn10TntLgW1DCKF9DC+GsMT2nnV3l2pBds/V61fmhje1dAH7AXuRLvw3SLqDVKW/g+2PSZo+YJtCjXWqDzCUKbYvqHp9YW46Wj5D5/KhV2u0/hImL3NnOQHA3rKmLusuKZxdQoOB/kKhvMZzSZ3w1Mod0xidFkQDGt48LmlqvjuYCjyRV1sE3GR7CYCka4A9SNVOr5H0MOmavqWkObZnsLqxzqJcTb8JUHNg0iJ/iUskHS2pMy9FeyqHEEL7aVBQuU7Dm6tIrTHJjz/Nz68DdpO0fr64vxG41/Y3bW9tezrpDuKPuTBgwL4OA26sFT+AYncIHwTOI0WoAX6T00IIYdxp4B1CrYY3twKzJR1HGln6cADbz0j6CvA7UpFzje2fD3GM84GLJT1IujM4qt7KRVoZ/RU4ZKj1QghhXGhcK6NaDW+eAg6osc0lpKantfb5MLBr1evlrI7/DmnUWhk1Q1kd08qIW7ijtetdh6tvUkn16i08mddwqayRC1uZx/HQFdkFpHqorUlNmH6W00IIYVyp9ENo16ErihQIU2xfYLs3LxeS2sCGEML4YxdbWlC0MgohhGEY73cIHwSOAP4GLCY1XYpWRiGE8adok9MWLRBau5VRWUHlEmZpK4tKGhGzrM5LZXTWKqOjY5nU4iOUjeugsqSLKp0n8uvNJH13dLMVQghjk/qLLa2oSMe03Ww/W3mRO0es1XY2hBDanmnZgHERRWIIHZJWzVWZJ28oUpCEEELbaeegcpEL+5eB30q6nFQ+HsEYGaJahs4VZXzyza/fLqvDlEsa266seub+7hJmw2vxOvXhavnzbdGLfRFFgsrfy2N670+6Er7L9r2jnrMQQhhjGjlBzlhUqOonFwBRCIQQxjd7OBPktJyIBYQQwnC0b3nQ4gVCSf0QyviL6FwBvZPGzwB346ltfsfK8mI1YfjaucqoSD+ED1e3MgrlGE+FwXgThUELMdDvYksLKtJ25SXA7yTNlnSQpEJXJkmTJM2VNF/SQklnVL33EUl/yOlnV6WfJunB/N5bh386IYQwysb50BX/LukzwIHAB4DzJM0Gzrf9pzqb9gD7214qqRu4RdK1wHrAoaQObz2StgSQtDNpNp9dSENt/0rSTnkS6hBCGBPGdZURQJ6D82956QU2Ay6v/nU/2Da2l+aX3Xkx8CHgTNs9eb3KBNKHApfZ7rH9EPAgsPfwTymEEEaP+l1oaUVFZkw7iTRJ8xLgO8C/2V4pqQN4ADilzradwB3ADsDXbd8uaSfg9ZJmAsuBk23/jjT5zm1Vmy/KaQP3eTxwPMCE9Tej68USBiMrZeC1sv7AShrcrqSxYFq+09QwROxiBFq4OqiIIq2MJpM6o/2lOtF2v6SD622Yq3t2z4PjXSlp13zMzYB9gL1Ik0lvz+BXnrU+etuzgFkAG26+bRt/NSGEsSZ1TGvfy06RGMJn67x3X5GD2H5W0hzgINIv/x/naqi5kvpJhc4iYNuqzaYBjxXZfwghNE2LjmRaxKiNkCNpSmXYbEnrAW8G7gd+QhoGg1x9NIFUHXUVcJSkiZK2A3YE5o5W/kIIYSRkF1pa0Wh2TJsKXJTjCB3AbNtXS5oAfFfSPcAK4Jh8t7Awt166lxS4PnGoFkbqN13Lm19c945eOVpTd1l16iUdt29lObGLMjrElVWXHzGEEYgYwsjYXgCsNW+C7RXA0TW2mckYGUk1hBDW1rotiIpo7aErQgih2Vq0OqiIKBBCCKEot+70mEVEgRBCCMMRdwhjlKGzp/nFdRmzl7mUznCg3lIOS+eEco7bV8Jx+0qYpQ0iqDxi7VsetHiBEEIITab+9q0zigIhhBCKMm3dMS0KhBBCKEi0bqezIlq6QFA/dKxofnHd0h/aMPVNLCFgQlkDCIL6m3/csgbUixjCCEWBEEIIAYgCIYQQAhFDCCGEsFq0MgohhAA4qozGLJvOF1c2/bDqa340rn9iORHArhfLiXj29ZYTzFYJwezOzpJGdi3puG7lq45p6wKhnP+6EEJoVf0FlyFImiRprqT5khZKOiOnby7pekkP5MfNqrbZTdKtef278z7Wl/RzSffn9DOr1p8o6YeSHpR0u6Tp9fIUBUIIIQxDAyfI6QH2t/0qYHfgIEn7AKcCN9jeEbghv0ZSF3AJcILtXYAZQKWK5Eu2X0macmBfSf+U048DnrG9A3AOcFa9DEWBEEIIw2EXW4bcjW17aX7ZnRcDhwIX5fSLgHfm5wcCC2zPz9s/ZbvP9jLbv85pK4A7SVMQM2BflwMHSKpZV9jKtXmo36in+XXcnb3Nb2XQsaKk3ksl6ZhQTsykjFiNO8ZbDKGc4zaEDX2F//8nS5pX9XqW7VnVK+QZJe8AdgC+bvt2SVvZXpwO58WStsyr7wRY0nXAFOAy22cP2N+mwDuAr+akbYBH8r56JT0HbEGatngtLV0ghBBC0xUPKi+xvWf9XbkP2D1fyK+UtGud1buA/YC9gGXADZLusH0DrKpS+gHwNdt/ztsMVvrWPIGoMgohhOFoUJXRmrv0s8Ac4CDgcUlTAfLjE3m1RcBNtpfYXgZcA+xRtZtZwAO2z61KWwRsm/fVBWwCPF0rH1EghBBCUQb6XWwZgqQp+c4ASesBbwbuB64CjsmrHQP8ND+/DtgttyrqAt4I3Ju3/0/Sxf5fBxymel+HATfatUurqDIKIYTCDG5YDHEqcFGOI3QAs21fLelWYLak44C/AocD2H5G0leA36WMcI3tn0uaBnyaVJjcmWPG59n+DnA+cLGkB0l3BkfVy9CoFQiSJgE3AxPzcS63fXrV+ycDXwSm2F6S004jNZPqA06yfV3dg9h09DS/Y9p44q6SOoj1lBNU7lhRQlC5s5zP2GUFlUs634Ywwwkq19+VvYDUTHRg+lPAATW2uYTU9LQ6bRGDxwqwvZxcoBQxmncIlTa2SyV1A7dIutb2bZK2Bd5CKv0AkLQzqfTaBdga+JWknXLQJYQQxoboqTx8ddrYQuogcQprRrsPJTWj6rH9EPAgsPdo5S+EEEZkFILKY8Wo3rtJ6pR0FylKfn1uY3sI8Gilc0WVVe1ls0U5beA+j5c0T9K8Fb3LRi3vIYSwtoKFQYsWCKMaVB6kje1upODHgYOsXqi9bO7YMQtgkwlbmb8vXWujUddXQi1WZzl16mV1IVJXSdN5dZXQzmJCd/OPCfRPLOe4LmmgxoYwEMNfrxvbz0qaQ6oW2g6YnyPh00hR8b2pai+bTQMea0b+QgihsBb99V/EqFUZ1Whj+3vbW9qebns6qRDYw/bfSO1lj8qj820H7AjMHa38hRDC8OWhK4osLWg07xAGbWNba2XbCyXNJnW06AVOjBZGIYQxxeDG9UMYc0atQKjVxnbAOtMHvJ4JzCx8kP5+/EIElkPjqIwYwsQJzT8m0DFpYinHpaec2EXDFOiF3Kqip3IIIQxHG8cQokAIIYSi7GhlFEIIIYs7hBBCCGBcRj+kJmnpAsF9ffQvbX7HtHb+gxjvVEIHQHWVE2RVSUHlso7bEJXhr9tUSxcIIYTQdNHsNIQQggHHHUIIIYQ0cF3cIYQQQqC9Y4iqM73mmCfpSeAvZeejoMnAkrIz0QDtcB7tcA4Q5zFcL7M9ZV12IOkXpPwWscT2QetyvGZr6QKhlUiaZ3vPsvOxrtrhPNrhHCDOIzReC09uGkIIoZGiQAghhABEgdBMs8rOQIO0w3m0wzlAnEdosIghhBBCAOIOIYQQQhYFQgghBCAKhKaQ9LCkuyXdJWle2fkpQtJ3JT0h6Z6qtM0lXS/pgfy4WZl5LKLGeXxO0qP5+7hL0tvKzONQJG0r6deS7pO0UNJHc3pLfR91zqOlvo92FjGEJpD0MLCn7ZbpRCTpDcBS4Hu2d81pZwNP2z5T0qnAZrY/WWY+h1LjPD4HLLX9pTLzVpSkqcBU23dK2gi4A3gncCwt9H3UOY8jaKHvo53FHUIYlO2bgacHJB8KXJSfX0T6Zx7TapxHS7G92Pad+fnzwH3ANrTY91HnPMIYEQVCcxj4paQ7JB1fdmbWwVa2F0P65wa2LDk/6+LDkhbkKqUxXdVSTdJ04NXA7bTw9zHgPKBFv492EwVCc+xrew/gn4ATczVGKM83gZcDuwOLgS+Xm51iJG0IXAH8q+2/l52fkRrkPFry+2hHUSA0ge3H8uMTwJXA3uXmaMQez/XAlfrgJ0rOz4jYftx2n+1+4H9oge9DUjfpIvp92z/OyS33fQx2Hq34fbSrKBBGmaQNcgANSRsABwL31N9qzLoKOCY/Pwb4aYl5GbHKRTT7Z8b49yFJwPnAfba/UvVWS30ftc6j1b6PdhatjEaZpO1JdwWQ5p+41PbMErNUiKQfADNIQ/0+DpwO/ASYDbwU+CtwuO0xHbCtcR4zSNUTBh4G/m+lLn4skrQf8L/A3UBldpZPkerfW+b7qHMe76GFvo92FgVCCCEEIKqMQgghZFEghBBCAKJACCGEkEWBEEIIAYgCIYTQQJJOlmRJa01EX2twu/zeoAPcSZou6cWq9G8VyMOFkh6q2mb3xp5l+4oCIYyqPNLr5Pz8t+uwn2Mlbd2gPE2RdLuk30t6fSP2WbXvQ/JAcyPZ9lMDXo/48xpNkmZIunCQ9G2Bt5CawA6mF/iE7f8D7EPqtb9z1fvn2N49L9dUpf+pKv2Egtn8t6pt7iq4zbgXBUJoGEld9d63/bp12P2xQEMKBOAA4H7br7b9v8PduN552r7K9pkjzNcaBcI6fl5lOAc4hdSfYC2NHtxO0oGSbpV0p6Qf5SExwjqIAqENSdorDxQ2KfeUXihp10HWe39eb76ki3PayyTdkNNvkPTSIdIvlPQVSb8GzpK0haRf5l/f3wZUdbyl+XGGpDmSLpd0v6Tv516sSPqspN9JukfSLCWHAXsC389VAOtJeo2km5QGDLxuQG9XauU5Vx+cDbytsq8B2zws6SxJc/OyQ43z3FzST/K+b5O0W17vWEnn5edTJF2Rz+d3kvbN6RtKukBpjowFkt4t6UxgvZyn7w/4vCTpi/kzuVvSkUN9js0m6RDgUdvzC64/nTUHt4PaA9xtl/+eblK+o1O66/x34M15nLB5wMertpmZ93WOpIkjP7NxxnYsbbgA/wl8Cfg6cNog7+8C/AGYnF9vnh9/BhyTn38Q+MkQ6RcCVwOd+fXXgM/m528n/VqsHGNpfpwBPAdMI/0ouRXYrzof+fnFwDvy8zmkOSUAuoHfAlPy6yOB7w5yjrXyfCxwXo3P7WHg0/n5+4Gra5znfwOn5+f7A3cN3DdwadV5vZQ0ZAPAWcC5VcfcrPrzqUqvfF7vBq4HOoGtSFUyU+t9jqP0N3U7cBfwIGlI8bvycmh+b5Oqz3Bynf1sSJoL4V1VaVvl8+sAZla+T2AisEV+/hrgEWBj4GBgSVUe7gXOz+tNJf0QmUgaFvyzZf8/tspSegZiGaUvFiYA8/M/aucg738EmDlI+hKgOz/vBpYMkX5h5aKbX98FbF/1+mkGLxCur1rnm8DR+fm7c57vBh4FTs3pc1hdIOwK/L3qYnA38MthnMux1C8Qtq/a5qka5/n7Aef5CLAJaxYIT1Tl8a58PpWJYXYc5Ni1CoRzgA9WpV8MHFLvcxzlv60ZwIVVr/8hn+vDeeklFVovGWTbbuA64ON19j8duKfGe3NId4vvAH5QMK9Xj/Zn0i5L3Trf0NI2J/0S6wYmAS8MeF/UqOsdoNY61ekD911kvz1Vz/uALkmTgG+QLvyPKM1sNmmQbQUstP3aAscZbr4GrlfrPAermhm4/w7gtbZfrE7M1TrDGTOmXjXQWp/jMPbbELbvpmouBtWYITCf92CD9CFpqlePX7RqgDtJU0izwvUpjQu2I/Bn4C/A1yXtYPtBSesD02z/sbKvfLx3EoPlFRYxhPY1C/gM8H1SFcVANwBHSNoC0vy8Of23wFH5+XuBW4ZIH+jm/D6S/gkYzmQnlYv/EqUA4WFV7z1P+nUNqapriqTX5uN0S9plkP0VzfNAR1Y93lpjnerznEG6+xg4R8EvgQ9XXmh188eB6ZXPaKXS8NCDHetISZ35AvkGYG7BcymVpK0lVVoM7Qu8D9hfa8+ffHYlpgK8CfhYTn8DsEDSfOBy4ATbT9t+knQ39oO8zW3AK/M235d0N+nOcTKp+jQUEHcIbUjS+4Fe25dK6gR+K2l/2zdW1rG9UNJM4CZJfaQqkGOBk4DvSvo34EngA3mTWukDnUH6J70TuInaTRDXYvtZSf9D+kd+GPhd1dsXAt+S9CLwWlJh8TVJm5D+js8FFg7YZdE8DzRR0u2kH0zvqbHO54AL8sVoGauHoYbVv/5PIv2KXZDzeDNwAukC9XVJ95B+1Z8B/JhUiC+QdKft91bt78p8zvPzvk+x/TdJr6QEtueQqm5qvT+96vljwNvy81uocbdj+3010q8gzZ8w2Hs3AnsNkr5/rbyF+mK00xCq1KruGMb2nwA2tn16QzMWQhPEHUIIDSLpBNJd1rtKzkoIIxJ3CCGEEIAIKocQQsiiQAghhABEgRBCCCGLAiGEEAIQBUIIIYTs/wGQ/a87oKSV1wAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -210,6 +199,129 @@ "source": [ "clipped.plot()" ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "clipped.rio.to_raster(\"clipped.tif\", compress='LZMA', tiled=True, dtype=\"int32\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Clip using a GeoDataFrame" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "import geopandas\n", + "from shapely.geometry import box, mapping" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "geodf = geopandas.GeoDataFrame(\n", + " geometry=[\n", + " box(425499.18381405267, 4615331.540546387, 425526.18381405267, 4615478.540546387)\n", + " ],\n", + " crs=xds.rio.crs.to_dict()\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "clipped = xds.rio.clip(geodf.geometry.apply(mapping), geodf.crs, drop=False, invert=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "clipped.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "clipped.rio.to_raster(\"clipped_invert.tif\", compress='LZMA', tiled=True, dtype=\"int32\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[30267., 30252., 30238., ..., nan, nan, nan],\n", + " [30266., 30251., 30239., ..., nan, nan, nan],\n", + " [30267., 30253., 30243., ..., nan, nan, nan],\n", + " ...,\n", + " [30853., 30848., 30844., ..., nan, nan, nan],\n", + " [30849., 30844., 30840., ..., nan, nan, nan],\n", + " [30844., 30839., 30834., ..., nan, nan, nan]]])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "umpoer" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/sphinx/history.rst b/sphinx/history.rst index 83f07e99..ffc73aec 100644 --- a/sphinx/history.rst +++ b/sphinx/history.rst @@ -1,6 +1,10 @@ History ======= +0.0.9 +----- + - Add `rioxarray.open_rasterio` (issue #7) + 0.0.8 ----- - Fix setting nodata in _add_attrs_proj (pull #30) diff --git a/sphinx/rioxarray.rst b/sphinx/rioxarray.rst index f257e649..e01e0058 100644 --- a/sphinx/rioxarray.rst +++ b/sphinx/rioxarray.rst @@ -1,6 +1,12 @@ rioxarray package ================= +rioxarray.open_rasterio +----------------------- + +.. autofunction:: rioxarray.open_rasterio + + rioxarray.rioxarray module -------------------------- diff --git a/test/conftest.py b/test/conftest.py index a499e1a5..8522e8db 100644 --- a/test/conftest.py +++ b/test/conftest.py @@ -1,5 +1,74 @@ import os +from numpy.testing import assert_almost_equal, assert_array_equal +import xarray +from rioxarray.rioxarray import UNWANTED_RIO_ATTRS + TEST_DATA_DIR = os.path.join(os.path.dirname(__file__), "test_data") TEST_INPUT_DATA_DIR = os.path.join(TEST_DATA_DIR, "input") TEST_COMPARE_DATA_DIR = os.path.join(TEST_DATA_DIR, "compare") + + +def _assert_xarrays_equal(input_xarray, compare_xarray, precision=7): + # xarray.testing.assert_equal(input_xarray, compare_xarray) + def assert_attrs_equal(input_xr, compare_xr): + """check attrubutes that matter""" + if isinstance(input_xr, xarray.Dataset): + assert "creation_date" in input_xr.attrs + + for attr in compare_xr.attrs: + if ( + attr != "_FillValue" + and attr not in UNWANTED_RIO_ATTRS + and attr != "creation_date" + ): + try: + assert input_xr.attrs[attr] == compare_xr.attrs[attr] + except ValueError: + assert_almost_equal(input_xr.attrs[attr], compare_xr.attrs[attr]) + + assert_attrs_equal(input_xarray, compare_xarray) + if hasattr(input_xarray, "variables"): + # check coordinates + for coord in input_xarray.coords: + if coord in "xy": + assert_almost_equal( + input_xarray[coord].values, compare_xarray[coord].values + ) + else: + assert ( + input_xarray[coord].values == compare_xarray[coord].values + ).all() + + for var in input_xarray.rio.vars: + try: + _assert_xarrays_equal(input_xarray[var], compare_xarray[var]) + except AssertionError: + print("Error with variable {}".format(var)) + raise + else: + try: + assert_almost_equal( + input_xarray.values, compare_xarray.values, decimal=precision + ) + except AssertionError: + where_diff = input_xarray.values != compare_xarray.values + print(input_xarray.values[where_diff]) + print(compare_xarray.values[where_diff]) + raise + assert_attrs_equal(input_xarray, compare_xarray) + + compare_fill_value = compare_xarray.attrs.get( + "_FillValue", compare_xarray.encoding.get("_FillValue") + ) + input_fill_value = input_xarray.attrs.get( + "_FillValue", input_xarray.encoding.get("_FillValue") + ) + assert_array_equal([input_fill_value], [compare_fill_value]) + assert "grid_mapping" in compare_xarray.attrs + assert ( + input_xarray[input_xarray.attrs["grid_mapping"]] + == compare_xarray[compare_xarray.attrs["grid_mapping"]] + ) + for unwanted_attr in UNWANTED_RIO_ATTRS: + assert unwanted_attr not in input_xarray.attrs diff --git a/test/integration/test_integration__io.py b/test/integration/test_integration__io.py new file mode 100644 index 00000000..c0b147e1 --- /dev/null +++ b/test/integration/test_integration__io.py @@ -0,0 +1,63 @@ +import os + +import numpy +from numpy.testing import assert_almost_equal + +import rioxarray +from test.conftest import TEST_COMPARE_DATA_DIR, _assert_xarrays_equal + + +def test_open_rasterio_mask_chunk_clip(): + with rioxarray.open_rasterio( + os.path.join(TEST_COMPARE_DATA_DIR, "small_dem_3m_merged.tif"), + masked=True, + chunks=True, + ) as xdi: + assert str(type(xdi.data)) == "" + assert xdi.chunks == ((1,), (245,), (574,)) + assert numpy.isnan(xdi.values).sum() == 52119 + assert xdi.encoding == {"_FillValue": 0.0} + attrs = dict(xdi.attrs) + assert_almost_equal( + attrs.pop("transform"), + (3.0, 0.0, 425047.68381405267, 0.0, -3.0, 4615780.040546387), + ) + assert attrs == { + "grid_mapping": "spatial_ref", + "offsets": (0.0,), + "scales": (1.0,), + } + + # get subset for testing + subset = xdi.isel(x=slice(150, 160), y=slice(100, 150)) + comp_subset = subset.isel(x=slice(1, None), y=slice(1, None)) + # add transform for test + comp_subset.attrs["transform"] = tuple(comp_subset.rio.transform(recalc=True)) + + geometries = [ + { + "type": "Polygon", + "coordinates": [ + [ + [subset.x.values[0], subset.y.values[-1]], + [subset.x.values[0], subset.y.values[0]], + [subset.x.values[-1], subset.y.values[0]], + [subset.x.values[-1], subset.y.values[-1]], + [subset.x.values[0], subset.y.values[-1]], + ] + ], + } + ] + + # test data array + clipped = xdi.rio.clip(geometries, comp_subset.rio.crs) + _assert_xarrays_equal(clipped, comp_subset) + assert clipped.encoding == {"_FillValue": 0.0} + + # test dataset + clipped_ds = xdi.to_dataset(name="test_data").rio.clip( + geometries, subset.rio.crs + ) + comp_subset_ds = comp_subset.to_dataset(name="test_data") + _assert_xarrays_equal(clipped_ds, comp_subset_ds) + assert clipped_ds.test_data.encoding == {"_FillValue": 0.0} diff --git a/test/integration/test_integration_rioxarray.py b/test/integration/test_integration_rioxarray.py index 7a5fc22a..c9af0ba4 100644 --- a/test/integration/test_integration_rioxarray.py +++ b/test/integration/test_integration_rioxarray.py @@ -8,14 +8,19 @@ from numpy.testing import assert_almost_equal, assert_array_equal from rasterio.crs import CRS +import rioxarray from rioxarray.exceptions import ( DimensionError, MissingCRS, NoDataInBounds, OneDimensionalRaster, ) -from rioxarray.rioxarray import UNWANTED_RIO_ATTRS, _make_coords -from test.conftest import TEST_COMPARE_DATA_DIR, TEST_INPUT_DATA_DIR +from rioxarray.rioxarray import _make_coords +from test.conftest import ( + TEST_COMPARE_DATA_DIR, + TEST_INPUT_DATA_DIR, + _assert_xarrays_equal, +) @pytest.fixture(params=[xarray.open_dataset, xarray.open_dataarray]) @@ -113,71 +118,6 @@ def _del_attr(input_xr, attr): _mod_attr(input_xr, attr, remove=True) -def _assert_xarrays_equal(input_xarray, compare_xarray, precision=7): - # xarray.testing.assert_equal(input_xarray, compare_xarray) - def assert_attrs_equal(input_xr, compare_xr): - """check attrubutes that matter""" - if isinstance(input_xr, xarray.Dataset): - assert "creation_date" in input_xr.attrs - - for attr in compare_xr.attrs: - if ( - attr != "_FillValue" - and attr not in UNWANTED_RIO_ATTRS - and attr != "creation_date" - ): - try: - assert input_xr.attrs[attr] == compare_xr.attrs[attr] - except ValueError: - assert_almost_equal(input_xr.attrs[attr], compare_xr.attrs[attr]) - - assert_attrs_equal(input_xarray, compare_xarray) - if hasattr(input_xarray, "variables"): - # check coordinates - for coord in input_xarray.coords: - if coord in "xy": - assert_almost_equal( - input_xarray[coord].values, compare_xarray[coord].values - ) - else: - assert ( - input_xarray[coord].values == compare_xarray[coord].values - ).all() - - for var in input_xarray.rio.vars: - try: - _assert_xarrays_equal(input_xarray[var], compare_xarray[var]) - except AssertionError: - print("Error with variable {}".format(var)) - raise - else: - try: - assert_almost_equal( - input_xarray.values, compare_xarray.values, decimal=precision - ) - except AssertionError: - where_diff = input_xarray.values != compare_xarray.values - print(input_xarray.values[where_diff]) - print(compare_xarray.values[where_diff]) - raise - assert_attrs_equal(input_xarray, compare_xarray) - - compare_fill_value = compare_xarray.attrs.get( - "_FillValue", compare_xarray.encoding.get("_FillValue") - ) - input_fill_value = input_xarray.attrs.get( - "_FillValue", input_xarray.encoding.get("_FillValue") - ) - assert_array_equal([input_fill_value], [compare_fill_value]) - assert "grid_mapping" in compare_xarray.attrs - assert ( - input_xarray[input_xarray.attrs["grid_mapping"]] - == compare_xarray[compare_xarray.attrs["grid_mapping"]] - ) - for unwanted_attr in UNWANTED_RIO_ATTRS: - assert unwanted_attr not in input_xarray.attrs - - @pytest.fixture(params=[xarray.open_dataset, xarray.open_dataarray]) def modis_clip(request, tmpdir): return dict( @@ -257,8 +197,9 @@ def test_clip_box__one_dimension_error(modis_clip): ) -def test_clip_geojson(): - with xarray.open_rasterio( +@pytest.fixture(params=[xarray.open_rasterio, rioxarray.open_rasterio]) +def test_clip_geojson(request): + with request.param( os.path.join(TEST_COMPARE_DATA_DIR, "small_dem_3m_merged.tif") ) as xdi: # get subset for testing @@ -301,8 +242,9 @@ def test_clip_geojson(): @pytest.mark.parametrize( "invert, expected_sum", [(False, 2150801411), (True, 535727386)] ) -def test_clip_geojson__no_drop(invert, expected_sum): - with xarray.open_rasterio( +@pytest.fixture(params=[xarray.open_rasterio, rioxarray.open_rasterio]) +def test_clip_geojson__no_drop(request, invert, expected_sum): + with request.param( os.path.join(TEST_COMPARE_DATA_DIR, "small_dem_3m_merged.tif") ) as xdi: geometries = [ @@ -460,8 +402,9 @@ def test_reproject__no_nodata(modis_reproject): _assert_xarrays_equal(mds_repr, mdc) -def test_reproject__scalar_coord(): - with xarray.open_rasterio( +@pytest.fixture(params=[xarray.open_rasterio, rioxarray.open_rasterio]) +def test_reproject__scalar_coord(request): + with request.param( os.path.join(TEST_COMPARE_DATA_DIR, "small_dem_3m_merged.tif") ) as xdi: xdi_repr = xdi.squeeze().rio.reproject("epsg:3395") @@ -524,8 +467,9 @@ def test_reproject_match__no_transform_nodata(modis_reproject_match): _assert_xarrays_equal(mds_repr, mdc) -def test_make_src_affine(modis_reproject): - with xarray.open_dataarray(modis_reproject["input"]) as xdi, xarray.open_rasterio( +@pytest.fixture(params=[xarray.open_rasterio, rioxarray.open_rasterio]) +def test_make_src_affine(request, modis_reproject): + with xarray.open_dataarray(modis_reproject["input"]) as xdi, request.param( modis_reproject["input"] ) as xri: @@ -564,8 +508,9 @@ def test_make_src_affine__single_point(): assert_array_equal(attribute_transform, calculated_transform) -def test_make_coords__calc_trans(modis_reproject): - with xarray.open_dataarray(modis_reproject["input"]) as xdi, xarray.open_rasterio( +@pytest.fixture(params=[xarray.open_rasterio, rioxarray.open_rasterio]) +def test_make_coords__calc_trans(request, modis_reproject): + with xarray.open_dataarray(modis_reproject["input"]) as xdi, request.param( modis_reproject["input"] ) as xri: # calculate coordinates from the calculated transform @@ -587,8 +532,9 @@ def test_make_coords__calc_trans(modis_reproject): assert_array_equal(xri.coords["y"].values, calc_coords_calc_transr["y"].values) -def test_make_coords__attr_trans(modis_reproject): - with xarray.open_dataarray(modis_reproject["input"]) as xdi, xarray.open_rasterio( +@pytest.fixture(params=[xarray.open_rasterio, rioxarray.open_rasterio]) +def test_make_coords__attr_trans(request, modis_reproject): + with xarray.open_dataarray(modis_reproject["input"]) as xdi, request.param( modis_reproject["input"] ) as xri: # calculate coordinates from the attribute transform @@ -773,7 +719,8 @@ def test_to_raster_3d(tmpdir): assert_array_equal(rds.read(), xds.values) -def test_to_raster__preserve_profile__none_nodata(tmpdir): +@pytest.fixture(params=[xarray.open_rasterio, rioxarray.open_rasterio]) +def test_to_raster__preserve_profile__none_nodata(request, tmpdir): tmp_raster = tmpdir.join("output_profile.tif") input_raster = tmpdir.join("input_profile.tif") @@ -794,7 +741,7 @@ def test_to_raster__preserve_profile__none_nodata(tmpdir): ) as rds: rds.write(numpy.empty((1, 512, 512), dtype=numpy.float32)) - with xarray.open_rasterio(str(input_raster)) as mda: + with request.param(str(input_raster)) as mda: mda.rio.to_raster(str(tmp_raster)) with rasterio.open(str(tmp_raster)) as rds, rasterio.open(str(input_raster)) as rdc: From 3891f3b828d877c46e0cefabbe68da91701c0fd3 Mon Sep 17 00:00:00 2001 From: snowman2 Date: Tue, 23 Jul 2019 15:49:28 -0500 Subject: [PATCH 2/9] set the channel priority as strict --- .travis.yml | 1 + appveyor.yml | 1 + 2 files changed, 2 insertions(+) diff --git a/.travis.yml b/.travis.yml index e72f5e54..3ca95010 100644 --- a/.travis.yml +++ b/.travis.yml @@ -29,6 +29,7 @@ before_install: - conda update conda python - conda config --add channels conda-forge - conda config --add channels conda-forge +- conda config --set channel_priority strict # Create conda environment - conda create -n test python=$PYTHON_VERSION rasterio=1.0.* scipy xarray netcdf4 dask - source activate test diff --git a/appveyor.yml b/appveyor.yml index d677a7b6..90bc5637 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -12,6 +12,7 @@ install: - conda config --set always_yes yes - conda config --add channels conda-forge - conda config --add channels conda-forge + - conda config --set channel_priority strict #----------------------------------------------------------------------------- # Create conda environment From fa65f8e4c443a0ae1c422a1829e50e8887ca120f Mon Sep 17 00:00:00 2001 From: snowman2 Date: Tue, 23 Jul 2019 15:51:12 -0500 Subject: [PATCH 3/9] undo strict for windows --- appveyor.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/appveyor.yml b/appveyor.yml index 90bc5637..d677a7b6 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -12,7 +12,6 @@ install: - conda config --set always_yes yes - conda config --add channels conda-forge - conda config --add channels conda-forge - - conda config --set channel_priority strict #----------------------------------------------------------------------------- # Create conda environment From fecee634292b57ecc4d6a5ad1ec8efdab2e1d5cb Mon Sep 17 00:00:00 2001 From: snowman2 Date: Tue, 23 Jul 2019 16:05:55 -0500 Subject: [PATCH 4/9] updates based on recommendations from gruca --- rioxarray/_io.py | 44 +++++++++++++++++++------------------------- 1 file changed, 19 insertions(+), 25 deletions(-) diff --git a/rioxarray/_io.py b/rioxarray/_io.py index bdb484ba..ec54ca5b 100644 --- a/rioxarray/_io.py +++ b/rioxarray/_io.py @@ -19,18 +19,13 @@ from xarray.backends.file_manager import CachingFileManager from xarray.backends.locks import SerializableLock +from rioxarray.exceptions import RioXarrayError from rioxarray.rioxarray import affine_to_coords # TODO: should this be GDAL_LOCK instead? RASTERIO_LOCK = SerializableLock() -_ERROR_MSG = ( - "The kind of indexing operation you are trying to do is not " - "valid on rasterio files. Try to load your data with ds.load()" - "first." -) - class RasterioArrayWrapper(BackendArray): """A wrapper around rasterio dataset objects""" @@ -83,7 +78,8 @@ def _get_indexer(self, key): -------- indexing.decompose_indexer """ - assert len(key) == 3, "rasterio datasets should always be 3D" + if len(key) != 3: + raise RioXarrayError("rasterio datasets should always be 3D") # bands cannot be windowed but they can be listed band_key = key[0] @@ -229,7 +225,7 @@ def open_rasterio( dask's multithreaded backend. masked : bool, optional If True, read the mask and to set values to NaN. Defaults to False. -return + Returns ------- data : DataArray @@ -275,27 +271,25 @@ def open_rasterio( coords["band"] = np.asarray(riods.indexes) # Get coordinates - if LooseVersion(rasterio.__version__) < "1.0": + if LooseVersion(rasterio.__version__) < LooseVersion("1.0"): transform = riods.affine else: transform = riods.transform - if transform.is_rectilinear: + + parse = True if (parse_coordinates is None) else parse_coordinates + if transform.is_rectilinear and parse: # 1d coordinates - parse = True if parse_coordinates is None else parse_coordinates - if parse: - coords.update(affine_to_coords(riods.transform, riods.width, riods.height)) - else: + coords.update(affine_to_coords(riods.transform, riods.width, riods.height)) + elif parse: # 2d coordinates - parse = False if (parse_coordinates is None) else parse_coordinates - if parse: - warnings.warn( - "The file coordinates' transformation isn't " - "rectilinear: xarray won't parse the coordinates " - "in this case. Set `parse_coordinates=False` to " - "suppress this warning.", - RuntimeWarning, - stacklevel=3, - ) + warnings.warn( + "The file coordinates' transformation isn't " + "rectilinear: xarray won't parse the coordinates " + "in this case. Set `parse_coordinates=False` to " + "suppress this warning.", + RuntimeWarning, + stacklevel=3, + ) # Attributes attrs = dict() @@ -369,7 +363,7 @@ def open_rasterio( from dask.array.core import normalize_chunks import dask - if dask.__version__ < "0.18.0": + if LooseVersion(dask.__version__) < LooseVersion("0.18.0"): msg = ( "Automatic chunking requires dask.__version__ >= 0.18.0 . " "You currently have version %s" % dask.__version__ From 5feefd08cbb3a58f51bd817350c75ad918e49bb0 Mon Sep 17 00:00:00 2001 From: snowman2 Date: Wed, 24 Jul 2019 07:57:26 -0500 Subject: [PATCH 5/9] added dtype check --- test/integration/test_integration__io.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/test/integration/test_integration__io.py b/test/integration/test_integration__io.py index c0b147e1..3d15ba25 100644 --- a/test/integration/test_integration__io.py +++ b/test/integration/test_integration__io.py @@ -13,6 +13,8 @@ def test_open_rasterio_mask_chunk_clip(): masked=True, chunks=True, ) as xdi: + assert str(xdi.dtype) == "float64" + assert str(xdi.data.dtype) == "float64" assert str(type(xdi.data)) == "" assert xdi.chunks == ((1,), (245,), (574,)) assert numpy.isnan(xdi.values).sum() == 52119 From a11d95ad73c300bbdb6a10639899559587ec7a97 Mon Sep 17 00:00:00 2001 From: snowman2 Date: Wed, 24 Jul 2019 07:58:33 -0500 Subject: [PATCH 6/9] use np.float64 instead of string init for dtype --- rioxarray/_io.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rioxarray/_io.py b/rioxarray/_io.py index ec54ca5b..2d7bdf00 100644 --- a/rioxarray/_io.py +++ b/rioxarray/_io.py @@ -48,7 +48,7 @@ def __init__(self, manager, lock, vrt_params=None, masked=False): if not np.all(np.asarray(dtypes) == dtypes[0]): raise ValueError("All bands should have the same dtype") if self.masked: - self._dtype = np.dtype("float64") + self._dtype = np.float64 else: self._dtype = np.dtype(dtypes[0]) From 75e054d6326cbdbe2d31791d4614237d4533d505 Mon Sep 17 00:00:00 2001 From: snowman2 Date: Wed, 24 Jul 2019 07:59:20 -0500 Subject: [PATCH 7/9] one line if for dtype --- rioxarray/_io.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/rioxarray/_io.py b/rioxarray/_io.py index 2d7bdf00..55f32887 100644 --- a/rioxarray/_io.py +++ b/rioxarray/_io.py @@ -47,10 +47,8 @@ def __init__(self, manager, lock, vrt_params=None, masked=False): dtypes = riods.dtypes if not np.all(np.asarray(dtypes) == dtypes[0]): raise ValueError("All bands should have the same dtype") - if self.masked: - self._dtype = np.float64 - else: - self._dtype = np.dtype(dtypes[0]) + + self._dtype = np.float64 if self.masked else np.dtype(dtypes[0]) @property def dtype(self): From 5a9627bb6fc68a4c61ab7946304271cc115c2d68 Mon Sep 17 00:00:00 2001 From: snowman2 Date: Wed, 24 Jul 2019 08:43:06 -0500 Subject: [PATCH 8/9] added tests from xarray backends --- test/integration/test_integration__io.py | 580 +++++++++++++++++++++++ 1 file changed, 580 insertions(+) diff --git a/test/integration/test_integration__io.py b/test/integration/test_integration__io.py index 3d15ba25..6851757f 100644 --- a/test/integration/test_integration__io.py +++ b/test/integration/test_integration__io.py @@ -1,7 +1,19 @@ +import contextlib +import itertools import os +import pickle +import shutil +import sys +import tempfile +import mock import numpy +import numpy as np from numpy.testing import assert_almost_equal +from xarray.testing import assert_allclose, assert_identical, assert_equal +import pytest +import xarray as xr +from xarray import DataArray import rioxarray from test.conftest import TEST_COMPARE_DATA_DIR, _assert_xarrays_equal @@ -63,3 +75,571 @@ def test_open_rasterio_mask_chunk_clip(): comp_subset_ds = comp_subset.to_dataset(name="test_data") _assert_xarrays_equal(clipped_ds, comp_subset_ds) assert clipped_ds.test_data.encoding == {"_FillValue": 0.0} + + +############################################################################## +# From xarray tests +############################################################################## +ON_WINDOWS = sys.platform == "win32" +_counter = itertools.count() + + +@contextlib.contextmanager +def create_tmp_file(suffix=".nc", allow_cleanup_failure=False): + temp_dir = tempfile.mkdtemp() + path = os.path.join(temp_dir, "temp-%s%s" % (next(_counter), suffix)) + try: + yield path + finally: + try: + shutil.rmtree(temp_dir) + except OSError: + if not allow_cleanup_failure: + raise + + +@contextlib.contextmanager +def create_tmp_geotiff( + nx=4, + ny=3, + nz=3, + transform=None, + transform_args=[5000, 80000, 1000, 2000.0], + crs={"units": "m", "no_defs": True, "ellps": "WGS84", "proj": "utm", "zone": 18}, + open_kwargs=None, + additional_attrs=None, +): + # yields a temporary geotiff file and a corresponding expected DataArray + import rasterio + from rasterio.transform import from_origin + + if open_kwargs is None: + open_kwargs = {} + + with create_tmp_file(suffix=".tif", allow_cleanup_failure=ON_WINDOWS) as tmp_file: + # allow 2d or 3d shapes + if nz == 1: + data_shape = ny, nx + write_kwargs = {"indexes": 1} + else: + data_shape = nz, ny, nx + write_kwargs = {} + data = np.arange(nz * ny * nx, dtype=rasterio.float32).reshape(*data_shape) + if transform is None: + transform = from_origin(*transform_args) + if additional_attrs is None: + additional_attrs = { + "descriptions": tuple("d{}".format(n + 1) for n in range(nz)), + "units": tuple("u{}".format(n + 1) for n in range(nz)), + } + with rasterio.open( + tmp_file, + "w", + driver="GTiff", + height=ny, + width=nx, + count=nz, + crs=crs, + transform=transform, + dtype=rasterio.float32, + **open_kwargs + ) as s: + for attr, val in additional_attrs.items(): + setattr(s, attr, val) + s.write(data, **write_kwargs) + dx, dy = s.res[0], -s.res[1] + + a, b, c, d = transform_args + data = data[np.newaxis, ...] if nz == 1 else data + expected = DataArray( + data, + dims=("band", "y", "x"), + coords={ + "band": np.arange(nz) + 1, + "y": -np.arange(ny) * d + b + dy / 2, + "x": np.arange(nx) * c + a + dx / 2, + }, + ) + yield tmp_file, expected + + +class TestRasterio: + def test_serialization(self): + with create_tmp_geotiff(additional_attrs={}) as (tmp_file, expected): + # Write it to a netcdf and read again (roundtrip) + with xr.open_rasterio(tmp_file) as rioda: + with create_tmp_file(suffix=".nc") as tmp_nc_file: + rioda.to_netcdf(tmp_nc_file) + with xr.open_dataarray(tmp_nc_file) as ncds: + assert_identical(rioda, ncds) + + def test_utm(self): + with create_tmp_geotiff() as (tmp_file, expected): + with xr.open_rasterio(tmp_file) as rioda: + assert_allclose(rioda, expected) + assert rioda.attrs["scales"] == (1.0, 1.0, 1.0) + assert rioda.attrs["offsets"] == (0.0, 0.0, 0.0) + assert rioda.attrs["descriptions"] == ("d1", "d2", "d3") + assert rioda.attrs["units"] == ("u1", "u2", "u3") + assert isinstance(rioda.attrs["crs"], str) + assert isinstance(rioda.attrs["res"], tuple) + assert isinstance(rioda.attrs["is_tiled"], np.uint8) + assert isinstance(rioda.attrs["transform"], tuple) + assert len(rioda.attrs["transform"]) == 6 + np.testing.assert_array_equal( + rioda.attrs["nodatavals"], [np.NaN, np.NaN, np.NaN] + ) + + # Check no parse coords + with xr.open_rasterio(tmp_file, parse_coordinates=False) as rioda: + assert "x" not in rioda.coords + assert "y" not in rioda.coords + + def test_non_rectilinear(self): + from rasterio.transform import from_origin + + # Create a geotiff file with 2d coordinates + with create_tmp_geotiff( + transform=from_origin(0, 3, 1, 1).rotation(45), crs=None + ) as (tmp_file, _): + # Default is to not parse coords + with xr.open_rasterio(tmp_file) as rioda: + assert "x" not in rioda.coords + assert "y" not in rioda.coords + assert "crs" not in rioda.attrs + assert rioda.attrs["scales"] == (1.0, 1.0, 1.0) + assert rioda.attrs["offsets"] == (0.0, 0.0, 0.0) + assert rioda.attrs["descriptions"] == ("d1", "d2", "d3") + assert rioda.attrs["units"] == ("u1", "u2", "u3") + assert isinstance(rioda.attrs["res"], tuple) + assert isinstance(rioda.attrs["is_tiled"], np.uint8) + assert isinstance(rioda.attrs["transform"], tuple) + assert len(rioda.attrs["transform"]) == 6 + + # See if a warning is raised if we force it + with pytest.warns(Warning, match="transformation isn't rectilinear"): + with xr.open_rasterio(tmp_file, parse_coordinates=True) as rioda: + assert "x" not in rioda.coords + assert "y" not in rioda.coords + + def test_platecarree(self): + with create_tmp_geotiff( + 8, + 10, + 1, + transform_args=[1, 2, 0.5, 2.0], + crs="+proj=latlong", + open_kwargs={"nodata": -9765}, + ) as (tmp_file, expected): + with xr.open_rasterio(tmp_file) as rioda: + assert_allclose(rioda, expected) + assert rioda.attrs["scales"] == (1.0,) + assert rioda.attrs["offsets"] == (0.0,) + assert isinstance(rioda.attrs["descriptions"], tuple) + assert isinstance(rioda.attrs["units"], tuple) + assert isinstance(rioda.attrs["crs"], str) + assert isinstance(rioda.attrs["res"], tuple) + assert isinstance(rioda.attrs["is_tiled"], np.uint8) + assert isinstance(rioda.attrs["transform"], tuple) + assert len(rioda.attrs["transform"]) == 6 + np.testing.assert_array_equal(rioda.attrs["nodatavals"], [-9765.0]) + + def test_notransform(self): + # regression test for https://github.com/pydata/xarray/issues/1686 + import rasterio + import warnings + + # Create a geotiff file + with warnings.catch_warnings(): + # rasterio throws a NotGeoreferencedWarning here, which is + # expected since we test rasterio's defaults in this case. + warnings.filterwarnings( + "ignore", + category=UserWarning, + message="Dataset has no geotransform set", + ) + with create_tmp_file(suffix=".tif") as tmp_file: + # data + nx, ny, nz = 4, 3, 3 + data = np.arange(nx * ny * nz, dtype=rasterio.float32).reshape( + nz, ny, nx + ) + with rasterio.open( + tmp_file, + "w", + driver="GTiff", + height=ny, + width=nx, + count=nz, + dtype=rasterio.float32, + ) as s: + s.descriptions = ("nx", "ny", "nz") + s.units = ("cm", "m", "km") + s.write(data) + + # Tests + expected = DataArray( + data, + dims=("band", "y", "x"), + coords={ + "band": [1, 2, 3], + "y": [0.5, 1.5, 2.5], + "x": [0.5, 1.5, 2.5, 3.5], + }, + ) + with xr.open_rasterio(tmp_file) as rioda: + assert_allclose(rioda, expected) + assert rioda.attrs["scales"] == (1.0, 1.0, 1.0) + assert rioda.attrs["offsets"] == (0.0, 0.0, 0.0) + assert rioda.attrs["descriptions"] == ("nx", "ny", "nz") + assert rioda.attrs["units"] == ("cm", "m", "km") + assert isinstance(rioda.attrs["res"], tuple) + assert isinstance(rioda.attrs["is_tiled"], np.uint8) + assert isinstance(rioda.attrs["transform"], tuple) + assert len(rioda.attrs["transform"]) == 6 + + def test_indexing(self): + with create_tmp_geotiff( + 8, 10, 3, transform_args=[1, 2, 0.5, 2.0], crs="+proj=latlong" + ) as (tmp_file, expected): + with xr.open_rasterio(tmp_file, cache=False) as actual: + + # tests + # assert_allclose checks all data + coordinates + assert_allclose(actual, expected) + assert not actual.variable._in_memory + + # Basic indexer + ind = {"x": slice(2, 5), "y": slice(5, 7)} + assert_allclose(expected.isel(**ind), actual.isel(**ind)) + assert not actual.variable._in_memory + + ind = {"band": slice(1, 2), "x": slice(2, 5), "y": slice(5, 7)} + assert_allclose(expected.isel(**ind), actual.isel(**ind)) + assert not actual.variable._in_memory + + ind = {"band": slice(1, 2), "x": slice(2, 5), "y": 0} + assert_allclose(expected.isel(**ind), actual.isel(**ind)) + assert not actual.variable._in_memory + + # orthogonal indexer + ind = { + "band": np.array([2, 1, 0]), + "x": np.array([1, 0]), + "y": np.array([0, 2]), + } + assert_allclose(expected.isel(**ind), actual.isel(**ind)) + assert not actual.variable._in_memory + + ind = {"band": np.array([2, 1, 0]), "x": np.array([1, 0]), "y": 0} + assert_allclose(expected.isel(**ind), actual.isel(**ind)) + assert not actual.variable._in_memory + + ind = {"band": 0, "x": np.array([0, 0]), "y": np.array([1, 1, 1])} + assert_allclose(expected.isel(**ind), actual.isel(**ind)) + assert not actual.variable._in_memory + + # minus-stepped slice + ind = {"band": np.array([2, 1, 0]), "x": slice(-1, None, -1), "y": 0} + assert_allclose(expected.isel(**ind), actual.isel(**ind)) + assert not actual.variable._in_memory + + ind = {"band": np.array([2, 1, 0]), "x": 1, "y": slice(-1, 1, -2)} + assert_allclose(expected.isel(**ind), actual.isel(**ind)) + assert not actual.variable._in_memory + + # empty selection + ind = {"band": np.array([2, 1, 0]), "x": 1, "y": slice(2, 2, 1)} + assert_allclose(expected.isel(**ind), actual.isel(**ind)) + assert not actual.variable._in_memory + + ind = {"band": slice(0, 0), "x": 1, "y": 2} + assert_allclose(expected.isel(**ind), actual.isel(**ind)) + assert not actual.variable._in_memory + + # vectorized indexer + ind = { + "band": DataArray([2, 1, 0], dims="a"), + "x": DataArray([1, 0, 0], dims="a"), + "y": np.array([0, 2]), + } + assert_allclose(expected.isel(**ind), actual.isel(**ind)) + assert not actual.variable._in_memory + + ind = { + "band": DataArray([[2, 1, 0], [1, 0, 2]], dims=["a", "b"]), + "x": DataArray([[1, 0, 0], [0, 1, 0]], dims=["a", "b"]), + "y": 0, + } + assert_allclose(expected.isel(**ind), actual.isel(**ind)) + assert not actual.variable._in_memory + + # Selecting lists of bands is fine + ex = expected.isel(band=[1, 2]) + ac = actual.isel(band=[1, 2]) + assert_allclose(ac, ex) + ex = expected.isel(band=[0, 2]) + ac = actual.isel(band=[0, 2]) + assert_allclose(ac, ex) + + # Integer indexing + ex = expected.isel(band=1) + ac = actual.isel(band=1) + assert_allclose(ac, ex) + + ex = expected.isel(x=1, y=2) + ac = actual.isel(x=1, y=2) + assert_allclose(ac, ex) + + ex = expected.isel(band=0, x=1, y=2) + ac = actual.isel(band=0, x=1, y=2) + assert_allclose(ac, ex) + + # Mixed + ex = actual.isel(x=slice(2), y=slice(2)) + ac = actual.isel(x=[0, 1], y=[0, 1]) + assert_allclose(ac, ex) + + ex = expected.isel(band=0, x=1, y=slice(5, 7)) + ac = actual.isel(band=0, x=1, y=slice(5, 7)) + assert_allclose(ac, ex) + + ex = expected.isel(band=0, x=slice(2, 5), y=2) + ac = actual.isel(band=0, x=slice(2, 5), y=2) + assert_allclose(ac, ex) + + # One-element lists + ex = expected.isel(band=[0], x=slice(2, 5), y=[2]) + ac = actual.isel(band=[0], x=slice(2, 5), y=[2]) + assert_allclose(ac, ex) + + def test_caching(self): + with create_tmp_geotiff( + 8, 10, 3, transform_args=[1, 2, 0.5, 2.0], crs="+proj=latlong" + ) as (tmp_file, expected): + # Cache is the default + with xr.open_rasterio(tmp_file) as actual: + + # This should cache everything + assert_allclose(actual, expected) + + # once cached, non-windowed indexing should become possible + ac = actual.isel(x=[2, 4]) + ex = expected.isel(x=[2, 4]) + assert_allclose(ac, ex) + + def test_chunks(self): + with create_tmp_geotiff( + 8, 10, 3, transform_args=[1, 2, 0.5, 2.0], crs="+proj=latlong" + ) as (tmp_file, expected): + # Chunk at open time + with xr.open_rasterio(tmp_file, chunks=(1, 2, 2)) as actual: + + import dask.array as da + + assert isinstance(actual.data, da.Array) + assert "open_rasterio" in actual.data.name + + # do some arithmetic + ac = actual.mean() + ex = expected.mean() + assert_allclose(ac, ex) + + ac = actual.sel(band=1).mean(dim="x") + ex = expected.sel(band=1).mean(dim="x") + assert_allclose(ac, ex) + + def test_pickle_rasterio(self): + # regression test for https://github.com/pydata/xarray/issues/2121 + with create_tmp_geotiff() as (tmp_file, expected): + with xr.open_rasterio(tmp_file) as rioda: + temp = pickle.dumps(rioda) + with pickle.loads(temp) as actual: + assert_equal(actual, rioda) + + def test_ENVI_tags(self): + rasterio = pytest.importorskip("rasterio", minversion="1.0a") + from rasterio.transform import from_origin + + # Create an ENVI file with some tags in the ENVI namespace + # this test uses a custom driver, so we can't use create_tmp_geotiff + with create_tmp_file(suffix=".dat") as tmp_file: + # data + nx, ny, nz = 4, 3, 3 + data = np.arange(nx * ny * nz, dtype=rasterio.float32).reshape(nz, ny, nx) + transform = from_origin(5000, 80000, 1000, 2000.0) + with rasterio.open( + tmp_file, + "w", + driver="ENVI", + height=ny, + width=nx, + count=nz, + crs={ + "units": "m", + "no_defs": True, + "ellps": "WGS84", + "proj": "utm", + "zone": 18, + }, + transform=transform, + dtype=rasterio.float32, + ) as s: + s.update_tags( + ns="ENVI", + description="{Tagged file}", + wavelength="{123.000000, 234.234000, 345.345678}", + fwhm="{1.000000, 0.234000, 0.000345}", + ) + s.write(data) + dx, dy = s.res[0], -s.res[1] + + # Tests + coords = { + "band": [1, 2, 3], + "y": -np.arange(ny) * 2000 + 80000 + dy / 2, + "x": np.arange(nx) * 1000 + 5000 + dx / 2, + "wavelength": ("band", np.array([123, 234.234, 345.345678])), + "fwhm": ("band", np.array([1, 0.234, 0.000345])), + } + expected = DataArray(data, dims=("band", "y", "x"), coords=coords) + + with xr.open_rasterio(tmp_file) as rioda: + assert_allclose(rioda, expected) + assert isinstance(rioda.attrs["crs"], str) + assert isinstance(rioda.attrs["res"], tuple) + assert isinstance(rioda.attrs["is_tiled"], np.uint8) + assert isinstance(rioda.attrs["transform"], tuple) + assert len(rioda.attrs["transform"]) == 6 + # from ENVI tags + assert isinstance(rioda.attrs["description"], str) + assert isinstance(rioda.attrs["map_info"], str) + assert isinstance(rioda.attrs["samples"], str) + + def test_no_mftime(self): + # rasterio can accept "filename" urguments that are actually urls, + # including paths to remote files. + # In issue #1816, we found that these caused dask to break, because + # the modification time was used to determine the dask token. This + # tests ensure we can still chunk such files when reading with + # rasterio. + with create_tmp_geotiff( + 8, 10, 3, transform_args=[1, 2, 0.5, 2.0], crs="+proj=latlong" + ) as (tmp_file, expected): + with mock.patch("os.path.getmtime", side_effect=OSError): + with xr.open_rasterio(tmp_file, chunks=(1, 2, 2)) as actual: + import dask.array as da + + assert isinstance(actual.data, da.Array) + assert_allclose(actual, expected) + + @pytest.mark.xfail(reason="Network could be problematic") + def test_http_url(self): + # more examples urls here + # http://download.osgeo.org/geotiff/samples/ + url = "http://download.osgeo.org/geotiff/samples/made_up/ntf_nord.tif" + with xr.open_rasterio(url) as actual: + assert actual.shape == (1, 512, 512) + # make sure chunking works + with xr.open_rasterio(url, chunks=(1, 256, 256)) as actual: + import dask.array as da + + assert isinstance(actual.data, da.Array) + + def test_rasterio_environment(self): + import rasterio + + with create_tmp_geotiff() as (tmp_file, expected): + # Should fail with error since suffix not allowed + with pytest.raises(Exception): + with rasterio.Env(GDAL_SKIP="GTiff"): + with xr.open_rasterio(tmp_file) as actual: + assert_allclose(actual, expected) + + def test_rasterio_vrt(self): + import rasterio + + # tmp_file default crs is UTM: CRS({'init': 'epsg:32618'} + with create_tmp_geotiff() as (tmp_file, expected): + with rasterio.open(tmp_file) as src: + with rasterio.vrt.WarpedVRT(src, crs="epsg:4326") as vrt: + expected_shape = (vrt.width, vrt.height) + expected_crs = vrt.crs + print(expected_crs) + expected_res = vrt.res + # Value of single pixel in center of image + lon, lat = vrt.xy(vrt.width // 2, vrt.height // 2) + expected_val = next(vrt.sample([(lon, lat)])) + with xr.open_rasterio(vrt) as da: + actual_shape = (da.sizes["x"], da.sizes["y"]) + actual_crs = da.crs + print(actual_crs) + actual_res = da.res + actual_val = da.sel(dict(x=lon, y=lat), method="nearest").data + + assert actual_crs == expected_crs + assert actual_res == expected_res + assert actual_shape == expected_shape + assert expected_val.all() == actual_val.all() + + def test_rasterio_vrt_with_transform_and_size(self): + # Test open_rasterio() support of WarpedVRT with transform, width and + # height (issue #2864) + import rasterio + from rasterio.warp import calculate_default_transform + from affine import Affine + + with create_tmp_geotiff() as (tmp_file, expected): + with rasterio.open(tmp_file) as src: + # Estimate the transform, width and height + # for a change of resolution + # tmp_file initial res is (1000,2000) (default values) + trans, w, h = calculate_default_transform( + src.crs, src.crs, src.width, src.height, resolution=500, *src.bounds + ) + with rasterio.vrt.WarpedVRT( + src, transform=trans, width=w, height=h + ) as vrt: + expected_shape = (vrt.width, vrt.height) + expected_res = vrt.res + expected_transform = vrt.transform + with xr.open_rasterio(vrt) as da: + actual_shape = (da.sizes["x"], da.sizes["y"]) + actual_res = da.res + actual_transform = Affine(*da.transform) + assert actual_res == expected_res + assert actual_shape == expected_shape + assert actual_transform == expected_transform + + @pytest.mark.xfail(reason="Network could be problematic") + def test_rasterio_vrt_network(self): + import rasterio + + url = "https://storage.googleapis.com/\ + gcp-public-data-landsat/LC08/01/047/027/\ + LC08_L1TP_047027_20130421_20170310_01_T1/\ + LC08_L1TP_047027_20130421_20170310_01_T1_B4.TIF" + env = rasterio.Env( + GDAL_DISABLE_READDIR_ON_OPEN="EMPTY_DIR", + CPL_VSIL_CURL_USE_HEAD=False, + CPL_VSIL_CURL_ALLOWED_EXTENSIONS="TIF", + ) + with env: + with rasterio.open(url) as src: + with rasterio.vrt.WarpedVRT(src, crs="epsg:4326") as vrt: + expected_shape = (vrt.width, vrt.height) + expected_crs = vrt.crs + expected_res = vrt.res + # Value of single pixel in center of image + lon, lat = vrt.xy(vrt.width // 2, vrt.height // 2) + expected_val = next(vrt.sample([(lon, lat)])) + with xr.open_rasterio(vrt) as da: + actual_shape = (da.sizes["x"], da.sizes["y"]) + actual_crs = da.crs + actual_res = da.res + actual_val = da.sel(dict(x=lon, y=lat), method="nearest").data + + assert_equal(actual_shape, expected_shape) + assert_equal(actual_crs, expected_crs) + assert_equal(actual_res, expected_res) + assert_equal(expected_val, actual_val) From 80c08dfe8d368a2e4bbffbdc400a392f512446e8 Mon Sep 17 00:00:00 2001 From: snowman2 Date: Wed, 24 Jul 2019 08:49:46 -0500 Subject: [PATCH 9/9] remove print --- test/integration/test_integration__io.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/test/integration/test_integration__io.py b/test/integration/test_integration__io.py index 6851757f..2776a8de 100644 --- a/test/integration/test_integration__io.py +++ b/test/integration/test_integration__io.py @@ -565,7 +565,6 @@ def test_rasterio_vrt(self): with rasterio.vrt.WarpedVRT(src, crs="epsg:4326") as vrt: expected_shape = (vrt.width, vrt.height) expected_crs = vrt.crs - print(expected_crs) expected_res = vrt.res # Value of single pixel in center of image lon, lat = vrt.xy(vrt.width // 2, vrt.height // 2) @@ -573,7 +572,6 @@ def test_rasterio_vrt(self): with xr.open_rasterio(vrt) as da: actual_shape = (da.sizes["x"], da.sizes["y"]) actual_crs = da.crs - print(actual_crs) actual_res = da.res actual_val = da.sel(dict(x=lon, y=lat), method="nearest").data