def test_stackmirror_get_tile_index():
tile_side = 100
mirror = StackMirror(IMAGE_BASE, tile_side, tile_side, TILE_SOURCE_TYPE,
'png')
tile_idx_kwargs = {
'zoom_level': 0,
'height': tile_side,
'width': tile_side
}
# trivial case
coords = {'x': 0, 'y': 0, 'z': 0}
idx, offset = mirror.get_tile_index(coords)
assert idx == TileIndex(0, 0, 0, **tile_idx_kwargs)
assert offset == {'x': 0, 'y': 0, 'z': 0}
# test offset
coords = {'x': 50, 'y': 50, 'z': 0}
idx, offset = mirror.get_tile_index(coords)
assert idx == TileIndex(0, 0, 0, **tile_idx_kwargs)
assert offset == {'x': 50, 'y': 50, 'z': 0}
# test tile idx
coords = {'x': tile_side, 'y': tile_side, 'z': 1}
idx, offset = mirror.get_tile_index(coords)
assert idx == TileIndex(1, 1, 1, **tile_idx_kwargs)
assert offset == {'x': 0, 'y': 0, 'z': 0}
# test row/col correctness
coords = {'x': tile_side, 'y': 0, 'z': 0}
idx, offset = mirror.get_tile_index(coords)
assert idx == TileIndex(depth=0, row=0, col=1, **tile_idx_kwargs)
assert offset == {'x': 0, 'y': 0, 'z': 0}
def test_imagefetcher_roi_to_tiles(min_fetcher, roi, expected_drc,
expected_yx_minmax):
tile_side = 100
zoom_level = 0
mirror = StackMirror(IMAGE_BASE, tile_side, tile_side, TILE_SOURCE_TYPE,
'png')
min_fetcher.stack.mirrors = [mirror]
min_fetcher.mirror = mirror
(min_y, max_y), (min_x, max_x) = expected_yx_minmax
expected_bounds = {
'min': {
'z': 0,
'y': min_y,
'x': min_x,
},
'max': {
'z': 0,
'y': max_y,
'x': max_x,
},
}
expected_tiles = {
TileIndex(*drc,
zoom_level=zoom_level,
height=tile_side,
width=tile_side)
for drc in expected_drc
}
tiles, slicing = min_fetcher._roi_to_tiles(roi, zoom_level)
assert tiles == expected_tiles
assert slicing == expected_bounds
def test_tile_index_coords():
idx = TileIndex(5, 2, 1, None, 10, 20)
result = idx.coords
expected_result = {'z': 5, 'y': 20, 'x': 20}
assert result == expected_result
def test_404_handled_correctly(min_fetcher):
idx = TileIndex(0, 0, 0, 0, 100, 100)
min_fetcher._session.get = mock.Mock(side_effect=HTTPError(
response=mock.Mock(status_code=404)))
with mock.patch('catpy.image.response_to_array', mock.Mock()):
tile = min_fetcher._fetch(idx)
assert tile.shape == (100, 100)
assert (tile == 0).sum() == tile.size
def test_imagefetcher_get_tile_from_cache(realistic_fetcher, tile_gen):
cached = next(tile_gen)
height, width = cached.shape
tile_index = TileIndex(0, 0, 0, 0, height, width)
realistic_fetcher._tile_cache[tile_index] = cached
out = realistic_fetcher.get([[0, 0, 0], [1, height, width]],
ROIMode.SCALED, 0)
realistic_fetcher._fetch.assert_not_called()
assert np.allclose(out.squeeze(), cached)
def test_fill_tiled_cuboid():
kwargs = {'zoom_level': 1, 'height': 2, 'width': 3}
min_tile = TileIndex(1, 2, 3, **kwargs)
max_tile = TileIndex(2, 4, 3, **kwargs)
results = fill_tiled_cuboid(min_tile, max_tile)
expected_results = {
TileIndex(1, 2, 3, **kwargs),
TileIndex(2, 2, 3, **kwargs),
TileIndex(1, 3, 3, **kwargs),
TileIndex(2, 3, 3, **kwargs),
TileIndex(1, 4, 3, **kwargs),
TileIndex(2, 4, 3, **kwargs)
}
assert results == expected_results
def test_tile_index_comparable(name):
kwargs = {'zoom_level': 1, 'height': 10, 'width': 20}
idx1 = TileIndex(1, 2, 3, **kwargs)
idx2 = TileIndex(4, 5, 6, **kwargs)
assert idx1.is_comparable(idx2)
kwargs[name] = kwargs[name] * 2
idx3 = TileIndex(7, 8, 9, **kwargs)
assert not idx1.is_comparable(idx3)
def test_imagefetcher_fetch(min_fetcher):
idx = TileIndex(0, 0, 0, 0, 100, 100)
min_fetcher._session.get = mock.Mock()
with mock.patch('catpy.image.response_to_array', mock.Mock()):
min_fetcher._fetch(idx)
min_fetcher._session.get.assert_called_once()
def test_imagefetcher_get_tile_from_fetch(min_fetcher):
idx = TileIndex(0, 0, 0, 0, 100, 100)
min_fetcher._fetch = mock.Mock()
min_fetcher._get_tile(idx)
min_fetcher._fetch.assert_called_with(idx)
def test_stackmirror_raises_on_incompatible_tile_index():
mirror = StackMirror(IMAGE_BASE, 512, 512, TILE_SOURCE_TYPE, 'png')
tile_idx = TileIndex(0, 0, 0, 0, 256, 256)
with pytest.raises(ValueError):
mirror.generate_url(tile_idx)
def test_stackmirror_formats_url(tile_source_type):
mirror = StackMirror(IMAGE_BASE, 256, 256, tile_source_type, 'png')
tile_idx = TileIndex(0, 0, 0, 0, 256, 256)
response = mirror.generate_url(tile_idx)
assert not set('{}').issubset(response)
def test_tile_index_url_kwargs():
idx = TileIndex(1, 2, 3, 4, 5, 6)
d = idx.url_kwargs
for key in ('depth', 'row', 'col', 'zoom_level'):
assert key in d
def test_fill_tiled_cuboid_raises():
min_tile = TileIndex(1, 2, 3, 1, 2, 3)
max_tile = TileIndex(2, 4, 3, 4, 5, 6)
with pytest.raises(ValueError):
fill_tiled_cuboid(min_tile, max_tile)