def test_close_early(self):
sampler = UniformSampler(reader=get_dynamic_window_reader(),
window_sizes=DYNAMIC_MOD_DATA,
batch_size=2,
windows_per_image=10,
queue_length=10)
sampler.close_all()
def __init__(self,
reader,
window_sizes,
batch_size=1,
windows_per_image=1,
queue_length=10,
name='weighted_sampler'):
UniformSampler.__init__(self,
reader=reader,
window_sizes=window_sizes,
batch_size=batch_size,
windows_per_image=windows_per_image,
queue_length=queue_length,
name=name)
tf.logging.info('Initialised weighted sampler window instance')
self.window_centers_sampler = weighted_spatial_coordinates
def test_ill_init(self):
with self.assertRaisesRegexp(ValueError, ""):
sampler = UniformSampler(reader=get_3d_reader(),
window_sizes=MOD_2D_DATA,
batch_size=2,
windows_per_image=10,
queue_length=10)
def initialise_uniform_sampler(self):
self.sampler = [[UniformSampler(
reader=reader,
window_sizes=self.data_param,
batch_size=self.net_param.batch_size,
windows_per_image=self.action_param.sample_per_volume,
queue_length=self.net_param.queue_length) for reader in
self.readers]]
def __init__(self,
reader,
data_param,
batch_size,
windows_per_image,
constraint,
random_windows_per_image=0,
queue_length=10):
UniformSampler.__init__(self,
reader=reader,
data_param=data_param,
batch_size=batch_size,
windows_per_image=windows_per_image,
queue_length=queue_length)
self.constraint = constraint
self.n_samples_rand = random_windows_per_image
self.spatial_coordinates_generator = \
self.selective_spatial_coordinates()
tf.logging.info('initialised selective sampling')
def test_dynamic_init(self):
sampler = UniformSampler(reader=get_dynamic_window_reader(),
window_sizes=DYNAMIC_MOD_DATA,
batch_size=2,
windows_per_image=10,
queue_length=10)
with self.test_session() as sess:
sampler.set_num_threads(2)
out = sess.run(sampler.pop_batch_op())
self.assertAllClose(out['image'].shape[1:], (8, 2, 256, 2))
sampler.close_all()
def test_2d_init(self):
sampler = UniformSampler(reader=get_2d_reader(),
window_sizes=MOD_2D_DATA,
batch_size=2,
windows_per_image=10,
queue_length=10)
with self.test_session() as sess:
sampler.set_num_threads(2)
out = sess.run(sampler.pop_batch_op())
self.assertAllClose(out['image'].shape, (2, 10, 9, 1))
sampler.close_all()
def get_sampler(image_reader, patch_size, phase):
if phase in ('training', 'validation'):
sampler = UniformSampler(image_reader,
window_sizes=patch_size,
windows_per_image=2)
elif phase == 'inference':
sampler = GridSampler(image_reader,
window_sizes=patch_size,
window_border=(8, 8, 8),
batch_size=1)
else:
raise Exception('Invalid phase choice: {}'.format(
{'phase': ['train', 'validation', 'inference']}))
return sampler
def test_3d_concentric_init(self):
sampler = UniformSampler(reader=get_concentric_window_reader(),
window_sizes=MULTI_WINDOW_DATA,
batch_size=2,
windows_per_image=10,
queue_length=10)
with self.test_session() as sess:
sampler.set_num_threads(2)
out = sess.run(sampler.pop_batch_op())
img_loc = out['image_location']
seg_loc = out['label_location']
self.assertTrue(np.all(img_loc[:, 0] == seg_loc[:, 0]))
self.assertTrue(np.all((img_loc - seg_loc)[:, 1:4] == [1, 1, 0]))
self.assertTrue(np.all((img_loc - seg_loc)[:, 4:] == [-2, -1, 1]))
self.assertAllClose(out['image'].shape, (2, 4, 10, 3, 1))
self.assertAllClose(out['label'].shape, (2, 7, 12, 2, 1))
sampler.close_all()
###
reader = ImageReader().initialise(data_param)
reader.add_preprocessing_layers( # add volume padding layer
[PadLayer(image_name=['MR'], border=volume_padding_size, mode='constant')])
###
# show 'volume' -- without window sampling
###
image_2d = ImageWindowDataset(reader)()['MR'][0, :, :, 0, 0, 0]
vis_coordinates(image_2d, saving_name='output/image.png')
###
# create & show uniform random samples
###
uniform_sampler = UniformSampler(reader,
spatial_window_size,
windows_per_image=100)
next_window = uniform_sampler.pop_batch_op()
coords = []
with tf.Session() as sess:
for _ in range(20):
uniform_windows = sess.run(next_window)
coords.append(uniform_windows['MR_location'])
coords = np.concatenate(coords, axis=0)
vis_coordinates(image_2d, coords, 'output/uniform.png')
###
# create & show all grid samples
###
grid_sampler = GridSampler(reader, spatial_window_size, window_border=border)
next_grid = grid_sampler.pop_batch_op()
#Create image reader and add padding layer with 'constant' value 0
#This will ensure that samples are taken even at the beginning and ending slice
reader = ImageReader().initialise(data_param)
reader.add_preprocessing_layers(
PadLayer(image_name=['MR', 'sampler'],
border=(20, 20, 20),
mode='constant'))
_, img, _ = reader(idx=0)
#Create samplers with window_size
weighted_sampler = WeightedSampler(reader, window_sizes=(48, 48, 48))
balanced_sampler = BalancedSampler(reader, window_sizes=(48, 48, 48))
uniform_sampler = UniformSampler(reader, window_sizes=(48, 48, 48))
#Generate N samples for each type
N = 30
import tensorflow as tf
# adding the tensorflow tensors
next_window = weighted_sampler.pop_batch_op()
# run the tensors
with tf.Session() as sess:
weighted_sampler.run_threads(sess) #initialise the iterator
w_coords = []
for _ in range(N):
windows = sess.run(next_window)
#print(windows.keys(), windows['MR_location'], windows['MR'].shape)
w_coords.append(windows['MR_location'])
