示例#1
0
def test_encode_failrange():
    testdata = np.zeros((2))

    testdata[1] = 256 ** 3 + 1

    with pytest.raises(ValueError):
        data_to_rgb(testdata, 0, 1)
示例#2
0
def test_encode_failrange():
    testdata = np.zeros((2))

    testdata[1] = 256**3 + 1

    with pytest.raises(ValueError):
        data_to_rgb(testdata, 0, 1)
示例#3
0
def test_encode_data_roundtrip():
    minrand, maxrand = np.sort(np.random.randint(-427, 8848, 2))

    testdata = np.round(
        (np.sum(np.dstack(np.indices((512, 512), dtype=np.float64)), axis=2) /
         (511. + 511.)) * maxrand, 2) + minrand

    baseval = -1000
    interval = 0.1

    rtripped = _decode(data_to_rgb(testdata.copy(), baseval, interval),
                       baseval, interval)

    assert testdata.min() == rtripped.min()
    assert testdata.max() == rtripped.max()
示例#4
0
def tile(
    tile_z,
    tile_x,
    tile_y,
    tileformat,
    indexes=1,
    shadder=None,
    colormap=None,
    range=None,
):
    """Handle tile requests"""
    if tileformat == "jpg":
        tileformat = "jpeg"

    if colormap and shadder:
        return ("NOK", "text/plain",
                "Cannot pass shadder and colormap options")

    address = f"s3://elevation-tiles-prod/geotiff/{tile_z}/{tile_x}/{tile_y}.tif"
    data, mask = main.tile(address,
                           tile_x,
                           tile_y,
                           tile_z,
                           indexes=indexes,
                           tilesize=512)
    if shadder:
        tileformat = "png"
        if shadder == "mapbox":
            tile = encoders.data_to_rgb(data[0], -10000, 1)
        elif shadder == "mapzen":
            tile = mapzen_elevation_rgb.data_to_rgb(data)
        else:
            return ("NOK", "text/plain", f"Invalid shadder mode: {shadder}")
    else:
        if not range:
            range = "0,10000"
        histoCut = list(map(int, range.split(',')))

        tile = numpy.where(
            mask, linear_rescale(data, in_range=histoCut, out_range=[0, 255]),
            0)

    options = dict(mask=mask)
    if colormap:
        options.update(color_map=get_colormap(name=colormap))
    img = array_to_img(tile, **options)

    return ("OK", f"image/{tileformat}", img_to_buffer(img, tileformat))
示例#5
0
def test_encode_data_roundtrip():
    minrand, maxrand = np.sort(np.random.randint(-427, 8848, 2))

    testdata = np.round((np.sum(
        np.dstack(
            np.indices((512, 512),
                dtype=np.float64)),
        axis=2) / (511. + 511.)) * maxrand, 2) + minrand

    baseval = -1000
    interval = 0.1

    rtripped = _decode(data_to_rgb(testdata.copy(), baseval, interval), baseval, interval)

    assert testdata.min() == rtripped.min()
    assert testdata.max() == rtripped.max()
示例#6
0
def _tile_worker(tile):
    """
    For each tile, and given an open rasterio src, plus a`global_args` dictionary
    with attributes of `base_val`, `interval`, and a `writer_func`,
    warp a continous single band raster to a 512 x 512 mercator tile,
    then encode this tile into RGB.

    Parameters
    -----------
    tile: list
        [x, y, z] indices of tile

    Returns
    --------
    tile, buffer
        tuple with the input tile, and a bytearray with the data encoded into
        the format created in the `writer_func`

    """
    x, y, z = tile

    bounds = [
        c for i in (
            mercantile.xy(*mercantile.ul(x, y + 1, z)),
            mercantile.xy(*mercantile.ul(x + 1, y, z)),
        ) for c in i
    ]

    toaffine = transform.from_bounds(*bounds + [512, 512])

    out = np.empty((512, 512), dtype=src.meta["dtype"])

    reproject(
        rasterio.band(src, 1),
        out,
        dst_transform=toaffine,
        dst_crs="epsg:3857",
        resampling=Resampling.bilinear,
    )

    out = data_to_rgb(out, global_args["base_val"], global_args["interval"])

    return tile, global_args["writer_func"](out, global_args["kwargs"].copy(),
                                            toaffine)
示例#7
0
def _tile_worker(tile):
    """
    For each tile, and given an open rasterio src, plus a`global_args` dictionary
    with attributes of `base_val`, `interval`, and a `writer_func`,
    warp a continous single band raster to a 512 x 512 mercator tile,
    then encode this tile into RGB.

    Parameters
    -----------
    tile: list
        [x, y, z] indices of tile

    Returns
    --------
    tile, buffer
        tuple with the input tile, and a bytearray with the data encoded into
        the format created in the `writer_func`

    """
    x, y, z = tile

    bounds = [c for i in (mercantile.xy(*mercantile.ul(x, y + 1, z)),
            mercantile.xy(*mercantile.ul(x + 1, y, z))) for c in i]

    toaffine = transform.from_bounds(*bounds + [512, 512])

    out = np.empty((512, 512), dtype=src.meta['dtype'])

    reproject(
        rasterio.band(src, 1), out,
        dst_transform=toaffine,
        dst_crs="epsg:3857",
        resampling=RESAMPLING.bilinear)

    out = data_to_rgb(out, global_args['base_val'], global_args['interval'])

    return tile, global_args['writer_func'](out, global_args['kwargs'].copy(), toaffine)
示例#8
0
def tile(
    z,
    x,
    y,
    scale=1,
    ext="png",
    url=None,
    indexes=None,
    expr=None,
    nodata=None,
    rescale=None,
    color_formula=None,
    color_map=None,
    dem=None,
):
    """Handle tile requests."""
    if ext == "jpg":
        driver = "jpeg"
    elif ext == "jp2":
        driver = "JP2OpenJPEG"
    else:
        driver = ext

    if indexes and expr:
        raise TilerError("Cannot pass indexes and expression")
    if not url:
        raise TilerError("Missing 'url' parameter")

    if indexes:
        indexes = tuple(int(s) for s in re.findall(r"\d+", indexes))

    tilesize = scale * 256

    if nodata is not None:
        nodata = numpy.nan if nodata == "nan" else float(nodata)

    if expr is not None:
        tile, mask = expression(url, x, y, z, expr, tilesize=tilesize)
    else:
        tile, mask = main.tile(url,
                               x,
                               y,
                               z,
                               indexes=indexes,
                               tilesize=tilesize)

    if dem:
        if dem == "mapbox":
            tile = encoders.data_to_rgb(tile, -10000, 1)
        elif dem == "mapzen":
            tile = mapzen_elevation_rgb.data_to_rgb(tile)
        else:
            return ("NOK", "text/plain", 'Invalid "dem" mode')
    else:
        rtile, rmask = _postprocess(tile,
                                    mask,
                                    tilesize,
                                    rescale=rescale,
                                    color_formula=color_formula)

        if color_map:
            color_map = get_colormap(color_map, format="gdal")

    options = img_profiles.get(driver, {})
    return (
        "OK",
        f"image/{ext}",
        array_to_image(rtile,
                       rmask,
                       img_format=driver,
                       color_map=color_map,
                       **options),
    )
示例#9
0
def _rgb_worker(data, window, ij, g_args):
    return data_to_rgb(data[0][g_args["bidx"] - 1], g_args["base_val"],
                       g_args["interval"])
示例#10
0
def tiles(
    z,
    x,
    y,
    scale=1,
    ext="png",
    url=None,
    nodata=None,
    indexes=None,
    rescale=None,
    color_ops=None,
    color_map=None,
    dem=None,
):
    """
    Handle Raster /tiles requests.

    Note: All the querystring parameters are translated to function keywords
    and passed as string value by lambda_proxy

    Attributes
    ----------
    z : int, required
        Mercator tile ZOOM level.
    x : int, required
        Mercator tile X index.
    y : int, required
        Mercator tile Y index.
    scale : int
        Output scale factor (default: 1).
    ext : str
        Image format to return (default: png).
    url : str, required
        Dataset url to read from.
    indexes : str, optional, (defaults: None)
        Comma separated band index number (e.g "1,2,3").
    nodata, str, optional
        Custom nodata value if not preset in dataset.
    rescale : str, optional
        Min and Max data bounds to rescale data from.
    color_ops : str, optional
        rio-color compatible color formula
    color_map : str, optional
        Rio-tiler compatible colormap name ("cfastie" or "schwarzwald")
    dem : str, optional
        Create Mapbox or Mapzen RGBA encoded elevation image

    Returns
    -------
    status : str
        Status of the request (e.g. OK, NOK).
    MIME type : str
        response body MIME type (e.g. image/jpeg).
    body : bytes
        Image body.

    """
    if not url:
        raise TilerError("Missing 'url' parameter")

    if indexes:
        indexes = tuple(int(s) for s in re.findall(r"\d+", indexes))

    if nodata is not None and isinstance(nodata, str):
        nodata = numpy.nan if nodata == "nan" else float(nodata)

    tilesize = 256 * scale

    tile, mask = main.tile(url,
                           x,
                           y,
                           z,
                           indexes=indexes,
                           tilesize=tilesize,
                           nodata=nodata)

    if dem:
        if dem == "mapbox":
            tile = encoders.data_to_rgb(tile, -10000, 1)
        elif dem == "mapzen":
            tile = mapzen_elevation_rgb.data_to_rgb(tile)
        else:
            return ("NOK", "text/plain", 'Invalid "dem" mode')
    else:
        rtile, rmask = _postprocess_tile(tile,
                                         mask,
                                         rescale=rescale,
                                         color_ops=color_ops)

        if color_map:
            color_map = get_colormap(color_map, format="gdal")

    driver = "jpeg" if ext == "jpg" else ext
    options = img_profiles.get(driver, {})
    return (
        "OK",
        f"image/{ext}",
        array_to_image(rtile,
                       rmask,
                       img_format=driver,
                       color_map=color_map,
                       **options),
    )
示例#11
0
def tile(
    z: int,
    x: int,
    y: int,
    scale: int = 1,
    ext: str = None,
    url: str = None,
    indexes: Union[str, Tuple[int]] = None,
    expr: str = None,
    nodata: Union[str, int, float] = None,
    rescale: str = None,
    color_formula: str = None,
    color_map: str = None,
    dem: str = None,
) -> Tuple[str, str, BinaryIO]:
    """Handle tile requests."""
    driver = "jpeg" if ext == "jpg" else ext

    if indexes and expr:
        raise TilerError("Cannot pass indexes and expression")

    if not url:
        raise TilerError("Missing 'url' parameter")

    if isinstance(indexes, str):
        indexes = tuple(int(s) for s in re.findall(r"\d+", indexes))

    if nodata is not None:
        nodata = numpy.nan if nodata == "nan" else float(nodata)

    tilesize = scale * 256

    if expr is not None:
        tile, mask = expression(url,
                                x,
                                y,
                                z,
                                expr=expr,
                                tilesize=tilesize,
                                nodata=nodata)
    else:
        tile, mask = main.tile(url,
                               x,
                               y,
                               z,
                               indexes=indexes,
                               tilesize=tilesize,
                               nodata=nodata)

    if dem:
        if dem == "mapbox":
            tile = encoders.data_to_rgb(tile, -10000, 1)
        elif dem == "mapzen":
            tile = mapzen_elevation_rgb.data_to_rgb(tile)
        else:
            return ("NOK", "text/plain", 'Invalid "dem" mode')
    else:
        rtile, rmask = _postprocess(tile,
                                    mask,
                                    rescale=rescale,
                                    color_formula=color_formula)

        if color_map:
            color_map = get_colormap(color_map, format="gdal")

    options = img_profiles.get(driver, {})
    return (
        "OK",
        f"image/{ext}",
        array_to_image(rtile,
                       rmask,
                       img_format=driver,
                       color_map=color_map,
                       **options),
    )
示例#12
0
文件: cli.py 项目: mapbox/rio-rgbify
def _rgb_worker(data, window, ij, g_args):
    return data_to_rgb(data[0][g_args['bidx'] - 1],
        g_args['base_val'],
        g_args['interval'])
示例#13
0
def _rgb_worker(data, window, ij, g_args):
    return data_to_rgb(data[0][g_args['bidx'] - 1], g_args['base_val'],
                       g_args['interval'])