Beispiel #1
0
def test_create_mosaic():
    """Create mosaic from tiles."""
    tp = BufferedTilePyramid("geodetic")
    # quick return mosaic if there is just one tile
    tile = tp.tile(3, 3, 3)
    data = np.ones(tile.shape)
    mosaic = create_mosaic([(tile, data)])
    assert isinstance(mosaic, ReferencedRaster)
    assert np.array_equal(data, mosaic.data)
    assert tile.affine == mosaic.affine
    zoom = 5
    # multiple tiles on top left corner of tile matrix
    for pixelbuffer in [0, 10]:
        tp = BufferedTilePyramid("geodetic", pixelbuffer=pixelbuffer)
        tiles = [
            (tp.tile(zoom, row, col), np.ones(tp.tile(zoom, row, col).shape))
            for row, col in product(range(4), range(4))
        ]
        # 4x4 top left tiles from zoom 5 equal top left tile from zoom 3
        # also use tile generator
        mosaic = create_mosaic((t for t in tiles))
        assert isinstance(mosaic, ReferencedRaster)
        assert np.all(np.where(mosaic.data == 1, True, False))
        mosaic_bbox = box(
            mosaic.affine[2],
            mosaic.affine[5] + mosaic.data.shape[1] * mosaic.affine[4],
            mosaic.affine[2] + mosaic.data.shape[2] * mosaic.affine[0],
            mosaic.affine[5]
        )
        control_bbox = box(*unary_union([t.bbox for t, _ in tiles]).bounds)
        assert mosaic_bbox.equals(control_bbox)
    # multiple tiles on bottom right corner of tile matrix
    for pixelbuffer in [0, 10]:
        tp = BufferedTilePyramid("geodetic", pixelbuffer=pixelbuffer)
        tiles = [
            (tp.tile(zoom, row, col), np.ones(tp.tile(zoom, row, col).shape))
            for row, col in product(
                range(tp.matrix_height(zoom) - 4, tp.matrix_height(zoom)),
                range(tp.matrix_width(zoom) - 4, tp.matrix_width(zoom))
            )
        ]
        # 4x4 top left tiles from zoom 5 equal top left tile from zoom 3
        # also use tile generator
        mosaic = create_mosaic((t for t in tiles))
        assert isinstance(mosaic, ReferencedRaster)
        assert np.all(np.where(mosaic.data == 1, True, False))
        mosaic_bbox = box(
            mosaic.affine[2],
            mosaic.affine[5] + mosaic.data.shape[1] * mosaic.affine[4],
            mosaic.affine[2] + mosaic.data.shape[2] * mosaic.affine[0],
            mosaic.affine[5]
        )
        control_bbox = box(*unary_union([t.bbox for t, _ in tiles]).bounds)
        assert mosaic_bbox.equals(control_bbox)
Beispiel #2
0
def test_count_tiles_mercator():
    for metatiling in [1, 2, 4, 8, 16]:
        tp = BufferedTilePyramid("mercator", metatiling=metatiling)
        for zoom in range(13):
            count_by_geom = count_tiles(box(*tp.bounds), tp, zoom, zoom)
            count_by_tp = tp.matrix_width(zoom) * tp.matrix_height(zoom)
            assert count_by_geom == count_by_tp
Beispiel #3
0
def test_tile_to_zoom_level():
    tp_merc = BufferedTilePyramid("mercator")
    tp_geod = BufferedTilePyramid("geodetic")
    zoom = 9
    col = 0

    # mercator from geodetic
    # at Northern boundary
    assert tile_to_zoom_level(tp_merc.tile(zoom, 0, col), tp_geod) == 9
    assert tile_to_zoom_level(tp_merc.tile(zoom, 0, col),
                              tp_geod,
                              matching_method="min") == 12
    # at Equator
    assert tile_to_zoom_level(
        tp_merc.tile(zoom,
                     tp_merc.matrix_height(zoom) // 2, col), tp_geod) == 9
    assert tile_to_zoom_level(tp_merc.tile(zoom,
                                           tp_merc.matrix_height(zoom) // 2,
                                           col),
                              tp_geod,
                              matching_method="min") == 9
    # at Southern boundary
    assert tile_to_zoom_level(
        tp_merc.tile(zoom,
                     tp_merc.matrix_height(zoom) - 1, col), tp_geod) == 9
    assert tile_to_zoom_level(tp_merc.tile(zoom,
                                           tp_merc.matrix_height(zoom) - 1,
                                           col),
                              tp_geod,
                              matching_method="min") == 12
    assert tile_to_zoom_level(BufferedTilePyramid("mercator",
                                                  metatiling=2,
                                                  pixelbuffer=20).tile(
                                                      4, 0, 7),
                              BufferedTilePyramid("geodetic",
                                                  metatiling=8,
                                                  pixelbuffer=20),
                              matching_method="gdal") == 4

    # geodetic from mercator
    # at Northern boundary
    assert tile_to_zoom_level(tp_geod.tile(zoom, 0, col), tp_merc) == 2
    with pytest.raises(TopologicalError):
        tile_to_zoom_level(tp_geod.tile(zoom, 0, col),
                           tp_merc,
                           matching_method="min")
    # at Equator
    assert tile_to_zoom_level(
        tp_geod.tile(zoom,
                     tp_geod.matrix_height(zoom) // 2, col), tp_merc) == 10
    assert tile_to_zoom_level(tp_geod.tile(zoom,
                                           tp_geod.matrix_height(zoom) // 2,
                                           col),
                              tp_merc,
                              matching_method="min") == 10
    # at Southern boundary
    assert tile_to_zoom_level(
        tp_geod.tile(zoom,
                     tp_geod.matrix_height(zoom) - 1, col), tp_merc) == 2
    with pytest.raises(TopologicalError):
        tile_to_zoom_level(tp_geod.tile(zoom,
                                        tp_geod.matrix_height(zoom) - 1, col),
                           tp_merc,
                           matching_method="min")

    # check wrong method
    with pytest.raises(ValueError):
        tile_to_zoom_level(tp_geod.tile(zoom,
                                        tp_geod.matrix_height(zoom) - 1, col),
                           tp_merc,
                           matching_method="invalid_method")