Ejemplo n.º 1
0
def test_mosaic_tiler():
    """Test mosaic tiler."""
    # test with mosaic_tiler for compatibility
    (t, m), assets_used = mosaic.mosaic_tiler(assets, x, y, z, _read_tile)
    assert len(assets_used) == 1
    assert t.shape == (3, 256, 256)
    assert m.shape == (256, 256)
    assert m.all()
    assert t[0][-1][-1] == 8682

    # test with default and full covered tile and default options
    (t, m), assets_used = mosaic.mosaic_reader(assets, _read_tile, x, y, z)
    assert t.shape == (3, 256, 256)
    assert m.shape == (256, 256)
    assert m.all()
    assert t[0][-1][-1] == 8682

    # Test last pixel selection
    assetsr = list(reversed(assets))
    (t, m), _ = mosaic.mosaic_reader(assetsr, _read_tile, x, y, z)
    assert t.shape == (3, 256, 256)
    assert m.shape == (256, 256)
    assert m.all()
    assert t[0][-1][-1] == 8057

    (t, m), _ = mosaic.mosaic_reader(assets, _read_tile, x, y, z, indexes=1)
    assert t.shape == (1, 256, 256)
    assert m.shape == (256, 256)
    assert t.all()
    assert m.all()
    assert t[0][-1][-1] == 8682

    # Test darkest pixel selection
    (t, m), assets_used = mosaic.mosaic_reader(
        assets, _read_tile, x, y, z, pixel_selection=defaults.LowestMethod())
    assert len(assets_used) == 2
    assert m.all()
    assert t[0][-1][-1] == 8057

    (to, mo), _ = mosaic.mosaic_reader(assets_order,
                                       _read_tile,
                                       x,
                                       y,
                                       z,
                                       pixel_selection=defaults.LowestMethod())
    numpy.testing.assert_array_equal(t[0, m], to[0, mo])

    # Test brightest pixel selection
    (t, m), _ = mosaic.mosaic_reader(assets,
                                     _read_tile,
                                     x,
                                     y,
                                     z,
                                     pixel_selection=defaults.HighestMethod())
    assert m.all()
    assert t[0][-1][-1] == 8682

    (to,
     mo), _ = mosaic.mosaic_reader(assets_order,
                                   _read_tile,
                                   x,
                                   y,
                                   z,
                                   pixel_selection=defaults.HighestMethod())
    numpy.testing.assert_array_equal(to, t)
    numpy.testing.assert_array_equal(mo, m)

    # test with default and partially covered tile
    (t, m), _ = mosaic.mosaic_reader(assets,
                                     _read_tile,
                                     xp,
                                     yp,
                                     zp,
                                     pixel_selection=defaults.HighestMethod())
    assert t.any()
    assert not m.all()

    # test when tiler raise errors (outside bounds)
    (t, m), _ = mosaic.mosaic_reader(assets, _read_tile, 150, 300, 9)
    assert not t
    assert not m

    # Test mean pixel selection
    (t, m), _ = mosaic.mosaic_reader(assets,
                                     _read_tile,
                                     x,
                                     y,
                                     z,
                                     pixel_selection=defaults.MeanMethod())
    assert t.shape == (3, 256, 256)
    assert m.shape == (256, 256)
    assert m.all()
    assert t[0][-1][-1] == 8369

    # Test mean pixel selection
    (t, m), _ = mosaic.mosaic_reader(
        assets,
        _read_tile,
        x,
        y,
        z,
        pixel_selection=defaults.MeanMethod(enforce_data_type=False),
    )
    assert m.all()
    assert t[0][-1][-1] == 8369.5

    # Test median pixel selection
    (t, m), _ = mosaic.mosaic_reader(assets,
                                     _read_tile,
                                     x,
                                     y,
                                     z,
                                     pixel_selection=defaults.MedianMethod())
    assert t.shape == (3, 256, 256)
    assert m.shape == (256, 256)
    assert m.all()
    assert t[0][-1][-1] == 8369

    # Test median pixel selection
    (t, m), _ = mosaic.mosaic_reader(
        assets,
        _read_tile,
        x,
        y,
        z,
        pixel_selection=defaults.MedianMethod(enforce_data_type=False),
    )
    assert m.all()
    assert t[0][-1][-1] == 8369.5

    # Test invalid Pixel Selection class
    with pytest.raises(Exception):

        class aClass(object):
            pass

        mosaic.mosaic_reader(assets,
                             _read_tile,
                             x,
                             y,
                             z,
                             pixel_selection=aClass())

    # test with preview
    # NOTE: We need to fix the output width and height because each preview could have different size
    (t, m), _ = mosaic.mosaic_reader(assets,
                                     _read_preview,
                                     width=256,
                                     height=256)
    assert t.shape == (3, 256, 256)
    assert m.shape == (256, 256)
Ejemplo n.º 2
0
def test_mosaic_tiler():
    """Test mosaic tiler."""
    # test with default and full covered tile and default options
    (t, m), assets_used = mosaic.mosaic_reader(assets, _read_tile, x, y, z)
    assert t.shape == (3, 256, 256)
    assert m.shape == (256, 256)
    assert m.all()
    assert t[0][-1][-1] == 8682
    assert t.dtype == m.dtype

    # Test last pixel selection
    assetsr = list(reversed(assets))
    (t, m), _ = mosaic.mosaic_reader(assetsr, _read_tile, x, y, z)
    assert t.shape == (3, 256, 256)
    assert m.shape == (256, 256)
    assert m.all()
    assert t[0][-1][-1] == 8057
    assert t.dtype == m.dtype

    (t, m), _ = mosaic.mosaic_reader(assets, _read_tile, x, y, z, indexes=1)
    assert t.shape == (1, 256, 256)
    assert m.shape == (256, 256)
    assert t.all()
    assert m.all()
    assert t[0][-1][-1] == 8682
    assert t.dtype == m.dtype

    # Test darkest pixel selection
    (t, m), assets_used = mosaic.mosaic_reader(
        assets, _read_tile, x, y, z, pixel_selection=defaults.LowestMethod())
    assert len(assets_used) == 2
    assert m.all()
    assert t[0][-1][-1] == 8057
    assert t.dtype == m.dtype

    (to, mo), _ = mosaic.mosaic_reader(assets_order,
                                       _read_tile,
                                       x,
                                       y,
                                       z,
                                       pixel_selection=defaults.LowestMethod())
    numpy.testing.assert_array_equal(t[0, m], to[0, mo])
    assert to.dtype == mo.dtype

    # Test brightest pixel selection
    (t, m), _ = mosaic.mosaic_reader(assets,
                                     _read_tile,
                                     x,
                                     y,
                                     z,
                                     pixel_selection=defaults.HighestMethod())
    assert m.all()
    assert t[0][-1][-1] == 8682
    assert t.dtype == m.dtype

    (to,
     mo), _ = mosaic.mosaic_reader(assets_order,
                                   _read_tile,
                                   x,
                                   y,
                                   z,
                                   pixel_selection=defaults.HighestMethod())
    numpy.testing.assert_array_equal(to, t)
    numpy.testing.assert_array_equal(mo, m)
    assert to.dtype == mo.dtype

    # test with default and partially covered tile
    (t, m), _ = mosaic.mosaic_reader(assets,
                                     _read_tile,
                                     xp,
                                     yp,
                                     zp,
                                     pixel_selection=defaults.HighestMethod())
    assert t.any()
    assert not m.all()
    assert t.dtype == m.dtype

    # test when tiler raise errors (outside bounds)
    with pytest.raises(EmptyMosaicError):
        mosaic.mosaic_reader(assets, _read_tile, 150, 300, 9)

    # Test mean pixel selection
    (t, m), _ = mosaic.mosaic_reader(assets,
                                     _read_tile,
                                     x,
                                     y,
                                     z,
                                     pixel_selection=defaults.MeanMethod())
    assert t.shape == (3, 256, 256)
    assert m.shape == (256, 256)
    assert m.all()
    assert t[0][-1][-1] == 8369
    assert t.dtype == m.dtype

    # Test mean pixel selection
    (t, m), _ = mosaic.mosaic_reader(
        assets,
        _read_tile,
        x,
        y,
        z,
        pixel_selection=defaults.MeanMethod(enforce_data_type=False),
    )
    assert m.all()
    assert t[0][-1][-1] == 8369.5
    assert t.dtype == m.dtype

    # Test median pixel selection
    (t, m), _ = mosaic.mosaic_reader(assets,
                                     _read_tile,
                                     x,
                                     y,
                                     z,
                                     pixel_selection=defaults.MedianMethod())
    assert t.shape == (3, 256, 256)
    assert m.shape == (256, 256)
    assert m.all()
    assert t[0][-1][-1] == 8369
    assert t.dtype == m.dtype

    # Test median pixel selection
    (t, m), _ = mosaic.mosaic_reader(
        assets,
        _read_tile,
        x,
        y,
        z,
        pixel_selection=defaults.MedianMethod(enforce_data_type=False),
    )
    assert m.all()
    assert t[0][-1][-1] == 8369.5
    assert t.dtype == m.dtype

    (t, m), _ = mosaic.mosaic_reader(
        assets_order,
        _read_tile,
        x,
        y,
        z,
        pixel_selection=defaults.LastBandHigh(),
        indexes=(1, 2, 3, 1),
    )
    assert t.shape == (3, 256, 256)
    assert m.shape == (256, 256)
    assert m.all()
    assert t[0][-1][-1] == 8682
    assert t.dtype == m.dtype

    (t, m), _ = mosaic.mosaic_reader(
        assets_order,
        _read_tile,
        x,
        y,
        z,
        pixel_selection=defaults.LastBandLow(),
        indexes=(1, 2, 3, 1),
    )
    assert t.shape == (3, 256, 256)
    assert m.shape == (256, 256)
    assert m.all()
    assert t[0][-1][-1] == 8057
    assert t.dtype == m.dtype

    # Test pixel selection as _class_, not instance of class
    (t, m), assets_used = mosaic.mosaic_reader(
        assets, _read_tile, x, y, z, pixel_selection=defaults.FirstMethod)
    assert t.shape == (3, 256, 256)
    assert m.shape == (256, 256)
    assert m.all()
    assert t[0][-1][-1] == 8682
    assert t.dtype == m.dtype

    # Test invalid Pixel Selection class
    with pytest.raises(InvalidMosaicMethod):

        class aClass(object):
            pass

        mosaic.mosaic_reader(assets,
                             _read_tile,
                             x,
                             y,
                             z,
                             pixel_selection=aClass())

    # test with preview
    # NOTE: We need to fix the output width and height because each preview could have different size
    # Also because the 2 assets cover different bbox, getting the preview merged together doesn't make real sense
    (t, m), _ = mosaic.mosaic_reader(assets,
                                     _read_preview,
                                     width=256,
                                     height=256)
    assert t.shape == (3, 256, 256)
    assert m.shape == (256, 256)
    assert t.dtype == m.dtype