def test_get_limits(self, dim_order, ranges):
descriptor = SubImageDescriptor.from_dict({
"filename": 'TestFileName',
"suffix": "SUFFIX",
"index": 0,
"data_type": "XXXX",
"template": [],
"dim_order": dim_order,
"ranges": ranges,
"file_format": "mhd",
"msb": "False",
"compression": [],
"voxel_size": [1, 1, 1]
})
read_file = Mock()
global_image_size = len(dim_order) * [50]
image = create_dummy_image(global_image_size)
image_wrapper = image
read_file.read_image.return_value = image_wrapper.image
file_factory = Mock()
file_factory.create_read_file.return_value = read_file
si = SubImage(descriptor, file_factory)
minv, maxv = si.get_limits()
actual_min = np.min(image_wrapper.image.get_raw())
actual_max = np.max(image_wrapper.image.get_raw())
self.assertEqual(minv, actual_min)
self.assertEqual(maxv, actual_max)
def test_read_image(self, dim_order, ranges, start, size):
descriptor = SubImageDescriptor.from_dict({
"filename": 'TestFileName', "suffix": "SUFFIX", "index": 0,
"data_type": "XXXX", "template": [], "dim_order": dim_order,
"ranges": ranges, "file_format": "mhd", "msb": "False",
"compression": []})
read_file = Mock()
global_image_size = len(dim_order)*[50]
image = create_dummy_image(global_image_size)
image_wrapper = image
sub_image = image_wrapper.get_sub_image(start, size)
read_file.read_image.return_value = sub_image.image
file_factory = Mock()
file_factory.create_read_file.return_value = read_file
si = SubImage(descriptor, file_factory)
# CoordinateTransforer is tested elsewhere. Here we do not make sure
# the coordinates have been transformed, using another
# CoordinateTransformer to check, but we are not verifying the
# transformations are correct, since the CoordinateTransformer test
# should do this
transformer = CoordinateTransformer(
descriptor.ranges.origin_start, descriptor.ranges.image_size,
descriptor.axis)
expected_start, expected_size = transformer.to_local(start, size)
test_image = si.read_image(start, size)
np.testing.assert_array_equal(test_image.image, sub_image.image)
np.testing.assert_array_equal(read_file.read_image.call_args[0][0], expected_start)
np.testing.assert_array_equal(read_file.read_image.call_args[0][1], expected_size)
def test_write_image(self, image_size):
initial_image = create_empty_image(image_size)
linear_image_file = MockAbstractLinearImageFile(initial_image)
dummy_image = create_dummy_image(image_size)
source = SimpleMockSource(dummy_image)
linear_image_file.write_image(source, None)
np.testing.assert_equal(initial_image.image, dummy_image.image)
def test_set_sub_image(self, main_dim_size, main_origin, sub_dim_size,
sub_origin):
num_dimensions = len(main_dim_size)
main_image = create_dummy_image(main_dim_size, origin=main_origin)
main_image_unset = ImageWrapper(main_origin, image_size=main_dim_size)
sub_image = create_dummy_image(sub_dim_size,
origin=sub_origin,
value_base=1000)
is_valid = True
for dim_index in range(0, num_dimensions):
if sub_origin[dim_index] < main_origin[dim_index] or \
sub_origin[dim_index] + sub_dim_size[dim_index] > \
main_origin[dim_index] + main_dim_size[dim_index]:
is_valid = False
if is_valid:
main_image.set_sub_image(sub_image)
main_image_unset.set_sub_image(sub_image)
self.assertTrue(
np.array_equal(
main_image.get_sub_image(sub_origin, sub_dim_size).image,
sub_image.image))
self.assertTrue(
np.array_equal(
main_image_unset.get_sub_image(sub_origin,
sub_dim_size).image,
sub_image.image))
else:
try:
main_image.set_sub_image(sub_image)
self.fail("Expeced this function call to fail")
except ValueError:
pass
try:
main_image.get_sub_image(sub_origin, sub_dim_size).image
self.fail("Expeced this function call to fail")
except ValueError:
pass
def test_write_image(self, dim_order, ranges, start, size):
descriptor = SubImageDescriptor.from_dict({
"filename": 'TestFileName',
"suffix": "SUFFIX",
"index": 0,
"data_type": "XXXX",
"template": [],
"dim_order": dim_order,
"ranges": ranges,
"file_format": "mhd",
"msb": "False",
"compression": [],
"voxel_size": [1, 1, 1]
})
file_factory = Mock()
out_file = Mock()
file_factory.create_write_file.return_value = out_file
# This test verifies that the read source supplied to the output file
# correctly converts from the file coordinate system to the global
# coordinate system
source = Mock()
dummy_image = create_dummy_image(len(size) * [20])
source.read_image.return_value = dummy_image
si = SubImage(descriptor, file_factory)
si.write_image(source, None)
# CoordinateTransforer is tested elsewhere.
transformer = CoordinateTransformer(descriptor.ranges.origin_start,
descriptor.ranges.image_size,
descriptor.axis)
local_start, local_size = transformer.to_local(start, size)
# Fetch the local data source provided to the file write method
local_data_source = out_file.write_image.call_args[0][0]
# Read from the local data source to trigger a read in the global source
input_image = local_data_source.read_image(local_start,
local_size).image
input_image = local_data_source.read_image(local_start,
local_size).image
# Get the arguments
test_start = source.read_image.call_args[0][0]
test_size = source.read_image.call_args[0][1]
np.testing.assert_array_equal(test_start, local_start)
np.testing.assert_array_equal(test_size, local_size)
def test_close(self):
descriptor = SubImageDescriptor.from_dict({
"filename":
'TestFileName',
"ranges": [[0, 10, 0, 0], [0, 10, 0, 0], [0, 10, 0, 0]],
"suffix":
"SUFFIX",
"index":
0,
"dim_order": [1, 2, 3],
"data_type":
"XXXX",
"template": [],
"file_format":
"mhd",
"msb":
"False",
"compression": [],
"voxel_size": [1, 1, 1]
})
# Check that reading creates only one read file and it is left open
file_factory = FakeFileFactory(create_dummy_image([11, 11, 11]))
self.assertEqual(len(file_factory.read_files), 0)
self.assertEqual(len(file_factory.write_files), 0)
si = SubImage(descriptor, file_factory)
si.read_image([1, 1, 1], [1, 1, 1])
self.assertEqual(len(file_factory.read_files), 1)
self.assertTrue(file_factory.read_files[0].open)
self.assertEqual(len(file_factory.write_files), 0)
self.assertTrue(file_factory.read_files[0].open)
si.read_image([1, 1, 1], [2, 2, 2])
self.assertEqual(len(file_factory.read_files), 1)
self.assertEqual(len(file_factory.write_files), 0)
# Check that close() closes the read image
self.assertTrue(file_factory.read_files[0].open)
si.close()
self.assertEqual(len(file_factory.read_files), 1)
self.assertEqual(len(file_factory.write_files), 0)
self.assertFalse(file_factory.read_files[0].open)
# Check that file is closed after writing
source = FakeImageFileReader(descriptor)
self.assertEqual(len(file_factory.write_files), 0)
si.write_image(source, None)
self.assertEqual(len(file_factory.write_files), 1)
self.assertFalse(file_factory.write_files[0].open)
def test_local_source(self, origin, global_size, dim_order, dim_flip, start, size):
transformer = CoordinateTransformer(origin, global_size, Axis(dim_order, dim_flip))
data_source = Mock()
test_image = create_dummy_image(global_size)
data_source.read_image.return_value = test_image
source = LocalSource(data_source, transformer)
local_image = source.read_image(start, size).image
global_start, t_global_size = transformer.to_global(start, size)
np.testing.assert_array_equal(data_source.read_image.call_args[0][0],
start)
np.testing.assert_array_equal(data_source.read_image.call_args[0][1],
size)
self.assertEqual(data_source.close.call_count, 0)
source.close()
self.assertEqual(data_source.close.call_count, 1)
global_image = transformer.image_to_global(local_image)
np.testing.assert_array_equal(local_image, test_image.image)
def test_combined_image(self):
d1 = self._make_descriptor( 1, [[ 0, 11, 0, 2], [ 0, 11, 0, 2], [ 0, 11, 0, 2]])
d2 = self._make_descriptor( 2, [[ 0, 11, 0, 2], [ 0, 11, 0, 2], [ 8, 21, 2, 2]])
d3 = self._make_descriptor( 3, [[ 0, 11, 0, 2], [ 0, 11, 0, 2], [18, 29, 2, 0]])
d4 = self._make_descriptor( 4, [[ 0, 11, 0, 2], [ 8, 21, 2, 2], [ 0, 11, 0, 2]])
d5 = self._make_descriptor( 5, [[ 0, 11, 0, 2], [ 8, 21, 2, 2], [ 8, 21, 2, 2]])
d6 = self._make_descriptor( 6, [[ 0, 11, 0, 2], [ 8, 21, 2, 2], [18, 29, 2, 0]])
d7 = self._make_descriptor( 7, [[ 0, 11, 0, 2], [18, 29, 2, 0], [ 0, 11, 0, 2]])
d8 = self._make_descriptor( 8, [[ 0, 11, 0, 2], [18, 29, 2, 0], [ 8, 21, 2, 2]])
d9 = self._make_descriptor( 9, [[ 0, 11, 0, 2], [18, 29, 2, 0], [18, 29, 2, 0]])
d11 = self._make_descriptor(11, [[ 8, 21, 2, 2], [ 0, 11, 0, 2], [ 0, 11, 0, 2]])
d12 = self._make_descriptor(12, [[ 8, 21, 2, 2], [ 0, 11, 0, 2], [ 8, 21, 2, 2]])
d13 = self._make_descriptor(13, [[ 8, 21, 2, 2], [ 0, 11, 0, 2], [18, 29, 2, 0]])
d14 = self._make_descriptor(14, [[ 8, 21, 2, 2], [ 8, 21, 2, 2], [ 0, 11, 0, 2]])
d15 = self._make_descriptor(15, [[ 8, 21, 2, 2], [ 8, 21, 2, 2], [ 8, 21, 2, 2]])
d16 = self._make_descriptor(16, [[ 8, 21, 2, 2], [ 8, 21, 2, 2], [18, 29, 2, 0]])
d17 = self._make_descriptor(17, [[ 8, 21, 2, 2], [18, 29, 2, 0], [ 0, 11, 0, 2]])
d18 = self._make_descriptor(18, [[ 8, 21, 2, 2], [18, 29, 2, 0], [ 8, 21, 2, 2]])
d19 = self._make_descriptor(19, [[ 8, 21, 2, 2], [18, 29, 2, 0], [18, 29, 2, 0]])
d21 = self._make_descriptor(21, [[18, 29, 2, 0], [ 0, 11, 0, 2], [ 0, 11, 0, 2]])
d22 = self._make_descriptor(22, [[18, 29, 2, 0], [ 0, 11, 0, 2], [ 8, 21, 2, 2]])
d23 = self._make_descriptor(23, [[18, 29, 2, 0], [ 0, 11, 0, 2], [18, 29, 2, 0]])
d24 = self._make_descriptor(24, [[18, 29, 2, 0], [ 8, 21, 2, 2], [ 0, 11, 0, 2]])
d25 = self._make_descriptor(25, [[18, 29, 2, 0], [ 8, 21, 2, 2], [ 8, 21, 2, 2]])
d26 = self._make_descriptor(26, [[18, 29, 2, 0], [ 8, 21, 2, 2], [18, 29, 2, 0]])
d27 = self._make_descriptor(27, [[18, 29, 2, 0], [18, 29, 2, 0], [ 0, 11, 0, 2]])
d28 = self._make_descriptor(28, [[18, 29, 2, 0], [18, 29, 2, 0], [ 8, 21, 2, 2]])
d29 = self._make_descriptor(29, [[18, 29, 2, 0], [18, 29, 2, 0], [18, 29, 2, 0]])
descriptors = [d1, d2, d3, d4, d5, d6, d7, d8, d9,
d11, d12, d13, d14, d15, d16, d17, d18, d19,
d21, d22, d23, d24, d25, d26, d27, d28, d29]
image = create_dummy_image([30, 30, 30])
file_factory = FakeFileFactory(image=image)
ci = CombinedImage(descriptors, file_factory)
source = Mock()
self.assertEqual(len(file_factory.write_files), 0)
ci.write_image(source, False)
self.assertEqual(len(file_factory.write_files), 27)
for descriptor, write_file in zip(descriptors, file_factory.write_files):
self.assertEqual(descriptor.ranges.ranges, write_file.descriptor.ranges.ranges)
self.assertFalse(write_file.open)
self.assertEqual(len(file_factory.read_files), 0)
# Test reading and assembling the whole image
read_image = ci.read_image([0, 0, 0], [30, 30, 30], global_coordinate_transformer([30, 30, 30]))
np.testing.assert_array_equal(image.image, read_image.image)
# Test reading part of the image excluding some of the subimages
read_image = ci.read_image([0, 0, 0], [5, 5, 5], global_coordinate_transformer([30, 30, 30]))
np.testing.assert_array_equal(image.get_sub_image([0, 0, 0], [5, 5, 5]).image, read_image.image)
# Test file closing
self.assertEqual(len(file_factory.read_files), 27)
for read_file in file_factory.read_files:
self.assertTrue(read_file.open)
ci.close()
for read_file in file_factory.read_files:
self.assertFalse(read_file.open)
limits = ci.get_limits()
self.assertEqual(limits.min, np.min(image.image.get_raw()))
self.assertEqual(limits.max, np.max(image.image.get_raw()))
def test_read_image(self, image_size, start, size):
dummy_image = create_dummy_image(image_size)
linear_image_file = MockAbstractLinearImageFile(dummy_image)
read_image = linear_image_file.read_image(start, size)
test_image = dummy_image.get_sub_image(start, size)
np.testing.assert_equal(read_image, test_image.image)
