def test_gbif_mapbox_comp(self, taxon_id, tile_ids):
mpta = TileArray.from_dict({x: Tile(x) for x in tile_ids})
gbta = TileArray.from_dict({x: Tile(x) for x in tile_ids})
mapbox_tiles = self.mapbox.get_tiles(mpta)
gbif_tiles = self.gbif.get_tiles(taxon_id, gbta)
c_tiles = mapbox_tiles._composite_layer(gbif_tiles)
c_tiles.name = "gbif+mapbox"
final_image = c_tiles._composite_all()
final_image.save(f"gbif+mapbox-{taxon_id}-final.png")
class TestTile:
@pytest.mark.parametrize(
"tile_ids, images, names, tile_size",
[
(
[TileID(0, 0, 0)],
[create_blank_image(256, "RGB")],
["test_tile_creation"],
256,
),
],
)
def test_creation(self, tile_ids, images, names, tile_size):
for tid, img, name in zip(tile_ids, images, names):
tile = Tile(tid=tid, img=img, name=name)
assert tile.tid == tid
assert tile.img == img
assert tile.name == name
assert tile.resolution == tile_size
@pytest.mark.parametrize(
"test_tile, m_tile",
[
(
Tile(TileID(8, 4, 2), img=create_blank_image()),
mercantile.Tile(z=8, x=4, y=2),
),
(
Tile(TileID(4, 10, 9), img=create_blank_image()),
mercantile.Tile(z=4, x=10, y=9),
),
],
)
def test_to_mercantile(self, test_tile, m_tile):
assert test_tile.asmercantile == m_tile
@pytest.mark.parametrize(
"tile, bounds",
[
(
Tile(TileID(4, 10, 9), img=create_blank_image()),
LatLonBBox(
left=45.0,
bottom=-40.97989806962013,
right=67.5,
top=-21.943045533438177,
),
),
],
)
def test_tile_bounds(self, tile, bounds):
assert tile.bounds == bounds
def test_creation_constructor(self, tile_ids, images):
tile_array = TileArray.from_dict(
{TileID(k): Tile(TileID(k), v)
for k, v in zip(tile_ids, images)})
for tid in tile_ids:
assert tid in tile_array
pprint(tile_array)
def test_creation(self, tile_ids, images, names, tile_size):
for tid, img, name in zip(tile_ids, images, names):
tile = Tile(tid=tid, img=img, name=name)
assert tile.tid == tid
assert tile.img == img
assert tile.name == name
assert tile.resolution == tile_size
def _get_tile(self, tile_id: TileID = None, **params) -> Tile:
"""
Gets a tile for a specific taxon_key.
Parameters that can be used as per: https://github.com/gbif/pygbif/blob/master/pygbif/maps/map.py
Raises:
TypeError: TileID is a required parameter
Returns:
Tile: Tile with the downloaded tile image attached to it.
"""
params["style"] = params.get("style", self.map_defaults["style"])
params["srs"] = params.get("srs", self.srs)
# params["format"] = params.get("format", "@1x.png")
fmt = self.size_map(params.get("tile_size", self.map_defaults["size"]))
tile_id = params.get("tile_id", tile_id)
if tile_id is None:
raise TypeError("tile_id required for map tile lookup.")
taxon_key = params.get("taxonKey", "None")
if params.get("tile_size", None):
params.pop("tile_size")
url = f"v2/map/occurrence/density/{tile_id.z}/{tile_id.x}/{tile_id.y}{fmt}"
resp = requests.get(self.base_url + url, params=params)
print("gurl:", resp.url)
sc = resp.status_code
if sc in (200, 304):
img = imager.image_from_response(resp)
# the gbif api seems to return this in both error conditions and when there legitimately isn't any data.
elif sc == 204:
img = imager.blank("RGBA",
(self._tile_size, self._tile_size)), True
else:
if self.noisy_http_errors:
resp.raise_for_status()
return None
return Tile(tile_id, img=img, name=f"gbifmap_{taxon_key}")
def test_get_tilearray(self, taxon_id, tile_ids_expected_image, map_type):
tile_ids = tile_ids_expected_image.keys()
ta = TileArray.from_dict({x: Tile(x) for x in tile_ids})
ta = self.gbif.get_tiles(taxon_id, ta, mode=map_type)
print(ta)
for k, t in ta.items():
t.save()
print("IE", k, tile_ids_expected_image[k])
print("timg", t.img)
def download_tile_url(self,
tid: TileID,
tile_url: str,
params: Dict[str, str] = {}) -> Optional[Tile]:
res = requests.get(self.base_url + tile_url, params=params)
if res.status_code == 200:
img = imager.image_from_response(res)
tile = Tile(tid=tid, img=img, name=self.map_name)
return tile
else:
print(res.status_code, res.url)
return None
def download_tile(self, tile_id: TileID, rsid: str) -> Tile:
params = {
"layers": "EBIRD_GRIDS_WS2",
"format": "image/png",
"zoom": tile_id.zoom,
"x": tile_id.x,
"y": tile_id.y,
"CQL_FILTER": f"result_set_id='{rsid}'",
}
url = self.map_tile_url
print(f"ebird url: {url}")
resp = self.rget(url, params=params)
img = imager.image_from_response(resp)
return Tile(tile_id, img=img, name=f"ebird-{rsid}")
def create_tilearray(self, tids, imgs):
tile_array = TileArray()
for tid, img in zip(tids, imgs):
tile = Tile(tid=tid, img=img)
tile_array[tid] = tile
return tile_array