User friendly Rasterio plugin to read raster datasets.

Overview

rio-tiler

rio-tiler

User friendly Rasterio plugin to read raster datasets.

Test Coverage Package version Conda Forge Downloads Downloads Binder


Documentation: https://cogeotiff.github.io/rio-tiler/

Source Code: https://github.com/cogeotiff/rio-tiler


Description

rio-tiler was initialy designed to create slippy map tiles from large raster data sources and render these tiles dynamically on a web map. With rio-tiler v2.0 we added many more helper methods to read data and metadata from any raster source supported by Rasterio/GDAL. This includes local files and via HTTP, AWS S3, Google Cloud Storage, etc.

At the low level, rio-tiler is just a wrapper around the rasterio.vrt.WarpedVRT class, which can be useful for doing reprojection and/or property overriding (e.g nodata value).

Features

  • Read any dataset supported by GDAL/Rasterio

    from rio_tiler.io import COGReader
    
    with COGReader("my.tif") as image:
        print(image.dataset)  # rasterio opened dataset
        img = image.read()    # similar to rasterio.open("my.tif").read() but returns a rio_tiler.models.ImageData object
  • User friendly tile, part, feature, point reading methods

    from rio_tiler.io import COGReader
    
    with COGReader("my.tif") as image:
        img = image.tile(x, y, z)            # read mercator tile z-x-y
        img = image.part(bbox)               # read the data intersecting a bounding box
        img = image.feature(geojson_feature) # read the data intersecting a geojson feature
        img = image.point(lon,lat)           # get pixel values for a lon/lat coordinates
  • Enable property assignement (e.g nodata) on data reading

    from rio_tiler.io import COGReader
    
    with COGReader("my.tif") as image:
        img = image.tile(x, y, z, nodata=-9999) # read mercator tile z-x-y
  • STAC support

    from rio_tiler.io import STACReader
    
    with STACReader("item.json") as stac:
        print(stac.assets)  # available asset
        img = stac.tile(x, y, z, assets="asset1", indexes=(1, 2, 3))  # read tile for asset1 and indexes 1,2,3
        img = stac.tile(x, y, z, assets=("asset1", "asset2", "asset3",), indexes=(1,))  # create an image from assets 1,2,3 using their first band
  • Mosaic (merging or stacking)

    from rio_tiler.io import COGReader
    from rio_tiler.mosaic import mosaic_reader
    
    def reader(file, x, y, z, **kwargs):
        with COGReader("my.tif") as image:
            return image.tile(x, y, z, **kwargs)
    
    img, assets = mosaic_reader(["image1.tif", "image2.tif"], reader, x, y, z)
  • Native support for multiple TileMatrixSet via morecantile

    import morecantile
    from rio_tiler.io import COGReader
    
    # Use EPSG:4326 (WGS84) grid
    wgs84_grid = morecantile.tms.get("WorldCRS84Quad")
    with COGReader("my.tif", tms=wgs84_grid) as cog:
        img = cog.tile(1, 1, 1)

Install

You can install rio-tiler using pip

$ pip install -U pip
$ pip install -U rio-tiler

or install from source:

$ git clone https://github.com/cogeotiff/rio-tiler.git
$ cd rio-tiler
$ pip install -U pip
$ pip install -e .

GDAL>=3.0 / PROJ>=6.0 performances issue

rio-tiler is often used for dynamic tiling, where we need to perform small tasks involving cropping and reprojecting the input data. Starting with GDAL>=3.0 the project shifted to PROJ>=6, which introduced new ways to store projection metadata (using a SQLite database and/or cloud stored grids). This change introduced a performance regression as mentioned in https://mapserver.gis.umn.edu/id/development/rfc/ms-rfc-126.html:

using naively the equivalent calls proj_create_crs_to_crs() + proj_trans() would be a major performance killer, since proj_create_crs_to_crs() can take a time in the order of 100 milliseconds in the most complex situations.

We believe the issue reported in issues/346 is in fact due to ☝️ .

To get the best performances out of rio-tiler we recommend for now to use GDAL 2.4 until a solution can be found in GDAL or in PROJ.

Note: Starting with rasterio 1.2.0, rasterio's wheels are distributed with GDAL 3.2 and thus we recommend using rasterio==1.1.8 if using the default wheels, which include GDAL 2.4.

Links:

Plugins

rio-tiler-pds

rio-tiler v1 included several helpers for reading popular public datasets (e.g. Sentinel 2, Sentinel 1, Landsat 8, CBERS) from cloud providers. This functionality is now in a separate plugin, enabling easier access to more public datasets.

rio-tiler-mvt

Create Mapbox Vector Tiles from raster sources

Implementations

rio-viz: Visualize Cloud Optimized GeoTIFFs locally in the browser

titiler: A lightweight Cloud Optimized GeoTIFF dynamic tile server.

cogeo-mosaic: Create mosaics of Cloud Optimized GeoTIFF based on the mosaicJSON specification.

Contribution & Development

See CONTRIBUTING.md

Authors

The rio-tiler project was begun at Mapbox and was transferred to the cogeotiff Github organization in January 2019.

See AUTHORS.txt for a listing of individual contributors.

Changes

See CHANGES.md.

License

See LICENSE

Comments
  • Bug in new `calculate_default_transform` from terracotta

    Bug in new `calculate_default_transform` from terracotta

    While using the new calculate_default_transform from Terracotta seemed to help with the performance, I encountered a but when dealing with scene that crosses the dateline separation

    The problem happens here: https://github.com/cogeotiff/rio-tiler/blob/06504ec8321d185602a5a91bc6b5415bdb94915c/rio_tiler/utils.py#L232-L241

    which will return negative width/height

    Tile
    x=17
    y=21
    z=6
    
    vrt_transfrom
    |-386.76, 0.00,-9392582.04|
    | 0.00, 6.31, 6887893.49|
    | 0.00, 0.00, 1.00|
    
    vrt_width=-1619
    vrt_height=-99186
    

    dataset link: https://www.dropbox.com/s/jyskcxqnbq3240c/ask_cog.tif?dl=0

    Not sure if it means something but here is the result from both rasterio and terracotta's calculate_default_transform for a random tile.

    # rasterio
    | 238.34, 0.00,-20037508.08|
    | 0.00,-238.34, 13596067.67|
    | 0.00, 0.00, 1.00|
    
    # terracotta
    |-386.54, 0.00,-20028306.76|
    | 0.00, 6.31, 13596067.67|
    | 0.00, 0.00, 1.00|
    

    @dionhaefner, could you test terracotta with the dataset I shared, so I can confirm this is only happening in rio-tiler ?

    bug 
    opened by vincentsarago 16
  • Explore DHI-GRAS/terracotta and bring change over rio-tiler

    Explore DHI-GRAS/terracotta and bring change over rio-tiler

    https://github.com/DHI-GRAS/terracotta is a new lib inspired by rio-tiler made by @dionhaefner et all. This lib has plenty of nice tricks which could be useful in rio-tiler eg:

    • different resampling method for up and down sampling: https://github.com/DHI-GRAS/terracotta/blob/7aa0751a105d1a804f0c5389e0abaab4399ffdee/terracotta/drivers/raster_base.py#L431-L436
    • check tile coverage https://github.com/DHI-GRAS/terracotta/blob/7aa0751a105d1a804f0c5389e0abaab4399ffdee/terracotta/drivers/raster_base.py#L428-L429
    • prevent interpolation artefact ? https://github.com/DHI-GRAS/terracotta/blob/7aa0751a105d1a804f0c5389e0abaab4399ffdee/terracotta/drivers/raster_base.py#L396-L411
    documentation 
    opened by vincentsarago 14
  • Use ColorInterp or MaskFlags to check alpha band

    Use ColorInterp or MaskFlags to check alpha band

    I got this error: https://github.com/mapbox/rasterio/blob/master/rasterio/_warp.pyx#L907

    and this code explains that it checks alpha band by GDAL color interpretation. https://github.com/mapbox/rasterio/blob/master/rasterio/_warp.pyx#L898

    p.s: sorry for my bad english

    opened by kprabowo 12
  • error when reading a file

    error when reading a file

    Hello, i have a tiff file that i can open with rasterio.

    But i get the following error with COGReader:

    File "/usr/local/lib/python3.9/site-packages/rio_tiler/io/cogeo.py", line 101, in attrs_post_init self.nodata = self.nodata if self.nodata is not None else self.dataset.nodata AttributeError: '_GeneratorContextManager' object has no attribute 'nodata'

    opened by nes123 10
  • Check if transform is ok

    Check if transform is ok

    first mentioned in https://github.com/cogeotiff/rio-cogeo/issues/164

    I'm seeing some weird Internal Tile fetching behavior. When working with a Web Mercator aligned file I would expect GDAL to only do 2 GET requests (header + tile) but It seems that we are fetching more than 1 tile.

    $ tilebench profile https://rio-tiler-dev.s3.amazonaws.com/data/eu_webAligned_256pxWEBP.tif --tile 5-10-9 --add-kernels | jq
    {
      "LIST": {
        "count": 0
      },
      "HEAD": {
        "count": 1
      },
      "GET": {
        "count": 3,
        "bytes": 17144,
        "ranges": [
          "0-16383",
          "205900-206279",
          "242386-242765"
        ]
      },
      "WarpKernels": [
        [
          "Src=512,2303,257x129",
          "Dst=0,0,256x128"
        ],
        [
          "Src=512,2431,257x129",
          "Dst=0,128,256x128"
        ]
      ],
      "Timing": 0.4853549003601074
    }
    

    ☝️ we do 3 GET,

    [
          "0-16383",  <-- GeoTIFF Header
          "205900-206279",  <--- Tile Data
          "242386-242765".  <--- Tile Data
    ]
    

    The weird part is when we look at the WarpKernels:

    [
        [
          "Src=512,2303,257x129",
          "Dst=0,0,256x128"
        ],
        [
          "Src=512,2431,257x129",
          "Dst=0,128,256x128"
        ]
    ]
    

    I'm not sure how to read the Kernels but the 257x129 seems weird.

    For the particular tile 5-10-9, here are the WarpedVRT info

    {
        'add_alpha': True, 
        'resampling': <Resampling.nearest: 0>, 
        'crs': CRS.from_epsg(3857), 
        'transform': Affine(2445.984905125635, 0.0, -7514065.6285459455, 0.0, -2445.984905125635, 8766409.89997027), 
        'width': 512, 
        'height': 512
    }
    Window(col_off=0, row_off=0, width=512, height=512)
    (3, 256, 256)
    

    The VRT is 512x512 for a 256x256 tile, which is what we expect because the zoom 5 correspond to the first overview.

    The input and output size are ok, so maybe we need to check if the transform is aligned with the internal tiles. https://github.com/cogeotiff/rio-tiler/blob/4bd9be5db98827e40d4222627c3af59e9063bd95/rio_tiler/utils.py#L166-L182

    bug enhancement help wanted 
    opened by vincentsarago 10
  • force overview dataset for WarpedVRT

    force overview dataset for WarpedVRT

    This is a major change

    While working on #95 and https://github.com/RemotePixel/amazonlinux/issues/10 I realized that maybe we were using WarpedVRT in an unoptimized way, when (comparing warped kernel + GET requests)

    This goes back to https://github.com/mapbox/rasterio/issues/1373 and precisely https://github.com/mapbox/rasterio/issues/1373#issuecomment-398487266

    When looking at the gdalwarp command I realized the gdal use specific overview level to create the output dataset. This PR tries to implement such logic.

    The first tests show that GET requests and output results are similar to gdalwarp outputs.

    ~@sgillies I'll need your help on this one (and I believe this will also fix the performance downgrade I saw in https://github.com/RemotePixel/amazonlinux/issues/10).~ (Edit the performance downgrade was due to SQLITE3 and centos) I'm not sure if this could also go directly to rasterio code base. (I know you have ton of stuff on your side so no stress, I'll continue to run some tests on my side).

    tagging @dionhaefner @mojodna because it might be of your interest.

    opened by vincentsarago 10
  • Apply same resampling method for mask and tile

    Apply same resampling method for mask and tile

    in https://github.com/cogeotiff/rio-tiler/blob/2bf9f144958ae226af4db338487e8a34159550be/rio_tiler/utils.py#L345-L353 we could end up (actual behavior) with using different resampling for mask and data which will result in bad masking.

    bug resolved-by-pr 
    opened by vincentsarago 10
  • Sentinel RasterIO Errors

    Sentinel RasterIO Errors

    Reopening issue #53 because this has not been fixed and is an issue with rio-tiler.

    Running the following:

    from rio_tiler import sentinel2
    import os
    os.environ["CURL_CA_BUNDLE"] = "/etc/ssl/certs/ca-certificates.crt"
    os.environ["AWS_REQUEST_PAYER"] = "requester"
    tile, mask = sentinel2.tile("S2B_tile_20180813_23MQQ_0", 781, 1052, 11, (4, 3, 2), tilesize=256)
    

    gives the error:

    RasterioIOError: '/vsis3/sentinel-s2-l1c/tiles/23/M/QQ/2018/8/13/0/B4.jp2' does not exist in the file system, and is not recognized as a supported dataset name.
    

    running gdalinfo on this path gives the error:

    ERROR 4: /vsis3/sentinel-s2-l1c/tiles/23/M/QQ/2018/8/13/0/B4.jp2: No such file or directory
    gdalinfo failed - unable to open '/vsis3/sentinel-s2-l1c/tiles/23/M/QQ/2018/8/13/0/B4.jp2'.
    

    This path is being generated by rio-tiler. This is only happening on Sentinel; Landsat works fine.

    opened by zags 10
  • Masking error for complex multipolygon cutlines with holes

    Masking error for complex multipolygon cutlines with holes

    rio-tiler version: rio-tiler==2.0.0rc4

    Recreate:

    from rio_tiler.io import COGReader
    import matplotlib.pyplot as plt
    
    
    feature = ... # huge multipolygon I'll attach separately
    
    with COGReader('https://rio-tiler-dev.s3.amazonaws.com/data/eu_webAligned_256pxWEBP.tif') as cog:
        data, mask = cog.feature(feature['geometry'])
    
    plt.imshow(mask)
    plt.show()
    

    rio-tiler-mask

    Tried the .buffer(0) trick as well with no change to the result. Geometry returns True for is_valid

    wontfix documentation 
    opened by drewbo 9
  • transform_bounds does not appear to support bbox crossing the antimeridian

    transform_bounds does not appear to support bbox crossing the antimeridian

    example (EPSG:32601)

    Upper Left  (365474, 7696071) 
    Lower Left  (365474, 7591951) 
    Upper Right (477094, 7696071)
    Lower Right (477094, 7591951)
    

    rasterio. warp.transform_bounds return flattened bounds.

    transform_bounds('EPSG:32601', 'EPSG:4326', 365474, 7591951, 477094, 7696071)
    -> (-179.90689695793938, 68.40816857051695, 179.96969316611757, 69.37306968939305)
    

    correct bounds (179.5819541972332, 68.40816857051695, -177.55854062377162, 69.37306968939305)

    It seems to need checking transformed points is crossing the antimeridian. For example, like this.

    def is_clockwise(xs, ys):
        if len(xs) != len(ys):
            raise TransformError("xs and ys arrays must be the same length") 
        
        area = 0
        if len(xs) > 2:
            if xs[0] == xs[-1] and ys[0] == ys[-1]:
                length = len(xs) - 1
            else:
                length = len(xs)
            
            for i in range(length - 1):
                area = area + xs[i] * ys[i+1] - ys[i] * xs[i+1]
            area = area + xs[length - 1] * ys[0] - ys[length - 1] * xs[0]
                
        return area >= 0
    
    def transform_bounds(
            src_crs,
            dst_crs,
            left,
            bottom,
            right,
            top,
            densify_pts=21):
        if densify_pts < 0:
            raise ValueError('densify parameter must be >= 0')
    
        if src_crs == dst_crs:
            return [left, bottom, right, top]
        
        in_xs = []
        in_ys = []
    
        if densify_pts > 0:
            densify_factor = 1.0 / float(densify_pts + 1)
            
            # left_bottom to right_bottom
            in_xs.extend(
                left + np.arange(1, densify_pts + 1, dtype=np.float64) *
                ((right - left) * densify_factor)
            )
            in_ys.extend([bottom] * densify_pts)
            # right_bottom to right_top
            in_xs.extend([right] * (densify_pts + 2))
            in_ys.extend(
                bottom + np.arange(0, densify_pts + 2, dtype=np.float64) *
                ((top - bottom) * densify_factor)
            )
            # right_top to left_top
            in_xs.extend(
                right + np.arange(1, densify_pts + 1, dtype=np.float64) *
                ((left - right) * densify_factor)
            )
            in_ys.extend([top] * densify_pts)
            # left_top to left_bottom
            in_xs.extend([left] * (densify_pts + 2))
            in_ys.extend(
                top + np.arange(0, densify_pts + 2, dtype=np.float64) *
                ((bottom - top) * densify_factor)
            )        
    
        else:
            in_xs = np.array(left, right, right, left,left)
            in_ys = np.array(bottom, bottom, top, top, bottom)
    
        xs, ys = transform(src_crs, dst_crs, in_xs, in_ys)
        if dst_crs == 'EPSG:4326' and not is_clockwise(xs, ys):
            xs = [x + 360 if x < 0 else x for x in xs]
            return (min(xs), min(ys), max(xs) - 360, max(ys))
        
        return (min(xs), min(ys), max(xs), max(ys))
    

    cogeo.bounds, cogeo.get_zooms, reader.part , etc., a lot of methods to create tile are affected. Couldn't we improve?

    opened by yonda-yonda 9
  • Provide parameter for retrieving additional data around tile edges to minimise edge effects

    Provide parameter for retrieving additional data around tile edges to minimise edge effects

    As proposed in #56 this PR aims to reduce the edge effects associated with tiles by introducing a tile_edges_padding parameter. Additional data is retrieved around the tiles edges during the tile generation process which helps to reduce sharp edges that occur due to resampling.

    @vincentsarago did suggest

    and then overwrite it to 0 if we don't need resampling (if the internal tiles match the requested bounds)

    I'm not really sure how we'd know about the internal tiles so happy to take any advice on this one :)

    Let me know if you need anything else on this.

    opened by rowanwins 9
  • Enable setting gcps in Reader option

    Enable setting gcps in Reader option

    Let's say you have an Non-geo image (as COG already) and some external GCP (e.g from a Georeferencing UI), it would be nice to pass those GCPS to rio_tiler.io.Reader directly to allow virtual georeferencing

    https://github.com/cogeotiff/rio-tiler/blob/93cf68ed9d4ba62c9fb51a11f601c1a141324ebb/rio_tiler/io/rasterio.py#L98-L110

    opened by vincentsarago 0
  • add issue template

    add issue template

    Let's make it clear what user should write to avoid issues like #546 #545

    ref: https://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests

    Here is a simple template we have at devseed

    <!-- Please search existing issues to avoid creating duplicates. -->
    
    
    #### Problem description
    
    [this should explain **why** the current behavior is a problem and why the expected output is a better solution.]
    
    #### Expected Output
    
    
    #### Environment Information
    
    Os, Python version, ...
    
    
    opened by vincentsarago 0
  • COGReader.tile doesn't take into account mask band in some circumstances

    COGReader.tile doesn't take into account mask band in some circumstances

    There is following set of files:

    • masked.tif (with PER_DATASET internal mask)
    • data.vrt built based on masked.tif
    • data.vrt.ovr (external overviews)

    Let's try to render a tile out of it:

    In [1]: from rio_tiler.io import COGReader
    
    In [2]: with COGReader("/tmp/test/data.vrt") as cog:
       ...:     tile = cog.tile(2323, 3503, 13, tilesize=256)
       ...: 
    GDAL: GDALClose(/tmp/test/masked.tif, this=0x3699940)
    GDAL: GDALClose(/tmp/test/data.vrt, this=0x3640b10)
    
    In [3]: with open("/tmp/test/tile-ok.png", "wb") as dst:
       ...:     dst.write(tile.render())
    

    Expected result (screenshot from QGIS):

    image

    Actual result:

    tile-ok

    Everything is fine.

    Now let's try to render tile on a lower zoom level, in this case GDAL will use existing overviews.

    In [1]: from rio_tiler.io import COGReader
    
    In [2]: with COGReader("/tmp/test/data.vrt") as cog:
       ...:     tile = cog.tile(72, 109, 8, tilesize=256)
       ...: 
    GDAL: GDALClose(/tmp/test/masked.tif, this=0x2f1f7e0)
    GDAL: GDALClose(/tmp/test/data.vrt, this=0x20b6740)
    GDAL: GDALClose(/tmp/test/data.vrt.ovr, this=0x2e51cc0)
    
    In [3]: with open("/tmp/test/tile-nok.png", "wb") as dst:
       ...:     dst.write(tile.render())
       ...: 
    

    Expected result: image

    Actual result: tile-nok

    As you can see the mask has not been taken into account.

    Files that are being used: example.zip

    wontfix blocked 
    opened by drnextgis 13
  • read low resolution version of the data

    read low resolution version of the data

    By design rio-tiler assume you are working within the native zoom range of your data (raw data = Max res, max res/number of overviews ~= minzoom).

    When reading a file, we always use a VRT to align the data to the bounds/size we want to read. This is all defined in https://github.com/cogeotiff/rio-tiler/blob/ccf6aa002fc0c3525c9889cffbb9ca26689ba0b9/rio_tiler/utils.py#L172-L188

    (this part was copie from https://github.com/mapbox/rasterio/issues/1373#issuecomment-398261502)

    if you try to read a really low version of your data, we will first create a huge VRT and then ask to read a decimated part of it (this is to make sure we read the overview).

    To be honest, for now I'm not sure there is a solution for this.

    opened by vincentsarago 0
  • Add indexes option to img.render() ?

    Add indexes option to img.render() ?

    Using img.render() with an ImageData.data array with too many bands fails with CPLE_NotSupportedError: PNG driver doesn't support 5 bands. Must be 1 (grey), 2 (grey+alpha), 3 (rgb) or 4 (rgba) bands.

    Example:

    src_path = "https://naipblobs.blob.core.windows.net/naip/v002/al/2019/al_60cm_2019/30087/m_3008701_ne_16_060_20191115.tif"
    with COGReader(src_path) as cog:
        img = cog.preview()    
        print(img.data.shape)  # >>> (4, 1024, 892)
    
    img.render()
    

    Reading all bands and later visualizing a band subset (without mutating the array) seems like a common usecase. Would propose to add an indexes parameter to .render(), so that specific bands can be selected for the vizualization.

    Happy to make a PR, but wanted to check first if there is a better solution or this is not intended etc.

    opened by chrieke 1
Owner
Pushing for adoption of Cloud Optimized GeoTIFF: An imagery format for cloud-native geospatial processing
null
Read and write rasters in parallel using Rasterio and Dask

dask-rasterio dask-rasterio provides some methods for reading and writing rasters in parallel using Rasterio and Dask arrays. Usage Read a multiband r

Dymaxion Labs 85 Aug 30, 2022
Histogram matching plugin for rasterio

rio-hist Histogram matching plugin for rasterio. Provides a CLI and python module for adjusting colors based on histogram matching in a variety of col

Mapbox 75 Sep 23, 2022
Color correction plugin for rasterio

rio-color A rasterio plugin for applying basic color-oriented image operations to geospatial rasters. Goals No heavy dependencies: rio-color is purpos

Mapbox 111 Nov 15, 2022
Cloud Optimized GeoTIFF creation and validation plugin for rasterio

rio-cogeo Cloud Optimized GeoTIFF (COG) creation and validation plugin for Rasterio. Documentation: https://cogeotiff.github.io/rio-cogeo/ Source Code

null 216 Dec 31, 2022
Summary statistics of geospatial raster datasets based on vector geometries.

rasterstats rasterstats is a Python module for summarizing geospatial raster datasets based on vector geometries. It includes functions for zonal stat

Matthew Perry 437 Dec 23, 2022
A light-weight, versatile XYZ tile server, built with Flask and Rasterio :earth_africa:

Terracotta is a pure Python tile server that runs as a WSGI app on a dedicated webserver or as a serverless app on AWS Lambda. It is built on a modern

DHI GRAS 531 Dec 28, 2022
How to use COG's (Cloud optimized GeoTIFFs) with Rasterio

How to use COG's (Cloud optimized GeoTIFFs) with Rasterio According to Cogeo.org: A Cloud Opdtimized GeoTIFF (COG) is a regular GeoTIFF file, aimed at

Marvin Gabler 8 Jul 29, 2022
Raster-based Spatial Analysis for Python

?? xarray-spatial: Raster-Based Spatial Analysis in Python ?? Fast, Accurate Python library for Raster Operations ⚡ Extensible with Numba ⏩ Scalable w

makepath 649 Jan 1, 2023
🌐 Local tile server for viewing geospatial raster files with ipyleaflet

?? Local Tile Server for Geospatial Rasters Need to visualize a rather large raster (gigabytes) you have locally? This is for you. A Flask application

Bane Sullivan 192 Jan 4, 2023
🌐 Local tile server for viewing geospatial raster files with ipyleaflet or folium

?? Local Tile Server for Geospatial Rasters Need to visualize a rather large (gigabytes) raster you have locally? This is for you. A Flask application

Bane Sullivan 192 Jan 4, 2023
Advanced raster and geometry manipulations

buzzard In a nutshell, the buzzard library provides powerful abstractions to manipulate together images and geometries that come from different kind o

Earthcube Lab 30 Jun 20, 2022
Read images to numpy arrays

mahotas-imread: Read Image Files IO with images and numpy arrays. Mahotas-imread is a simple module with a small number of functions: imread Reads an

Luis Pedro Coelho 67 Jan 7, 2023
Client library for interfacing with USGS datasets

USGS API USGS is a python module for interfacing with the US Geological Survey's API. It provides submodules to interact with various endpoints, and c

Amit Kapadia 104 Dec 30, 2022
A public data repository for datasets created from TransLink GTFS data.

TransLink Spatial Data What: TransLink is the statutory public transit authority for the Metro Vancouver region. This GitHub repository is a collectio

Henry Tang 3 Jan 14, 2022
A NASA MEaSUREs project to provide automated, low latency, global glacier flow and elevation change datasets

Notebooks A NASA MEaSUREs project to provide automated, low latency, global glacier flow and elevation change datasets This repository provides tools

NASA Jet Propulsion Laboratory 27 Oct 25, 2022
List of Land Cover datasets in the GEE Catalog

List of Land Cover datasets in the GEE Catalog A list of all the Land Cover (or discrete) datasets in Google Earth Engine. Values, Colors and Descript

David Montero Loaiza 5 Aug 24, 2022
Helping data scientists better understand their datasets and models in text classification. With love from ServiceNow.

Azimuth, an open-source dataset and error analysis tool for text classification, with love from ServiceNow. Overview Azimuth is an open source applica

ServiceNow 145 Dec 23, 2022
Google Maps keeps old satellite imagery around for a while – this tool collects what's available for a user-specified region in the form of a GIF.

google-maps-at-88-mph The folks maintaining Google Maps regularly update the satellite imagery it serves its users, but outdated versions of the image

Noah Doersing 111 Sep 27, 2022
This GUI app was created to show the detailed information about the weather in any city selected by user

WeatherApp Content Brief description Tools Features Hotkeys How it works Screenshots Ways to improve the project Installation Brief description This G

TheBugYouCantFix 5 Dec 30, 2022