def test_collapse_returns_sum_of_a_level_and_extended_upper_level(self):
pyr = Pyramid(12, 3)
level_0 = PyramidLevel(np.array([[2, 2], [3, 3]], dtype=np.float64), 2,
2)
level_1 = PyramidLevel(np.array([[0]], dtype=np.float64), 1, 1)
pyr.add_lower_resolution_level(level_0)
pyr.add_lower_resolution_level(level_1)
result = pyr.collapse()
self.assertIn(result, level_0.get_array())
def fuse(self, kernel_size):
"""Function which fuses each level of the pyramid using appropriate fusion operators
the output is one pyramid containing fused levels"""
log = logging.getLogger(".".join([__name__, self.__class__.__name__]))
log.addFilter(logconfig.ThreadContextFilter())
base_level_fused = self.get_fused_base(kernel_size)
depth = self.collection[0].get_depth()
fused = Pyramid(0,depth)
fused.add_lower_resolution_level(base_level_fused)
layers = len(self.collection)
region_kernel = self.get_region_kernel()
parameters = []
for level in range(depth - 2, -1, -1):
sh = self.collection[0].get_level(level).get_array().shape
laplacians = np.zeros((layers, sh[0], sh [1]), dtype=np.float64)
for layer in range(0, layers):
new_level = self.collection[layer].get_level(level).get_array()
laplacians[layer] = new_level
param = (laplacians, region_kernel,level)
parameters.append(param)
pool = Pool()
results = pool.map_async(fused_laplacian, parameters)
bunch = results.get()
pool.close()
pool.join()
fused.add_bunch_of_levels(bunch)
fused.sort_levels()
return fused
def test_sort_levels_sorts_levels_according_to_size_larger_first(self):
pyr = Pyramid(12, 3)
level_0 = PyramidLevel(
np.array([[10, 10, 10], [2, 2, 2], [4, 4, 4]], dtype=np.float64),
2, 2)
level_1 = PyramidLevel(np.array([[2, 2], [3, 3]], dtype=np.float64), 2,
2)
level_2 = PyramidLevel(np.array([0], dtype=np.float64), 1, 1)
pyr.add_lower_resolution_level(level_1)
pyr.add_lower_resolution_level(level_0)
pyr.add_lower_resolution_level(level_2)
self.assertEqual(
pyr.get_level(0).get_array().shape,
level_1.get_array().shape)
pyr.sort_levels()
self.assertEqual(
pyr.get_level(0).get_array().shape,
level_0.get_array().shape)
def test_collapse_returns_an_array_of_the_same_size_as_the_bottom_level(
self):
pyr = Pyramid(12, 3)
level_0 = PyramidLevel(
np.array([[10, 10, 10], [2, 2, 2], [4, 4, 4]], dtype=np.float64),
2, 2)
level_1 = PyramidLevel(np.array([[2, 2], [3, 3]], dtype=np.float64), 2,
2)
level_2 = PyramidLevel(np.array([0], dtype=np.float64), 1, 1)
pyr.add_lower_resolution_level(level_1)
pyr.add_lower_resolution_level(level_0)
pyr.add_lower_resolution_level(level_2)
pyr.sort_levels()
result = pyr.collapse()
self.assertEqual(result.shape, level_0.get_array().shape)
def laplacian_pyramid(self, depth):
"""Create laplacian pyramid of a certain depth."""
laplacian_collection = PyramidCollection()
gaussian_collection = self._gaussian_pyramid(depth)
for layer_number, image in enumerate(self.images):
gaussian_pyramid = gaussian_collection.get_pyramid(layer_number)
gaussian_top_level = gaussian_pyramid.get_top_level(
) # the lowest resolution
laplacian_pyramid = Pyramid(layer_number, depth)
laplacian_pyramid.add_higher_resolution_level(gaussian_top_level)
for level_number in range(depth - 1, 0, -1):
to_expand = gaussian_pyramid.get_level(
level_number).get_array()
expanded = cv2.pyrUp(to_expand)
lower_level = gaussian_pyramid.get_level(level_number -
1).get_array()
if expanded.shape != lower_level.shape:
expanded = expanded[:lower_level.shape[0], :lower_level.
shape[1]]
difference = lower_level - expanded
difference_level = PyramidLevel(difference, layer_number,
level_number)
laplacian_pyramid.add_higher_resolution_level(difference_level)
laplacian_collection.add_pyramid(laplacian_pyramid)
return laplacian_collection
def test_add_higher_resolution_level_adds_new_element_in_front_of_the_level_list(
self):
pyr = Pyramid(10, 2)
pyr.add_higher_resolution_level(10)
self.assertEqual(len(pyr.levels), 1)
pyr.add_higher_resolution_level(12)
self.assertEqual(len(pyr.levels), 2)
self.assertEqual(pyr.levels[1], 10)
self.assertEqual(pyr.levels[0], 12)
def test_add_lower_resolution_level_adds_new_element_on_the_end_of_level_list(
self):
pyr = Pyramid(10, 2)
pyr.add_lower_resolution_level(10)
self.assertEquals(len(pyr.levels), 1)
pyr.add_lower_resolution_level(12)
self.assertEquals(len(pyr.levels), 2)
self.assertEquals(pyr.levels[0], 10)
self.assertEquals(pyr.levels[1], 12)
def _gaussian_pyramid(self, depth):
"""Creates the gaussian pyramid of a certain depth"""
pyramid_collection = PyramidCollection()
for layer_number, image in enumerate(self.images):
pyramid = Pyramid(layer_number, depth)
level = PyramidLevel(image.astype(np.float64), layer_number, 0)
pyramid.add_lower_resolution_level(level)
for level_number in range(1, depth): #check the depth
image = cv2.pyrDown(image.astype(np.float64))
next_level = PyramidLevel(image, layer_number, level_number)
pyramid.add_lower_resolution_level(next_level)
pyramid_collection.add_pyramid(pyramid)
return pyramid_collection
def setUp(self):
pyr = Pyramid(12, 3)
level_0 = PyramidLevel(
np.array(
[[10, 10, 10, 10], [2, 2, 2, 2], [4, 4, 4, 4], [4, 4, 4, 4]],
dtype=np.float64), 2, 2)
level_1 = PyramidLevel(np.array([[2, 2], [3, 3]], dtype=np.float64), 2,
1)
level_2 = PyramidLevel(np.array([[0]], dtype=np.float64), 2, 0)
pyr.add_lower_resolution_level(level_0)
pyr.add_lower_resolution_level(level_1)
pyr.add_lower_resolution_level(level_2)
pyr1 = deepcopy(pyr)
self._kernel_size = 5
self._pyramid_collection = PyramidCollection()
self._pyramid_collection.add_pyramid(pyr)
self._pyramid_collection.add_pyramid(pyr1)
def test_get_top_level_returns_the_last_element_form_the_level_list(self):
pyr = Pyramid(10, 3)
pyr.levels = [12, 13, 14]
self.assertEqual(pyr.get_top_level(), 14)
def test_get_level_returns_the_correct_list_element(self):
pyr = Pyramid(10, 3)
pyr.levels = [12, 13, 14]
self.assertEqual(pyr.get_level(1), 13)
self.assertEqual(pyr.get_level(0), 12)
def test_get_depth_returns_correct_value(self):
depth = 12
pyr = Pyramid(10, depth)
self.assertEqual(pyr.get_depth(), depth)
def test_get_layer_number_returns_correct_value(self):
layer_number = 10
pyr = Pyramid(layer_number, 10)
self.assertEqual(pyr.get_layer_number(), layer_number)
