def _get_value(layer: Dict[str, Any], name: str, dataset: DatasetReader, lon: float, lat: float) -> Optional[numpy.float32]: index = dataset.index(lon, lat) shape = dataset.shape result: Optional[numpy.float32] if 0 <= index[0] < shape[0] and 0 <= index[1] < shape[1]: def get_index(index_: int) -> Tuple[int, int]: return index_, index_ + 1 result = dataset.read(1, window=(get_index(index[0]), get_index(index[1])))[0][0] result = None if result == layer.get("nodata", dataset.nodata) else result else: LOG.debug( "Out of index for layer: %s (%s), lon/lat: %dx%d, index: %dx%d, shape: %dx%d.", name, layer["file"], lon, lat, index[0], index[1], dataset.shape[0], dataset.shape[1], ) result = None return result
def _generate_shifted_image( self, source_file_path: str, dataset: DatasetReader) -> Tuple[Window, np.ndarray]: with rasterio.open(source_file_path) as image: image_width, image_height = image.width, image.height image_x, image_y = image.xy(0, 0) min_shift_x = math.floor(self.shift_min_percent * image_width) max_shift_x = math.floor(self.shift_max_percent * image_width) min_shift_y = math.floor(self.shift_min_percent * image_height) max_shift_y = math.floor(self.shift_max_percent * image_height) x_min_bound = 0 x_max_bound = dataset.width - image_width y_min_bound = 0 y_max_bound = dataset.height - image_height dataset_row, dataset_col = dataset.index(image_x, image_y) def _valid_lower_point(threshold, value): return max(threshold, value) def _valid_upper_point(threshold, value): return min(threshold, value) def _valid_lower_x(x): return _valid_lower_point(x_min_bound, x) def _valid_lower_y(y): return _valid_lower_point(y_min_bound, y) def _valid_upper_x(x): return _valid_upper_point(x_max_bound, x) def _valid_upper_y(y): return _valid_upper_point(y_max_bound, y) lower_x_range = np.arange(_valid_lower_x(dataset_col - max_shift_x), _valid_lower_x(dataset_col - min_shift_x)) upper_x_range = np.arange(_valid_upper_x(dataset_col + min_shift_x), _valid_upper_x(dataset_col + max_shift_x)) lower_y_range = np.arange(_valid_lower_y(dataset_row - max_shift_y), _valid_lower_y(dataset_row - min_shift_y)) upper_y_range = np.arange(_valid_upper_y(dataset_row + min_shift_y), _valid_upper_y(dataset_row + max_shift_y)) x_range = np.concatenate([lower_x_range, upper_x_range]) y_range = np.concatenate([lower_y_range, upper_y_range]) new_x = np.random.choice(x_range) new_y = np.random.choice(y_range) dataset_window = Window(new_x, new_y, image_width, image_height) p = dataset.read(window=dataset_window) return dataset_window, p
def read_from_lat_lon( data: DatasetReader, band_idxs: Union[int, Iterable[int]], lat: Tuple[float], lon: Tuple[float], **kwargs, ) -> np.ndarray: """ Read in a tile of raster data form specified latitude and longitude values. Note: This function only works if `data` is provided in the WGS geographical coordinate system (Note: WGS84 = EPSG4326). Args: data (DatasetReader): rasterio data handle band_idxs (Union[int, Iterable[int]]): The band index or indices for which to read the information from the underlying rasterio `data`. lat (Tuple[float]): A tuple containing (latitude_min, latitude_max). Latitudes must be in the range (-90, 90). lon (Tuple[float]): A tuple containing (longitude_min, longitude_max). Longitudes must be in the range (-180, 180). Returns: np.ndarray: A multidimensional numpy array containing the specified bands in the given latitude, longitude bounds. """ # Check that geographical cooridnate reference system of the data is # WGS84 (i.e. epsg 4326). If this is not the case, prompt user to retransform. if not data.crs == CRS.from_epsg(4326): raise CoordinateSystemError( "Latitude, Longitude based reading requires EPSG 4326 (WGS84) coordinate " f"reference system. Current CRS is {data.crs}. To use this method, first " "transform your data to EPSG 4326.") lat_min, lat_max = lat lon_min, lon_max = lon # Check if latitude and longitude are within physical bounds if not -90 <= lat_min < lat_max <= 90: raise InvalidUseError( "Latitudinal coordinates must be between -90 and 90 degrees") if not -180 <= lon_min < lon_max <= 180: raise InvalidUseError( "Longitudinal coordinates must be between -180 and 180 degrees") # Note: rows increase from top to bottom, latitude increases from bottom to top row_min, col_min = data.index(lon_min, lat_max) # index swaps values internally row_max, col_max = data.index(lon_max, lat_min) # Read specified region return data.read(indexes=band_idxs, window=((row_min, row_max), (col_min, col_max)), **kwargs)
def window_around_latlon(self, t: DatasetReader, lat: float, lon: float, size: float): # From latlon to the coordinate reference system of the image in m xs, ys = rasterio.warp.transform("EPSG:4326", t.crs, [lon], [lat], zs=None) # Create the corners of the viewing window in pixels top, right = t.index(xs[0] + size / 2, ys[0] + size / 2) bottom, left = t.index(xs[0] - size / 2, ys[0] - size / 2) window = rasterio.windows.Window(left, top, right - left, bottom - top) return window
def window_around_latlon(self, t: DatasetReader, lat: float, lon: float, size: float): # From latlon to the coordinate reference system of the image in m # pyre-fixme[16]: `DatasetReader` has no attribute `crs`. xs, ys = rasterio.warp.transform("EPSG:4326", t.crs, [lon], [lat], zs=None) # Create the corners of the viewing window in pixels top, right = t.index(xs[0] + size / 2, ys[0] + size / 2) bottom, left = t.index(xs[0] - size / 2, ys[0] - size / 2) # pyre-fixme[19]: Expected 0 positional arguments. window = rasterio.windows.Window(left, top, right - left, bottom - top) return window
def get_thumbnail( data: DatasetReader, band_idx: Optional[int] = 1, height: Optional[int] = 100, width: Optional[int] = None, ) -> np.ndarray: """ Calculate a thumbnail for a given band of a rasterio data Args: data (DatasetReader): rasterio data handle band_idx (Optional[int], optional): The band index for which to caluclate the thumbnail. Defaults to 1. height (Optional[int], optional): The desired height of the thumbnail. If only the height is set, the width will be automatically determined from the datas aspect ratio. Defaults to 100. width (Optional[int], optional): The desired width of the thumbnail. Defaults to None. Returns: np.ndarray: The 2D numpy array representing the thumbnail as calculated from nearest neighbour resampling. """ aspect_ratio = data.height / data.width if height and not width: width = int(height / aspect_ratio) elif width and not height: height = int(width * aspect_ratio) assert height > 0 and width > 0, "Output height and/or width must be specified." return data.read(band_idx, out_shape=(int(height), int(width)))
def _read(src: DatasetReader, bidx: int, window: Optional[RasterWindow], out_shape: Optional[RasterShape]) -> np.ndarray: return src.read(bidx, window=_roi_to_window(window, src.shape), out_shape=out_shape)
def get_uuid(collection: DatasetReader, idx: int): """ Returns a deterministic uuid based on band index and gdal checksum """ origin = collection.tags()["NC_GLOBAL#References"] return uuid.uuid5( NOAA_WATER_VAPOUR_NS, "{}?{}".format( origin, urllib.parse.urlencode({ "checksum": collection.checksum(idx), "band_index": idx, "filename": Path(collection.name).stem, }), ), )
def read_opened_rasterio(rasterio_image: DatasetReader, scale_factor: float = 1.0): image = rasterio_image.read( out_shape=( rasterio_image.count, int(rasterio_image.height * scale_factor), int(rasterio_image.width * scale_factor), ), resampling=Resampling.bilinear, ) if image.shape[-1] != 3: image = np.moveaxis(image, 0, -1) return image
def open(fp, mode='r', driver=None, width=None, height=None, count=None, crs=None, transform=None, dtype=None, nodata=None, **kwargs): """Open a dataset for reading or writing. The dataset may be located in a local file, in a resource located by a URL, or contained within a stream of bytes. In read ('r') or read/write ('r+') mode, no keyword arguments are required: these attributes are supplied by the opened dataset. In write ('w') mode, the driver, width, height, count, and dtype keywords are strictly required. Parameters ---------- fp : str or file object A filename or URL, or file object opened in binary ('rb') mode mode : str, optional 'r' (read, the default), 'r+' (read/write), or 'w' (write) driver : str, optional A short format driver name (e.g. "GTiff" or "JPEG") or a list of such names (see GDAL docs at http://www.gdal.org/formats_list.html). In 'w' mode a single name is required. In 'r' or 'r+' mode the driver can usually be omitted. Registered drivers will be tried sequentially until a match is found. When multiple drivers are available for a format such as JPEG2000, one of them can be selected by using this keyword argument. width, height : int, optional The numbers of rows and columns of the raster dataset. Required in 'w' mode, they are ignored in 'r' or 'r+' mode. count : int, optional The count of dataset bands. Required in 'w' mode, it is ignored in 'r' or 'r+' mode. dtype : str or numpy dtype The data type for bands. For example: 'uint8' or ``rasterio.uint16``. Required in 'w' mode, it is ignored in 'r' or 'r+' mode. crs : str, dict, or CRS; optional The coordinate reference system. Required in 'w' mode, it is ignored in 'r' or 'r+' mode. transform : Affine instance, optional Affine transformation mapping the pixel space to geographic space. Required in 'w' mode, it is ignored in 'r' or 'r+' mode. nodata : int, float, or nan; optional Defines the pixel value to be interpreted as not valid data. Required in 'w' mode, it is ignored in 'r' or 'r+' mode. kwargs : optional These are passed to format drivers as directives for creating or interpreting datasets. For example: in 'w' a `tiled=True` keyword argument will direct the GeoTIFF format driver to create a tiled, rather than striped, TIFF. Returns ------- A ``DatasetReader`` or ``DatasetUpdater`` object. Examples -------- To open a GeoTIFF for reading using standard driver discovery and no directives: >>> import rasterio >>> with rasterio.open('example.tif') as dataset: ... print(dataset.profile) To open a JPEG2000 using only the JP2OpenJPEG driver: >>> with rasterio.open( ... 'example.jp2', driver='JP2OpenJPEG') as dataset: ... print(dataset.profile) To create a new 8-band, 16-bit unsigned, tiled, and LZW-compressed GeoTIFF with a global extent and 0.5 degree resolution: >>> from rasterio.transform import from_origin >>> with rasterio.open( ... 'example.tif', 'w', driver='GTiff', dtype='uint16', ... width=720, height=360, count=8, crs='EPSG:4326', ... transform=from_origin(-180.0, 90.0, 0.5, 0.5), ... nodata=0, tiled=True, compress='lzw') as dataset: ... dataset.write(...) """ if not isinstance(fp, string_types): if not (hasattr(fp, 'read') or hasattr(fp, 'write')): raise TypeError("invalid path or file: {0!r}".format(fp)) if mode and not isinstance(mode, string_types): raise TypeError("invalid mode: {0!r}".format(mode)) if driver and not isinstance(driver, string_types): raise TypeError("invalid driver: {0!r}".format(driver)) if dtype and not check_dtype(dtype): raise TypeError("invalid dtype: {0!r}".format(dtype)) if nodata is not None: nodata = float(nodata) if 'affine' in kwargs: # DeprecationWarning's are ignored by default with warnings.catch_warnings(): warnings.warn( "The 'affine' kwarg in rasterio.open() is deprecated at 1.0 " "and only remains to ease the transition. Please switch to " "the 'transform' kwarg. See " "https://github.com/mapbox/rasterio/issues/86 for details.", DeprecationWarning, stacklevel=2) if transform: warnings.warn( "Found both 'affine' and 'transform' in rasterio.open() - " "choosing 'transform'") transform = transform else: transform = kwargs.pop('affine') if transform: transform = guard_transform(transform) # Check driver/mode blacklist. if driver and is_blacklisted(driver, mode): raise RasterioIOError( "Blacklisted: file cannot be opened by " "driver '{0}' in '{1}' mode".format(driver, mode)) # Special case for file object argument. if mode == 'r' and hasattr(fp, 'read'): @contextmanager def fp_reader(fp): memfile = MemoryFile(fp.read()) dataset = memfile.open() try: yield dataset finally: dataset.close() memfile.close() return fp_reader(fp) elif mode == 'w' and hasattr(fp, 'write'): @contextmanager def fp_writer(fp): memfile = MemoryFile() dataset = memfile.open(driver=driver, width=width, height=height, count=count, crs=crs, transform=transform, dtype=dtype, nodata=nodata, **kwargs) try: yield dataset finally: dataset.close() memfile.seek(0) fp.write(memfile.read()) memfile.close() return fp_writer(fp) else: # The 'normal' filename or URL path. _, _, scheme = parse_path(fp) with Env() as env: if scheme == 's3': env.credentialize() # Create dataset instances and pass the given env, which will # be taken over by the dataset's context manager if it is not # None. if mode == 'r': s = DatasetReader(fp, driver=driver, **kwargs) elif mode == 'r-': warnings.warn("'r-' mode is deprecated, use 'r'", DeprecationWarning) s = DatasetReader(fp) elif mode == 'r+': s = get_writer_for_path(fp)(fp, mode, driver=driver, **kwargs) elif mode == 'w': s = get_writer_for_driver(driver)(fp, mode, driver=driver, width=width, height=height, count=count, crs=crs, transform=transform, dtype=dtype, nodata=nodata, **kwargs) else: raise ValueError( "mode must be one of 'r', 'r+', or 'w', not %s" % mode) return s
def open(fp, mode='r', driver=None, width=None, height=None, count=None, crs=None, transform=None, dtype=None, nodata=None, sharing=False, **kwargs): """Open a dataset for reading or writing. The dataset may be located in a local file, in a resource located by a URL, or contained within a stream of bytes. In read ('r') or read/write ('r+') mode, no keyword arguments are required: these attributes are supplied by the opened dataset. In write ('w' or 'w+') mode, the driver, width, height, count, and dtype keywords are strictly required. Parameters ---------- fp : str, file object, PathLike object, FilePath, or MemoryFile A filename or URL, a file object opened in binary ('rb') mode, a Path object, or one of the rasterio classes that provides the dataset-opening interface (has an open method that returns a dataset). mode : str, optional 'r' (read, the default), 'r+' (read/write), 'w' (write), or 'w+' (write/read). driver : str, optional A short format driver name (e.g. "GTiff" or "JPEG") or a list of such names (see GDAL docs at https://gdal.org/drivers/raster/index.html). In 'w' or 'w+' modes a single name is required. In 'r' or 'r+' modes the driver can usually be omitted. Registered drivers will be tried sequentially until a match is found. When multiple drivers are available for a format such as JPEG2000, one of them can be selected by using this keyword argument. width : int, optional The number of columns of the raster dataset. Required in 'w' or 'w+' modes, it is ignored in 'r' or 'r+' modes. height : int, optional The number of rows of the raster dataset. Required in 'w' or 'w+' modes, it is ignored in 'r' or 'r+' modes. count : int, optional The count of dataset bands. Required in 'w' or 'w+' modes, it is ignored in 'r' or 'r+' modes. crs : str, dict, or CRS; optional The coordinate reference system. Required in 'w' or 'w+' modes, it is ignored in 'r' or 'r+' modes. transform : Affine instance, optional Affine transformation mapping the pixel space to geographic space. Required in 'w' or 'w+' modes, it is ignored in 'r' or 'r+' modes. dtype : str or numpy dtype The data type for bands. For example: 'uint8' or ``rasterio.uint16``. Required in 'w' or 'w+' modes, it is ignored in 'r' or 'r+' modes. nodata : int, float, or nan; optional Defines the pixel value to be interpreted as not valid data. Required in 'w' or 'w+' modes, it is ignored in 'r' or 'r+' modes. sharing : bool; optional To reduce overhead and prevent programs from running out of file descriptors, rasterio maintains a pool of shared low level dataset handles. When `True` this function will use a shared handle if one is available. Multithreaded programs must avoid sharing and should set *sharing* to `False`. kwargs : optional These are passed to format drivers as directives for creating or interpreting datasets. For example: in 'w' or 'w+' modes a `tiled=True` keyword argument will direct the GeoTIFF format driver to create a tiled, rather than striped, TIFF. Returns ------- A ``DatasetReader`` or ``DatasetWriter`` object. Examples -------- To open a GeoTIFF for reading using standard driver discovery and no directives: >>> import rasterio >>> with rasterio.open('example.tif') as dataset: ... print(dataset.profile) To open a JPEG2000 using only the JP2OpenJPEG driver: >>> with rasterio.open( ... 'example.jp2', driver='JP2OpenJPEG') as dataset: ... print(dataset.profile) To create a new 8-band, 16-bit unsigned, tiled, and LZW-compressed GeoTIFF with a global extent and 0.5 degree resolution: >>> from rasterio.transform import from_origin >>> with rasterio.open( ... 'example.tif', 'w', driver='GTiff', dtype='uint16', ... width=720, height=360, count=8, crs='EPSG:4326', ... transform=from_origin(-180.0, 90.0, 0.5, 0.5), ... nodata=0, tiled=True, compress='lzw') as dataset: ... dataset.write(...) """ if not isinstance(fp, str): if not ( hasattr(fp, "read") or hasattr(fp, "write") or isinstance(fp, (os.PathLike, MemoryFile, FilePath)) ): raise TypeError("invalid path or file: {0!r}".format(fp)) if mode and not isinstance(mode, str): raise TypeError("invalid mode: {0!r}".format(mode)) if driver and not isinstance(driver, str): raise TypeError("invalid driver: {0!r}".format(driver)) if dtype and not check_dtype(dtype): raise TypeError("invalid dtype: {0!r}".format(dtype)) if nodata is not None: nodata = float(nodata) if transform: transform = guard_transform(transform) # Check driver/mode blacklist. if driver and is_blacklisted(driver, mode): raise RasterioIOError( "Blacklisted: file cannot be opened by " "driver '{0}' in '{1}' mode".format(driver, mode)) # If the fp argument is a file-like object and can be adapted by # rasterio's FilePath we do so. Otherwise, we use a MemoryFile to # hold fp's contents and store that in an ExitStack attached to the # dataset object that we will return. When a dataset's close method # is called, this ExitStack will be unwound and the MemoryFile's # storage will be cleaned up. if mode == 'r' and hasattr(fp, 'read'): if have_vsi_plugin: return FilePath(fp).open(driver=driver, sharing=sharing, **kwargs) else: memfile = MemoryFile(fp.read()) dataset = memfile.open(driver=driver, sharing=sharing, **kwargs) dataset._env.enter_context(memfile) return dataset elif mode in ('w', 'w+') and hasattr(fp, 'write'): memfile = MemoryFile() dataset = memfile.open( driver=driver, width=width, height=height, count=count, crs=crs, transform=transform, dtype=dtype, nodata=nodata, sharing=sharing, **kwargs ) dataset._env.enter_context(memfile) # For the writing case we push an extra callback onto the # ExitStack. It ensures that the MemoryFile's contents are # copied to the open file object. def func(*args, **kwds): memfile.seek(0) fp.write(memfile.read()) dataset._env.callback(func) return dataset # TODO: test for a shared base class or abstract type. elif isinstance(fp, (FilePath, MemoryFile)): if mode.startswith("r"): dataset = fp.open(driver=driver, sharing=sharing, **kwargs) # Note: FilePath does not support writing and an exception will # result from this. elif mode.startswith("w"): dataset = fp.open( driver=driver, width=width, height=height, count=count, crs=crs, transform=transform, dtype=dtype, nodata=nodata, sharing=sharing, **kwargs ) return dataset # At this point, the fp argument is a string or path-like object # which can be converted to a string. else: raw_dataset_path = os.fspath(fp) path = _parse_path(raw_dataset_path) if mode == "r": dataset = DatasetReader(path, driver=driver, sharing=sharing, **kwargs) elif mode == "r+": dataset = get_writer_for_path(path, driver=driver)( path, mode, driver=driver, sharing=sharing, **kwargs ) elif mode.startswith("w"): if not driver: driver = driver_from_extension(path) writer = get_writer_for_driver(driver) if writer is not None: dataset = writer( path, mode, driver=driver, width=width, height=height, count=count, crs=crs, transform=transform, dtype=dtype, nodata=nodata, sharing=sharing, **kwargs ) else: raise DriverCapabilityError( "Writer does not exist for driver: %s" % str(driver) ) else: raise DriverCapabilityError( "mode must be one of 'r', 'r+', or 'w', not %s" % mode) return dataset
def open(path, mode='r', driver=None, width=None, height=None, count=None, crs=None, transform=None, dtype=None, nodata=None, **kwargs): """Open file at ``path`` in ``mode`` 'r' (read), 'r+' (read and write), or 'w' (write) and return a dataset Reader or Updater object. In write mode, a driver name such as "GTiff" or "JPEG" (see GDAL docs or ``gdal_translate --help`` on the command line), ``width`` (number of pixels per line) and ``height`` (number of lines), the ``count`` number of bands in the new file must be specified. Additionally, the data type for bands such as ``rasterio.ubyte`` for 8-bit bands or ``rasterio.uint16`` for 16-bit bands must be specified using the ``dtype`` argument. Parameters ---------- mode: string "r" (read), "r+" (read/write), or "w" (write) driver: string Driver code specifying the format name (e.g. "GTiff" or "JPEG"). See GDAL docs at http://www.gdal.org/formats_list.html (optional, required for writing). width: int Number of pixels per line (optional, required for write). height: int Number of lines (optional, required for write). count: int > 0 Count of bands (optional, required for write). dtype: rasterio.dtype the data type for bands such as ``rasterio.ubyte`` for 8-bit bands or ``rasterio.uint16`` for 16-bit bands (optional, required for write) crs: dict or string Coordinate reference system (optional, recommended for write). transform: Affine instance Affine transformation mapping the pixel space to geographic space (optional, recommended for writing). nodata: number Defines pixel value to be interpreted as null/nodata (optional, recommended for write, will be broadcast to all bands). Returns ------- A ``DatasetReader`` or ``DatasetUpdater`` object. Notes ----- In write mode, you must specify at least ``width``, ``height``, ``count`` and ``dtype``. A coordinate reference system for raster datasets in write mode can be defined by the ``crs`` argument. It takes Proj4 style mappings like .. code:: {'proj': 'longlat', 'ellps': 'WGS84', 'datum': 'WGS84', 'no_defs': True} An affine transformation that maps ``col,row`` pixel coordinates to ``x,y`` coordinates in the coordinate reference system can be specified using the ``transform`` argument. The value should be an instance of ``affine.Affine`` .. code:: python >>> from affine import Affine >>> transform = Affine(0.5, 0.0, -180.0, 0.0, -0.5, 90.0) These coefficients are shown in the figure below. .. code:: | x | | a b c | | c | | y | = | d e f | | r | | 1 | | 0 0 1 | | 1 | a: rate of change of X with respect to increasing column, i.e. pixel width b: rotation, 0 if the raster is oriented "north up" c: X coordinate of the top left corner of the top left pixel d: rotation, 0 if the raster is oriented "north up" e: rate of change of Y with respect to increasing row, usually a negative number (i.e. -1 * pixel height) if north-up. f: Y coordinate of the top left corner of the top left pixel A 6-element sequence of the affine transformation matrix coefficients in ``c, a, b, f, d, e`` order, (i.e. GDAL geotransform order) will be accepted until 1.0 (deprecated). A virtual filesystem can be specified. The ``vfs`` parameter may be an Apache Commons VFS style string beginning with "zip://" or "tar://"". In this case, the ``path`` must be an absolute path within that container. """ if not isinstance(path, string_types): raise TypeError("invalid path: {0!r}".format(path)) if mode and not isinstance(mode, string_types): raise TypeError("invalid mode: {0!r}".format(mode)) if driver and not isinstance(driver, string_types): raise TypeError("invalid driver: {0!r}".format(driver)) if dtype and not check_dtype(dtype): raise TypeError("invalid dtype: {0!r}".format(dtype)) if nodata is not None: nodata = float(nodata) if 'affine' in kwargs: # DeprecationWarning's are ignored by default with warnings.catch_warnings(): warnings.warn( "The 'affine' kwarg in rasterio.open() is deprecated at 1.0 " "and only remains to ease the transition. Please switch to " "the 'transform' kwarg. See " "https://github.com/mapbox/rasterio/issues/86 for details.", DeprecationWarning, stacklevel=2) if transform: warnings.warn( "Found both 'affine' and 'transform' in rasterio.open() - " "choosing 'transform'") transform = transform else: transform = kwargs.pop('affine') if transform: transform = guard_transform(transform) # Check driver/mode blacklist. if driver and is_blacklisted(driver, mode): raise RasterioIOError( "Blacklisted: file cannot be opened by " "driver '{0}' in '{1}' mode".format(driver, mode)) _, _, scheme = parse_path(path) with Env() as env: # Get AWS credentials only if we're attempting to access a # raster using the S3 scheme. if scheme == 's3': env.get_aws_credentials() log.debug("AWS credentials have been obtained") # Create dataset instances and pass the given env, which will # be taken over by the dataset's context manager if it is not # None. if mode == 'r': s = DatasetReader(path) elif mode == 'r-': warnings.warn("'r-' mode is deprecated, use 'r'", DeprecationWarning) s = DatasetReader(path) elif mode == 'r+': s = get_writer_for_path(path)(path, mode) elif mode == 'w': s = get_writer_for_driver(driver)(path, mode, driver=driver, width=width, height=height, count=count, crs=crs, transform=transform, dtype=dtype, nodata=nodata, **kwargs) else: raise ValueError( "mode string must be one of 'r', 'r+', or 'w', not %s" % mode) s.start() return s
def test_datasetreader_ctor_url(gdalenv): """DatasetReader constructor accepts URLs.""" dataset = DatasetReader(httpstif) assert dataset.name.startswith("https") assert dataset.name.endswith("float32.tif?raw=true")
def test_datasetreader_ctor_filename(path_rgb_byte_tif): """DatasetReader constructor accepts string filenames.""" assert DatasetReader(path_rgb_byte_tif).name.endswith("RGB.byte.tif")
def open(fp, mode='r', driver=None, width=None, height=None, count=None, crs=None, transform=None, dtype=None, nodata=None, **kwargs): """Open a dataset for reading or writing. The dataset may be located in a local file, in a resource located by a URL, or contained within a stream of bytes. To access a dataset within a zip file without unzipping the archive use an Apache VFS style zip:// URL like zip://path/to/archive.zip!path/to/example.tif In read ('r') or read/write ('r+') mode, no other keyword arguments are required: the attributes are supplied by the opened dataset. In write mode, a driver name such as "GTiff" or "JPEG" (see GDAL docs or ``gdal_translate --help`` on the command line), ``width`` (number of pixels per line) and ``height`` (number of lines), the ``count`` number of bands in the new file must be specified. Additionally, the data type for bands such as ``rasterio.ubyte`` for 8-bit bands or ``rasterio.uint16`` for 16-bit bands must be specified using the ``dtype`` argument. Parameters ---------- fp: string or file A filename or URL, or file object opened in binary mode. mode: string "r" (read), "r+" (read/write), or "w" (write) driver: string Driver code specifying the format name (e.g. "GTiff" or "JPEG"). See GDAL docs at http://www.gdal.org/formats_list.html (optional, required for writing). width: int Number of pixels per line (optional, required for write). height: int Number of lines (optional, required for write). count: int > 0 Count of bands (optional, required for write). dtype: rasterio.dtype the data type for bands such as ``rasterio.ubyte`` for 8-bit bands or ``rasterio.uint16`` for 16-bit bands (optional, required for write) crs: dict or string Coordinate reference system (optional, recommended for write). transform: Affine instance Affine transformation mapping the pixel space to geographic space (optional, recommended for writing). nodata: number Defines pixel value to be interpreted as null/nodata (optional, recommended for write, will be broadcast to all bands). Returns ------- A ``DatasetReader`` or ``DatasetUpdater`` object. Notes ----- In write mode, you must specify at least ``width``, ``height``, ``count`` and ``dtype``. A coordinate reference system for raster datasets in write mode can be defined by the ``crs`` argument. It takes Proj4 style mappings like .. code:: {'proj': 'longlat', 'ellps': 'WGS84', 'datum': 'WGS84', 'no_defs': True} An affine transformation that maps ``col,row`` pixel coordinates to ``x,y`` coordinates in the coordinate reference system can be specified using the ``transform`` argument. The value should be an instance of ``affine.Affine`` .. code:: python >>> from affine import Affine >>> transform = Affine(0.5, 0.0, -180.0, 0.0, -0.5, 90.0) These coefficients are shown in the figure below. .. code:: | x | | a b c | | c | | y | = | d e f | | r | | 1 | | 0 0 1 | | 1 | a: rate of change of X with respect to increasing column, i.e. pixel width b: rotation, 0 if the raster is oriented "north up" c: X coordinate of the top left corner of the top left pixel d: rotation, 0 if the raster is oriented "north up" e: rate of change of Y with respect to increasing row, usually a negative number (i.e. -1 * pixel height) if north-up. f: Y coordinate of the top left corner of the top left pixel A 6-element sequence of the affine transformation matrix coefficients in ``c, a, b, f, d, e`` order, (i.e. GDAL geotransform order) will be accepted until 1.0 (deprecated). A virtual filesystem can be specified. The ``vfs`` parameter may be an Apache Commons VFS style string beginning with "zip://" or "tar://"". In this case, the ``path`` must be an absolute path within that container. """ if not isinstance(fp, string_types): if not (hasattr(fp, 'read') or hasattr(fp, 'write')): raise TypeError("invalid path or file: {0!r}".format(fp)) if mode and not isinstance(mode, string_types): raise TypeError("invalid mode: {0!r}".format(mode)) if driver and not isinstance(driver, string_types): raise TypeError("invalid driver: {0!r}".format(driver)) if dtype and not check_dtype(dtype): raise TypeError("invalid dtype: {0!r}".format(dtype)) if nodata is not None: nodata = float(nodata) if 'affine' in kwargs: # DeprecationWarning's are ignored by default with warnings.catch_warnings(): warnings.warn( "The 'affine' kwarg in rasterio.open() is deprecated at 1.0 " "and only remains to ease the transition. Please switch to " "the 'transform' kwarg. See " "https://github.com/mapbox/rasterio/issues/86 for details.", DeprecationWarning, stacklevel=2) if transform: warnings.warn( "Found both 'affine' and 'transform' in rasterio.open() - " "choosing 'transform'") transform = transform else: transform = kwargs.pop('affine') if transform: transform = guard_transform(transform) # Check driver/mode blacklist. if driver and is_blacklisted(driver, mode): raise RasterioIOError("Blacklisted: file cannot be opened by " "driver '{0}' in '{1}' mode".format( driver, mode)) # Special case for file object argument. if mode == 'r' and hasattr(fp, 'read'): @contextmanager def fp_reader(fp): memfile = MemoryFile(fp.read()) dataset = memfile.open() try: yield dataset finally: dataset.close() memfile.close() return fp_reader(fp) elif mode == 'w' and hasattr(fp, 'write'): @contextmanager def fp_writer(fp): memfile = MemoryFile() dataset = memfile.open(driver=driver, width=width, height=height, count=count, crs=crs, transform=transform, dtype=dtype, nodata=nodata, **kwargs) try: yield dataset finally: dataset.close() memfile.seek(0) fp.write(memfile.read()) memfile.close() return fp_writer(fp) else: # The 'normal' filename or URL path. _, _, scheme = parse_path(fp) with Env() as env: # Get AWS credentials only if we're attempting to access a # raster using the S3 scheme. if scheme == 's3': env.get_aws_credentials() log.debug("AWS credentials have been obtained") # Create dataset instances and pass the given env, which will # be taken over by the dataset's context manager if it is not # None. if mode == 'r': s = DatasetReader(fp) elif mode == 'r-': warnings.warn("'r-' mode is deprecated, use 'r'", DeprecationWarning) s = DatasetReader(fp) elif mode == 'r+': s = get_writer_for_path(fp)(fp, mode) elif mode == 'w': s = get_writer_for_driver(driver)(fp, mode, driver=driver, width=width, height=height, count=count, crs=crs, transform=transform, dtype=dtype, nodata=nodata, **kwargs) else: raise ValueError( "mode must be one of 'r', 'r+', or 'w', not %s" % mode) s.start() return s
def open(fp, mode='r', driver=None, width=None, height=None, count=None, crs=None, transform=None, dtype=None, nodata=None, sharing=True, **kwargs): """Open a dataset for reading or writing. The dataset may be located in a local file, in a resource located by a URL, or contained within a stream of bytes. In read ('r') or read/write ('r+') mode, no keyword arguments are required: these attributes are supplied by the opened dataset. In write ('w' or 'w+') mode, the driver, width, height, count, and dtype keywords are strictly required. Parameters ---------- fp : str, file object or pathlib.Path object A filename or URL, a file object opened in binary ('rb') mode, or a Path object. mode : str, optional 'r' (read, the default), 'r+' (read/write), 'w' (write), or 'w+' (write/read). driver : str, optional A short format driver name (e.g. "GTiff" or "JPEG") or a list of such names (see GDAL docs at http://www.gdal.org/formats_list.html). In 'w' or 'w+' modes a single name is required. In 'r' or 'r+' modes the driver can usually be omitted. Registered drivers will be tried sequentially until a match is found. When multiple drivers are available for a format such as JPEG2000, one of them can be selected by using this keyword argument. width, height : int, optional The numbers of rows and columns of the raster dataset. Required in 'w' or 'w+' modes, they are ignored in 'r' or 'r+' modes. count : int, optional The count of dataset bands. Required in 'w' or 'w+' modes, it is ignored in 'r' or 'r+' modes. dtype : str or numpy dtype The data type for bands. For example: 'uint8' or ``rasterio.uint16``. Required in 'w' or 'w+' modes, it is ignored in 'r' or 'r+' modes. crs : str, dict, or CRS; optional The coordinate reference system. Required in 'w' or 'w+' modes, it is ignored in 'r' or 'r+' modes. transform : Affine instance, optional Affine transformation mapping the pixel space to geographic space. Required in 'w' or 'w+' modes, it is ignored in 'r' or 'r+' modes. nodata : int, float, or nan; optional Defines the pixel value to be interpreted as not valid data. Required in 'w' or 'w+' modes, it is ignored in 'r' or 'r+' modes. sharing : bool A flag that allows sharing of dataset handles. Default is `True`. Should be set to `False` in a multithreaded:w program. kwargs : optional These are passed to format drivers as directives for creating or interpreting datasets. For example: in 'w' or 'w+' modes a `tiled=True` keyword argument will direct the GeoTIFF format driver to create a tiled, rather than striped, TIFF. Returns ------- A ``DatasetReader`` or ``DatasetWriter`` object. Examples -------- To open a GeoTIFF for reading using standard driver discovery and no directives: >>> import rasterio >>> with rasterio.open('example.tif') as dataset: ... print(dataset.profile) To open a JPEG2000 using only the JP2OpenJPEG driver: >>> with rasterio.open( ... 'example.jp2', driver='JP2OpenJPEG') as dataset: ... print(dataset.profile) To create a new 8-band, 16-bit unsigned, tiled, and LZW-compressed GeoTIFF with a global extent and 0.5 degree resolution: >>> from rasterio.transform import from_origin >>> with rasterio.open( ... 'example.tif', 'w', driver='GTiff', dtype='uint16', ... width=720, height=360, count=8, crs='EPSG:4326', ... transform=from_origin(-180.0, 90.0, 0.5, 0.5), ... nodata=0, tiled=True, compress='lzw') as dataset: ... dataset.write(...) """ if not isinstance(fp, string_types): if not (hasattr(fp, 'read') or hasattr(fp, 'write') or isinstance(fp, Path)): raise TypeError("invalid path or file: {0!r}".format(fp)) if mode and not isinstance(mode, string_types): raise TypeError("invalid mode: {0!r}".format(mode)) if driver and not isinstance(driver, string_types): raise TypeError("invalid driver: {0!r}".format(driver)) if dtype and not check_dtype(dtype): raise TypeError("invalid dtype: {0!r}".format(dtype)) if nodata is not None: nodata = float(nodata) if transform: transform = guard_transform(transform) # Check driver/mode blacklist. if driver and is_blacklisted(driver, mode): raise RasterioIOError( "Blacklisted: file cannot be opened by " "driver '{0}' in '{1}' mode".format(driver, mode)) # Special case for file object argument. if mode == 'r' and hasattr(fp, 'read'): @contextmanager def fp_reader(fp): memfile = MemoryFile(fp.read()) dataset = memfile.open(driver=driver, sharing=sharing) try: yield dataset finally: dataset.close() memfile.close() return fp_reader(fp) elif mode in ('w', 'w+') and hasattr(fp, 'write'): @contextmanager def fp_writer(fp): memfile = MemoryFile() dataset = memfile.open(driver=driver, width=width, height=height, count=count, crs=crs, transform=transform, dtype=dtype, nodata=nodata, sharing=sharing, **kwargs) try: yield dataset finally: dataset.close() memfile.seek(0) fp.write(memfile.read()) memfile.close() return fp_writer(fp) else: # If a pathlib.Path instance is given, convert it to a string path. if isinstance(fp, Path): fp = str(fp) # The 'normal' filename or URL path. path = parse_path(fp) # Create dataset instances and pass the given env, which will # be taken over by the dataset's context manager if it is not # None. if mode == 'r': s = DatasetReader(path, driver=driver, sharing=sharing, **kwargs) elif mode == 'r+': s = get_writer_for_path(path)(path, mode, driver=driver, sharing=sharing, **kwargs) elif mode.startswith("w"): s = get_writer_for_driver(driver)(path, mode, driver=driver, width=width, height=height, count=count, crs=crs, transform=transform, dtype=dtype, nodata=nodata, sharing=sharing, **kwargs) else: raise ValueError( "mode must be one of 'r', 'r+', or 'w', not %s" % mode) return s
def open(path, mode='r', driver=None, width=None, height=None, count=None, crs=None, transform=None, dtype=None, nodata=None, **kwargs): """Open file at ``path`` in ``mode`` 'r' (read), 'r+' (read and write), or 'w' (write) and return a dataset Reader or Updater object. In write mode, a driver name such as "GTiff" or "JPEG" (see GDAL docs or ``gdal_translate --help`` on the command line), ``width`` (number of pixels per line) and ``height`` (number of lines), the ``count`` number of bands in the new file must be specified. Additionally, the data type for bands such as ``rasterio.ubyte`` for 8-bit bands or ``rasterio.uint16`` for 16-bit bands must be specified using the ``dtype`` argument. Parameters ---------- mode: string "r" (read), "r+" (read/write), or "w" (write) driver: string driver code specifying the format name (e.g. "GTiff" or "JPEG"). See GDAL docs at http://www.gdal.org/formats_list.html (optional, required for writing). width: int number of pixels per line (optional, required for write) height: int number of lines (optional, required for write) count: int > 0 number of bands (optional, required for write) dtype: rasterio.dtype the data type for bands such as ``rasterio.ubyte`` for 8-bit bands or ``rasterio.uint16`` for 16-bit bands (optional, required for write) crs: dict or string Coordinate reference system (optional, recommended for write) transform: Affine instance Affine transformation mapping the pixel space to geographic space (optional, recommended for writing). nodata: number Defines pixel value to be interpreted as null/nodata (optional, recommended for write) Returns ------- A ``DatasetReader`` or ``DatasetUpdater`` object. Notes ----- In write mode, you must specify at least ``width``, ``height``, ``count`` and ``dtype``. A coordinate reference system for raster datasets in write mode can be defined by the ``crs`` argument. It takes Proj4 style mappings like .. code:: {'proj': 'longlat', 'ellps': 'WGS84', 'datum': 'WGS84', 'no_defs': True} An affine transformation that maps ``col,row`` pixel coordinates to ``x,y`` coordinates in the coordinate reference system can be specified using the ``transform`` argument. The value should be an instance of ``affine.Affine`` .. code:: python >>> from affine import Affine >>> transform = Affine(0.5, 0.0, -180.0, 0.0, -0.5, 90.0) These coefficients are shown in the figure below. .. code:: | x | | a b c | | c | | y | = | d e f | | r | | 1 | | 0 0 1 | | 1 | a: rate of change of X with respect to increasing column, i.e. pixel width b: rotation, 0 if the raster is oriented "north up" c: X coordinate of the top left corner of the top left pixel d: rotation, 0 if the raster is oriented "north up" e: rate of change of Y with respect to increasing row, usually a negative number (i.e. -1 * pixel height) if north-up. f: Y coordinate of the top left corner of the top left pixel A 6-element sequence of the affine transformation matrix coefficients in ``c, a, b, f, d, e`` order, (i.e. GDAL geotransform order) will be accepted until 1.0 (deprecated). A virtual filesystem can be specified. The ``vfs`` parameter may be an Apache Commons VFS style string beginning with "zip://" or "tar://"". In this case, the ``path`` must be an absolute path within that container. """ if not isinstance(path, string_types): raise TypeError("invalid path: {0!r}".format(path)) if mode and not isinstance(mode, string_types): raise TypeError("invalid mode: {0!r}".format(mode)) if driver and not isinstance(driver, string_types): raise TypeError("invalid driver: {0!r}".format(driver)) if dtype and not check_dtype(dtype): raise TypeError("invalid dtype: {0!r}".format(dtype)) if 'affine' in kwargs: # DeprecationWarning's are ignored by default with warnings.catch_warnings(): warnings.simplefilter('always') warnings.warn( "The 'affine' kwarg in rasterio.open() is deprecated as of 1.0 " "and only remains to ease the transition. Please switch to " "the 'transform' kwarg. See " "https://github.com/mapbox/rasterio/issues/86 for details.", DeprecationWarning, stacklevel=2) if transform: warnings.warn( "Found both 'affine' and 'transform' in rasterio.open() - " "choosing 'transform'") transform = transform else: transform = kwargs.pop('affine') if transform: transform = guard_transform(transform) # Get AWS credentials if we're attempting to access a raster # on S3. pth, archive, scheme = parse_path(path) if scheme == 's3': Env().get_aws_credentials() log.debug("AWS credentials have been obtained") # Check driver/mode blacklist. if driver and is_blacklisted(driver, mode): raise RasterioIOError("Blacklisted: file cannot be opened by " "driver '{0}' in '{1}' mode".format( driver, mode)) # Create dataset instances and pass the given env, which will # be taken over by the dataset's context manager if it is not # None. if mode == 'r': s = DatasetReader(path) elif mode == 'r-': warnings.warn("'r-' mode is deprecated, use 'r'", DeprecationWarning) s = DatasetReader(path) elif mode == 'r+': s = get_writer_for_path(path)(path, mode) elif mode == 'w': s = get_writer_for_driver(driver)(path, mode, driver=driver, width=width, height=height, count=count, crs=crs, transform=transform, dtype=dtype, nodata=nodata, **kwargs) else: raise ValueError( "mode string must be one of 'r', 'r+', or 'w', not %s" % mode) s.start() return s