Hi Idan,

thanks, that's already quite useful. This is typically the kind of default values I encounter when using GDAL in the command line indeed.

This does not match the values I find when using rasterio's reproject, when nodata is set to None, which would be, e.g.

- uint8: 255 -> ok
- uint16: 65535 -> ok

- int16: 32767 -> ok
- uint32: 999999 -> not the same

- float32: 1e20 -> not the same

- float64: 1e20 -> not the same

Amaury

Hi,

what is the default nodata used by GDAL, and hence rasterio, for any given dtype?
For example, rasterio.warp.reproject states:
dst_nodata (int or float, optional) – The nodata value used to initialize the destination; it will remain in all areas not covered by the reprojected source. Defaults to the nodata value of the destination image (if set), the value of src_nodata, or 0 (GDAL default).

But I couldn't find anywhere in rasterio's or GDAL's documentation what was the default value for any given dtype.

Thanks,

Amaury

Hi all,

on the same topic, is there an easy way to get the destination parameters (transform, width, height) exactly as GDAL would do, considering the user might provide any of, or a combination of, the following: dst_bounds, dst_width/height, dst_res.

I understand that if dst_width/height or resolution are provided, the output transformation and width/height can easily be calculated using calculate_default_transform (and aligned_target if the resolution is to be strictly enforced). But what if dst_bounds are also set?

Let's consider the following cases:

- dst_bounds is set alone -> GDAL output strictly enforces the output bounds but keeps the output resolution as close as possible to the input resolution

- dst_bounds and res are set -> GDAL output enforces the output resolution and use the bounds that are as close as possible to the requested bounds

- dst_bounds and res are set+ tap option -> same as before but output bounds is a multiple of the resolution

- dst_bounds and width/height are set -> GDAL outputs shape and bounds are strictly enforced, the resolution is set accordingly.

Currently, I cannot find an easy way to do this with rasterio. At least a specific, non trivial order of rasterio functions have to be called, to get exactly this behavior. There could possibly be a specific rasterio function to do this.

Thanks in advance!

Amaury

Hi,

We are working on a process that extracts values from raster data and returns them as GeoJSON geometries. Our use cases are point, line, and polygon. 

For the line use case, we are trying to return the values and coordinates for each raster cell intersected by the line. We would also like to have the coordinates returned in geographic coordinates. To do this we are trying to use rasterio.transform.xy.

The problem we are encountering is that rasterio.transform.xy is not returning the coordinates in lat/long but rather in their native projection. We think this is caused by using the incorrect transform (Affine.affine) parameter.

Our setup is below. Note in this case shapes is a GeoJSON LineString:

```
with rasterio.open(raster_path) as src:

       out_image, out_transform = rasterio.mask.mask(src, shapes, crop=True)

       with MemoryFile() as memfile:

               with memfile.open(driver="GTiff", height=out_image.shape[1], width=out_image.shape[2], count=1,

                                      dtype=rasterio.float64, transform=out_transform) as dataset:

                        dataset.write(out_image)

                        ds = dataset.read()

                        xs_to_mod = list(range(0, ds.shape[1]))

                        ys_to_mod = list(range(0, ds.shape[2]))

                        xs, ys = rasterio.transform.xy(out_transform, xs_to_mod, ys_to_mod, offset='center')

```
Thank you

Hi All,

I am processing SNODAS data archives that store each variable in a single-band ESRI BIL format raster. rasterio.open() works like a charm when a) fp references a file on disk and b) when a hdr (header) file exists in that same location. (I am attaching a working set of files for reference).

I am curious if there is a way to load the raster from memory though. Since each eraster within the archive aforementioned archive is compressed using gzip, The goal is to download the dataset, unpack the .bil file, open it with the matching header information, and store it as e.g. GeoTIFF for further processing. Below is some code that (obviously) fails when it passes a tuple to the rasterio.open fp argument.

Looking forward to your thoughts on this. Thanks in advance,

Florian

Thanks for your reply, Sean.

> are you proposing that potentially any cloud platform would be made first class in rasterio, concretely, as in GDAL and as with rasterio/S3 today?

Yes, thats right.

> What would you think if rasterio were to take the opposite approach and require users to write ~5 lines of code themselves to adapt output of, say, keystonev3 and swiftclient to a standard interface in rasterio

Yeah, I actually had the same thought too, but wasn't sure if it would be received well.

That is actually kind-of how you can do it in rasterio already. You can manually create a `keystonev3` or `swiftclient` auth session, and populate it with your credentials. You can then manually create a rasterio `SwiftClient`, and give it that auth session. Then pass the pre-configured `SwiftClient` into `session.Env()` and rasterio will use that as the Cloud Session. Its a bit of boilerplate code, but it works across all of the existing `Session` subclasses for the different cloud platforms already.

Should that be the "standard" way of doing it? Could it be cleaner? Would AWS S3 still be a special case?

My end goal is to be able to use OpenStack Swift ObjectStore as a storage backend for an opendatacube project. Opendatacube only supports AWS S3 for now, because it relies on rasterio's "first-class" interface to S3. I was told, if I want to get other cloud providers working natively in opendatacube, we need them to be fully supported by rasterio first (as you mentioned, they're already fully supported by GDAL).

Ashley Sommer

• https://corteva.github.io/rioxarray/stable/examples/dask_read_write.html
• https://corteva.github.io/rioxarray/stable/examples/read-locks.html