def test_shift_real(self): """ Test on decomposed image with known shift """ numTiles = [2, 3, 4] overlap = [0.5, 0.4, 0.3, 0.2] acq = ["horizontalLines", "horizontalZigzag", "verticalLines"] for img, num, o, a in itertools.product(IMGS, numTiles, overlap, acq): _, img_name = os.path.split(img) conv = find_fittest_converter(img) data = conv.read_data(img)[0] data = ensure2DImage(data) # Create artificial tiled image [tiles, real_pos] = decompose_image(data, o, num, a) px_size = tiles[0].metadata[model.MD_PIXEL_SIZE] registrar = GlobalShiftRegistrar() # Register tiles for tile in tiles: registrar.addTile(tile) # Compare positions to real positions, allow 5 px offset registered_pos = registrar.getPositions()[0] diff = numpy.absolute(numpy.subtract(registered_pos, real_pos)) allowed_px_offset = numpy.repeat(numpy.multiply(px_size, 5), len(diff)) numpy.testing.assert_array_less(diff.flatten(), allowed_px_offset.flatten(), "Position %s pxs off for image '%s', " % (max(diff.flatten()) / px_size[0], img_name) + "%s x %s tiles, %s ovlp, %s method." % (num, num, o, a))
def test_real_perfect_overlap(self): """ Test on decomposed image """ numTiles = [2, 3, 4] overlap = [0.4] for img in IMGS: conv = find_fittest_converter(img) data = conv.read_data(img)[0] img = ensure2DImage(data) for n in numTiles: for o in overlap: [tiles, _] = decompose_image(img, o, n, "horizontalZigzag", False) weaver = CollageWeaverReverse() for t in tiles: weaver.addTile(t) sz = len(weaver.getFullImage()) w = weaver.getFullImage() numpy.testing.assert_allclose(w, img[:sz, :sz], rtol=1)
def test_shift_real(self): """ Test on decomposed image with known shift """ numTiles = [2, 3, 4] overlap = [0.5, 0.4, 0.3, 0.2] acq = ["horizontalLines", "horizontalZigzag", "verticalLines"] for img, num, o, a in itertools.product(IMGS, numTiles, overlap, acq): _, img_name = os.path.split(img) conv = find_fittest_converter(img) data = conv.read_data(img)[0] data = ensure2DImage(data) # Create artificial tiled image [tiles, real_pos] = decompose_image(data, o, num, a) px_size = tiles[0].metadata[model.MD_PIXEL_SIZE] registrar = GlobalShiftRegistrar() # Register tiles for tile in tiles: registrar.addTile(tile) # Compare positions to real positions, allow 5 px offset registered_pos = registrar.getPositions()[0] diff = numpy.absolute(numpy.subtract(registered_pos, real_pos)) allowed_px_offset = numpy.repeat(numpy.multiply(px_size, 5), len(diff)) numpy.testing.assert_array_less( diff.flatten(), allowed_px_offset.flatten(), "Position %s pxs off for image '%s', " % (max(diff.flatten()) / px_size[0], img_name) + "%s x %s tiles, %s ovlp, %s method." % (num, num, o, a))
def test_shift_real(self): """ Test on decomposed image with known shift """ numTiles = [2, 3] overlap = [0.2, 0.3, 0.4] acq = ["horizontalLines", "verticalLines", "horizontalZigzag"] for img in IMGS: conv = find_fittest_converter(img) data = conv.read_data(img)[0] data = ensure2DImage(data) for num in numTiles: for o in overlap: for a in acq: [tiles, pos] = decompose_image(data, o, num, a, False) registrar = IdentityRegistrar() for i in range(len(pos)): registrar.addTile(tiles[i]) calculatedPositions = registrar.getPositions()[0] diff1 = abs(calculatedPositions[i][0] - pos[i][0]) diff2 = abs(calculatedPositions[i][1] - pos[i][1]) # allow difference of 10% of overlap px_size = tiles[i].metadata[model.MD_PIXEL_SIZE] # allow error of 1% of tileSize margin1 = 0.01 * tiles[i].shape[0] * px_size[0] margin2 = 0.01 * tiles[i].shape[1] * px_size[1] self.assertLessEqual(diff1, margin1, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (calculatedPositions[i][0], pos[i][0])) self.assertLessEqual(diff2, margin2, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (calculatedPositions[i][1], pos[i][1]))
def test_no_seam(self): """ Test on decomposed image """ numTiles = [2, 3, 4] overlap = [0.4] for img in IMGS: conv = find_fittest_converter(img) data = conv.read_data(img)[0] img = ensure2DImage(data) for n in numTiles: for o in overlap: [tiles, _] = decompose_image(img, o, n, "horizontalZigzag", False) weaver = CollageWeaver(adjust_brightness=False) for t in tiles: weaver.addTile(t) sz = len(weaver.getFullImage()) w = weaver.getFullImage() numpy.testing.assert_array_almost_equal(w, img[:sz, :sz], decimal=1)
def test_real_perfect_overlap(self): """ Test on decomposed image """ numTiles = [2, 3, 4] overlap = [0.4] for img in IMGS: conv = find_fittest_converter(img) data = conv.read_data(img)[0] img = ensure2DImage(data) for n in numTiles: for o in overlap: [tiles, _] = decompose_image( img, o, n, "horizontalZigzag", False) weaver = CollageWeaverReverse() for t in tiles: weaver.addTile(t) sz = len(weaver.getFullImage()) w = weaver.getFullImage() numpy.testing.assert_allclose(w, img[:sz, :sz], rtol=1)
def test_shift_real(self): """ Test on decomposed image with known shift """ numTiles = [2, 3] overlap = [0.2, 0.3, 0.4] acq = ["horizontalLines", "verticalLines", "horizontalZigzag"] for img in IMGS: conv = find_fittest_converter(img) data = conv.read_data(img)[0] data = ensure2DImage(data) for num in numTiles: for o in overlap: for a in acq: [tiles, pos] = decompose_image(data, o, num, a, False) registrar = IdentityRegistrar() for i in range(len(pos)): registrar.addTile(tiles[i]) calculatedPositions = registrar.getPositions()[0] diff1 = abs(calculatedPositions[i][0] - pos[i][0]) diff2 = abs(calculatedPositions[i][1] - pos[i][1]) # allow difference of 10% of overlap px_size = tiles[i].metadata[model.MD_PIXEL_SIZE] # allow error of 1% of tileSize margin1 = 0.01 * tiles[i].shape[0] * px_size[0] margin2 = 0.01 * tiles[i].shape[1] * px_size[1] self.assertLessEqual( diff1, margin1, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (calculatedPositions[i][0], pos[i][0])) self.assertLessEqual( diff2, margin2, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (calculatedPositions[i][1], pos[i][1]))
def test_dependent_tiles(self): """ Tests functionality for dependent tiles """ # Test on 3 layers of the same image create by decompose_image for img in IMGS: conv = find_fittest_converter(img) data = conv.read_data(img)[0] img = ensure2DImage(data) num = 4 o = 0.3 # fails for 0.2 a = "horizontalZigzag" [tiles, pos] = decompose_image(img, o, num, a) registrar = GlobalShiftRegistrar() for i in range(len(pos)): registrar.addTile(tiles[i], (tiles[i], tiles[i])) tile_pos, dep_tile_pos = registrar.getPositions() for i in range(len(pos)): diff1 = abs(tile_pos[i][0] - pos[i][0]) diff2 = abs(tile_pos[i][1] - pos[i][1]) # allow difference of 10% of overlap px_size = tiles[i].metadata[model.MD_PIXEL_SIZE] # Check if position is not completely wrong. The margins are given # by the extreme value calculation in the registrar and provide # a very generous upper limit for the error that should never be exceeded # because of the fallback method. # Unfortunately, many tests don't pass stricter limits yet. margin1 = px_size[0] * 5 margin2 = px_size[1] * 5 self.assertLessEqual( diff1, margin1, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (tile_pos[i][0], pos[i][0])) self.assertLessEqual( diff2, margin2, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (tile_pos[i][1], pos[i][1])) for p, tile in zip(pos, dep_tile_pos): for dep_tile in tile: diff1 = abs(dep_tile[0] - p[0]) self.assertLessEqual( diff1, margin1, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (dep_tile[0], p[0])) diff2 = abs(dep_tile[1] - p[1]) self.assertLessEqual( diff2, margin2, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (dep_tile[1], p[1])) # Test with shifted dependent tiles [tiles, pos] = decompose_image(img, o, num, a) registrar = GlobalShiftRegistrar() # Add different shift for every dependent tile dep_tiles = copy.deepcopy(tiles) # x-shift for each dependent tile in px rnd1 = [random.randrange(-1000, 1000) for _ in range(len(pos))] # y-shift for each dependent tile in px rnd2 = [random.randrange(-1000, 1000) for _ in range(len(pos))] # Change metadata of dependent tiles for i in range(len(dep_tiles)): p = (dep_tiles[i].metadata[model.MD_POS][0] + rnd1[i] * px_size[0], dep_tiles[i].metadata[model.MD_POS][1] + rnd2[i] * px_size[1]) dep_tiles[i].metadata[model.MD_POS] = p for i in range(len(pos)): # Register tiles # 2 layers of dependent tiles with the same pos registrar.addTile(tiles[i], (dep_tiles[i], dep_tiles[i])) tile_pos, dep_tile_pos = registrar.getPositions() for i in range(len(pos)): # Test main tile diff1 = abs(tile_pos[i][0] - pos[i][0]) diff2 = abs(tile_pos[i][1] - pos[i][1]) margin1 = px_size[0] * 5 margin2 = px_size[1] * 5 self.assertLessEqual( diff1, margin1, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (tile_pos[i][0], pos[i][0])) self.assertLessEqual( diff2, margin2, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (tile_pos[i][0], pos[i][0])) for p, tile, r1, r2 in zip(tile_pos, dep_tile_pos, rnd1, rnd2): for dep_tile in tile: self.assertAlmostEqual(dep_tile[0], p[0] + r1 * px_size[0]) self.assertAlmostEqual(dep_tile[1], p[1] + r2 * px_size[1])
def test_dependent_tiles(self): """ Tests functionality for dependent tiles """ # Test on 3 layers of the same image create by decompose_image for img in IMGS: conv = find_fittest_converter(img) data = conv.read_data(img)[0] img = ensure2DImage(data) num = 2 o = 0.2 a = "horizontalZigzag" [tiles, pos] = decompose_image(img, o, num, a, False) registrar = IdentityRegistrar() for i in range(len(pos)): registrar.addTile(tiles[i], (tiles[i], tiles[i])) tile_pos, dep_tile_pos = registrar.getPositions() diff1 = abs(tile_pos[i][0] - pos[i][0]) diff2 = abs(tile_pos[i][1] - pos[i][1]) # allow difference of 10% of overlap px_size = tiles[i].metadata[model.MD_PIXEL_SIZE] margin = 0.01 * tiles[i].shape[0] * px_size[0] self.assertLessEqual( diff1, margin, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (tile_pos[i][0], pos[i][0])) self.assertLessEqual( diff2, margin, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (tile_pos[i][1], pos[i][1])) for j in range(len(dep_tile_pos[0])): diff1 = abs(dep_tile_pos[i][j][0] - pos[i][0]) self.assertLessEqual( diff1, margin, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (dep_tile_pos[i][j][0], pos[i][0])) diff2 = abs(dep_tile_pos[i][j][1] - pos[i][1]) self.assertLessEqual( diff2, margin, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (dep_tile_pos[i][j][1], pos[i][1])) # Test with shifted dependent tiles [tiles, pos] = decompose_image(img, o, num, a, False) registrar = IdentityRegistrar() # Add shift dep_tiles = copy.deepcopy(tiles) rnd1 = [random.randrange(-20, 20) for _ in range(len(pos))] rnd2 = [random.randrange(-20, 20) for _ in range(len(pos))] for i in range(len(dep_tiles)): p = (dep_tiles[i].metadata[model.MD_POS][0] + rnd1[i], dep_tiles[i].metadata[model.MD_POS][1] + rnd2[i]) dep_tiles[i].metadata[model.MD_POS] = p for i in range(len(pos)): registrar.addTile(tiles[i], (dep_tiles[i], dep_tiles[i])) tile_pos, dep_tile_pos = registrar.getPositions() diff1 = abs(tile_pos[i][0] - pos[i][0]) # allow difference of 10% of overlap margin = 0.3 * o * tiles[i].shape[0] self.assertLessEqual( diff1, margin, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (tile_pos[i][0], pos[i][0])) for j in range(2): diff1 = abs(dep_tile_pos[i][j][0] - pos[i][0]) self.assertLessEqual( diff1, margin, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (dep_tile_pos[i][j][0], pos[i][0] + rnd1[i])) diff2 = abs(dep_tile_pos[i][j][1] - pos[i][1]) self.assertLessEqual( diff2, margin, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (dep_tile_pos[i][j][1], pos[i][1] + rnd2[i]))
def test_dependent_tiles(self): """ Tests functionality for dependent tiles """ # Test on 3 layers of the same image create by decompose_image for img in IMGS: conv = find_fittest_converter(img) data = conv.read_data(img)[0] img = ensure2DImage(data) num = 4 o = 0.3 # fails for 0.2 a = "horizontalZigzag" [tiles, pos] = decompose_image(img, o, num, a) registrar = GlobalShiftRegistrar() for i in range(len(pos)): registrar.addTile(tiles[i], (tiles[i], tiles[i])) tile_pos, dep_tile_pos = registrar.getPositions() for i in range(len(pos)): diff1 = abs(tile_pos[i][0] - pos[i][0]) diff2 = abs(tile_pos[i][1] - pos[i][1]) # allow difference of 10% of overlap px_size = tiles[i].metadata[model.MD_PIXEL_SIZE] # Check if position is not completely wrong. The margins are given # by the extreme value calculation in the registrar and provide # a very generous upper limit for the error that should never be exceeded # because of the fallback method. # Unfortunately, many tests don't pass stricter limits yet. margin1 = px_size[0] * 5 margin2 = px_size[1] * 5 self.assertLessEqual(diff1, margin1, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (tile_pos[i][0], pos[i][0])) self.assertLessEqual(diff2, margin2, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (tile_pos[i][1], pos[i][1])) for p, tile in zip(pos, dep_tile_pos): for dep_tile in tile: diff1 = abs(dep_tile[0] - p[0]) self.assertLessEqual(diff1, margin1, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (dep_tile[0], p[0])) diff2 = abs(dep_tile[1] - p[1]) self.assertLessEqual(diff2, margin2, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (dep_tile[1], p[1])) # Test with shifted dependent tiles [tiles, pos] = decompose_image(img, o, num, a) registrar = GlobalShiftRegistrar() # Add different shift for every dependent tile dep_tiles = copy.deepcopy(tiles) # x-shift for each dependent tile in px rnd1 = [random.randrange(-1000, 1000) for _ in range(len(pos))] # y-shift for each dependent tile in px rnd2 = [random.randrange(-1000, 1000) for _ in range(len(pos))] # Change metadata of dependent tiles for i in range(len(dep_tiles)): p = (dep_tiles[i].metadata[model.MD_POS][0] + rnd1[i] * px_size[0], dep_tiles[i].metadata[model.MD_POS][1] + rnd2[i] * px_size[1]) dep_tiles[i].metadata[model.MD_POS] = p for i in range(len(pos)): # Register tiles # 2 layers of dependent tiles with the same pos registrar.addTile(tiles[i], (dep_tiles[i], dep_tiles[i])) tile_pos, dep_tile_pos = registrar.getPositions() for i in range(len(pos)): # Test main tile diff1 = abs(tile_pos[i][0] - pos[i][0]) diff2 = abs(tile_pos[i][1] - pos[i][1]) margin1 = px_size[0] * 5 margin2 = px_size[1] * 5 self.assertLessEqual(diff1, margin1, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (tile_pos[i][0], pos[i][0])) self.assertLessEqual(diff2, margin2, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (tile_pos[i][0], pos[i][0])) for p, tile, r1, r2 in zip(tile_pos, dep_tile_pos, rnd1, rnd2): for dep_tile in tile: self.assertAlmostEqual(dep_tile[0], p[0] + r1 * px_size[0]) self.assertAlmostEqual(dep_tile[1], p[1] + r2 * px_size[1])
def test_dependent_tiles(self): """ Tests functionality for dependent tiles """ # Test on 3 layers of the same image create by decompose_image for img in IMGS: conv = find_fittest_converter(img) data = conv.read_data(img)[0] img = ensure2DImage(data) num = 2 o = 0.2 a = "horizontalZigzag" [tiles, pos] = decompose_image(img, o, num, a, False) registrar = IdentityRegistrar() for i in range(len(pos)): registrar.addTile(tiles[i], (tiles[i], tiles[i])) tile_pos, dep_tile_pos = registrar.getPositions() diff1 = abs(tile_pos[i][0] - pos[i][0]) diff2 = abs(tile_pos[i][1] - pos[i][1]) # allow difference of 10% of overlap px_size = tiles[i].metadata[model.MD_PIXEL_SIZE] margin = 0.01 * tiles[i].shape[0] * px_size[0] self.assertLessEqual(diff1, margin, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (tile_pos[i][0], pos[i][0])) self.assertLessEqual(diff2, margin, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (tile_pos[i][1], pos[i][1])) for j in range(len(dep_tile_pos[0])): diff1 = abs(dep_tile_pos[i][j][0] - pos[i][0]) self.assertLessEqual(diff1, margin, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (dep_tile_pos[i][j][0], pos[i][0])) diff2 = abs(dep_tile_pos[i][j][1] - pos[i][1]) self.assertLessEqual(diff2, margin, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (dep_tile_pos[i][j][1], pos[i][1])) # Test with shifted dependent tiles [tiles, pos] = decompose_image(img, o, num, a, False) registrar = IdentityRegistrar() # Add shift dep_tiles = copy.deepcopy(tiles) rnd1 = [random.randrange(-20, 20) for _ in range(len(pos))] rnd2 = [random.randrange(-20, 20) for _ in range(len(pos))] for i in range(len(dep_tiles)): p = (dep_tiles[i].metadata[model.MD_POS][0] + rnd1[i], dep_tiles[i].metadata[model.MD_POS][1] + rnd2[i]) dep_tiles[i].metadata[model.MD_POS] = p for i in range(len(pos)): registrar.addTile(tiles[i], (dep_tiles[i], dep_tiles[i])) tile_pos, dep_tile_pos = registrar.getPositions() diff1 = abs(tile_pos[i][0] - pos[i][0]) # allow difference of 10% of overlap margin = 0.3 * o * tiles[i].shape[0] self.assertLessEqual(diff1, margin, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (tile_pos[i][0], pos[i][0])) for j in range(2): diff1 = abs(dep_tile_pos[i][j][0] - pos[i][0]) self.assertLessEqual(diff1, margin, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (dep_tile_pos[i][j][0], pos[i][0] + rnd1[i])) diff2 = abs(dep_tile_pos[i][j][1] - pos[i][1]) self.assertLessEqual(diff2, margin, "Failed for %s tiles, %s overlap and %s method," % (num, o, a) + " %f != %f" % (dep_tile_pos[i][j][1], pos[i][1] + rnd2[i]))