def test_find_quadkeys():
    """Get correct quadkeys"""
    tile = mercantile.Tile(150, 182, 9)
    assert utils.find_quadkeys(tile, 8) == ["03023033"]
    assert utils.find_quadkeys(tile, 9) == ["030230330"]
    assert utils.find_quadkeys(tile, 10) == [
        "0302303300",
        "0302303301",
        "0302303303",
        "0302303302",
    ]
Exemple #2
0
 def get_assets(self, x: int, y: int, z: int) -> List[str]:
     """Find assets."""
     mercator_tile = mercantile.Tile(x=x, y=y, z=z)
     quadkeys = find_quadkeys(mercator_tile, self.quadkey_zoom)
     return list(
         itertools.chain.from_iterable(
             [self.mosaic_def.tiles.get(qk, []) for qk in quadkeys]))
Exemple #3
0
                        def _get_tile(wind):
                            idx, window = wind
                            x = extrema["x"]["min"] + idx[1]
                            y = extrema["y"]["min"] + idx[0]
                            t = mercantile.Tile(x, y, base_zoom)

                            kds = set(find_quadkeys(t, mosaic_quadkey_zoom))
                            if not mosaic_quadkeys.intersection(kds):
                                return window, None, None

                            assets = mosaic.tile(*t)
                            if not assets:
                                raise Exception(
                                    f"No asset for tile {x}-{y}-{base_zoom}")

                            if assets:
                                tile, mask = mosaic_tiler(
                                    assets,
                                    x,
                                    y,
                                    base_zoom,
                                    cogeo.tile,
                                    indexes=info[6],
                                    tilesize=tilesize,
                                    pixel_selection=defaults.FirstMethod(),
                                )

                            return window, tile, mask
 def get_assets(self, x: int, y: int, z: int) -> List[str]:
     """Find assets."""
     mercator_tile = mercantile.Tile(x=x, y=y, z=z)
     quadkeys = find_quadkeys(mercator_tile, self.quadkey_zoom)
     return list(
         dict.fromkeys(
             itertools.chain.from_iterable(
                 [self._fetch(qk) for qk in quadkeys])))
Exemple #5
0
    def get_assets(self, x: int, y: int, z: int) -> List[str]:
        """Find assets."""
        mercator_tile = mercantile.Tile(x=x, y=y, z=z)
        quadkeys = find_quadkeys(mercator_tile, self.quadkey_zoom)

        assets = list(
            itertools.chain.from_iterable([
                self._fetch_dynamodb(qk).get("assets", []) for qk in quadkeys
            ]))

        # Find mosaics recursively?
        return assets
                    def _get_tile(wind):
                        idx, window = wind
                        x = extrema["x"]["min"] + idx[1]
                        y = extrema["y"]["min"] + idx[0]
                        t = mercantile.Tile(x, y, base_zoom)

                        kds = set(find_quadkeys(t, mosaic_quadkey_zoom))
                        if not mosaic_quadkeys.intersection(kds):
                            return window, None, None

                        try:
                            (tile, mask), _ = mosaic.tile(
                                t.x,
                                t.y,
                                t.z,
                                tilesize=tilesize,
                                pixel_selection=pixel_method(),
                            )
                        except NoAssetFoundError:
                            return window, None, None

                        return window, tile, mask