def test_dtype(self):
# https://github.com/fepegar/torchio/issues/407
tensor_int = (100 * torch.rand(1, 2, 3, 4)).byte()
transform = tio.ZNormalization(masking_method=tio.ZNormalization.mean)
transform(tensor_int)
transform = tio.ZNormalization()
transform(tensor_int)
def test_transforms(self):
landmarks_dict = dict(
t1=np.linspace(0, 100, 13),
t2=np.linspace(0, 100, 13),
)
elastic = torchio.RandomElasticDeformation(max_displacement=1)
transforms = (
torchio.CropOrPad((9, 21, 30)),
torchio.ToCanonical(),
torchio.Resample((1, 1.1, 1.25)),
torchio.RandomFlip(axes=(0, 1, 2), flip_probability=1),
torchio.RandomMotion(),
torchio.RandomGhosting(axes=(0, 1, 2)),
torchio.RandomSpike(),
torchio.RandomNoise(),
torchio.RandomBlur(),
torchio.RandomSwap(patch_size=2, num_iterations=5),
torchio.Lambda(lambda x: 2 * x, types_to_apply=torchio.INTENSITY),
torchio.RandomBiasField(),
torchio.RescaleIntensity((0, 1)),
torchio.ZNormalization(masking_method='label'),
torchio.HistogramStandardization(landmarks_dict=landmarks_dict),
elastic,
torchio.RandomAffine(),
torchio.OneOf({
torchio.RandomAffine(): 3,
elastic: 1
}),
torchio.Pad((1, 2, 3, 0, 5, 6), padding_mode='constant', fill=3),
torchio.Crop((3, 2, 8, 0, 1, 4)),
)
transform = torchio.Compose(transforms)
transform(self.sample)
def byol_aug(filename):
"""
BYOL minimizes the distance between representations of each sample and a transformation of that sample.
Examples of transformations include: translation, rotation, blurring, color inversion, color jitter, gaussian noise.
Return an augmented dataset that consisted the above mentioned transformation. Will be used in the training.
"""
image = tio.ScalarImage(filename)
get_foreground = tio.ZNormalization.mean
training_transform = tio.Compose([
tio.CropOrPad((180, 220, 170)), # zero mean, unit variance of foreground
tio.ZNormalization(
masking_method=get_foreground),
tio.RandomBlur(p=0.25), # blur 25% of times
tio.RandomNoise(p=0.25), # Gaussian noise 25% of times
tio.OneOf({ # either
tio.RandomAffine(): 0.8, # random affine
tio.RandomElasticDeformation(): 0.2, # or random elastic deformation
}, p=0.8), # applied to 80% of images
tio.RandomBiasField(p=0.3), # magnetic field inhomogeneity 30% of times
tio.OneOf({ # either
tio.RandomMotion(): 1, # random motion artifact
tio.RandomSpike(): 2, # or spikes
tio.RandomGhosting(): 2, # or ghosts
}, p=0.5), # applied to 50% of images
])
tfs_image = training_transform(image)
return tfs_image
def test_bounds_mask(self):
transform = tio.ZNormalization()
with self.assertRaises(ValueError):
transform.get_mask_from_anatomical_label('test', 0)
tensor = torch.rand((1, 2, 2, 2))
def get_mask(label):
mask = transform.get_mask_from_anatomical_label(label, tensor)
return mask
left = get_mask('Left')
assert left[:, 0].sum() == 4 and left[:, 1].sum() == 0
right = get_mask('Right')
assert right[:, 1].sum() == 4 and right[:, 0].sum() == 0
posterior = get_mask('Posterior')
assert posterior[:, :, 0].sum() == 4 and posterior[:, :, 1].sum() == 0
anterior = get_mask('Anterior')
assert anterior[:, :, 1].sum() == 4 and anterior[:, :, 0].sum() == 0
inferior = get_mask('Inferior')
assert inferior[..., 0].sum() == 4 and inferior[..., 1].sum() == 0
superior = get_mask('Superior')
assert superior[..., 1].sum() == 4 and superior[..., 0].sum() == 0
mask = transform.get_mask_from_bounds(3 * (0, 1), tensor)
assert mask[0, 0, 0, 0] == 1
assert mask.sum() == 1
def get_train_transform(landmarks_path, resection_params=None):
spatial_transform = tio.Compose((
tio.OneOf({
tio.RandomAffine(): 0.9,
tio.RandomElasticDeformation(): 0.1,
}),
tio.RandomFlip(),
))
resolution_transform = tio.OneOf(
(
tio.RandomAnisotropy(),
tio.RandomBlur(),
),
p=0.75,
)
transforms = []
if resection_params is not None:
transforms.append(get_simulation_transform(resection_params))
if landmarks_path is not None:
transforms.append(
tio.HistogramStandardization({'image': landmarks_path}))
transforms.extend([
# tio.RandomGamma(p=0.2),
resolution_transform,
tio.RandomGhosting(p=0.2),
tio.RandomSpike(p=0.2),
tio.RandomMotion(p=0.2),
tio.RandomBiasField(p=0.5),
tio.ZNormalization(masking_method=tio.ZNormalization.mean),
tio.RandomNoise(p=0.75), # always after ZNorm and after blur!
spatial_transform,
get_tight_crop(),
])
return tio.Compose(transforms)
def get_test_transform(landmarks_path):
transforms = []
if landmarks_path is not None:
transforms.append(tio.HistogramStandardization({'image': landmarks_path}))
transforms.extend([
tio.ZNormalization(masking_method=tio.ZNormalization.mean),
get_tight_crop(),
])
return tio.Compose(transforms)
def __getitem__(self, index):
img_path = os.path.join(self.root_dir, self.df.iloc[index, 1])
subject = tio.Subject(img=Image(img_path, type=tio.INTENSITY))
if (self.transform):
# in training phase
transformations = (
tio.ZNormalization(),
tio.Resample(target=2,
pre_affine_name="affine"), # preprocessing
tio.OneOf(transforms_dict),
tio.OneOf(transforms_dict2))
else:
# in validation and testing phase
transformations = (
tio.ZNormalization(),
tio.Resample(target=2,
pre_affine_name="affine") # preprocessing
)
transformations = Compose(transformations)
transformed_image = transformations(subject)
get_image = transformed_image.img
tensor_resampled_image = get_image.data
tensor_resampled_image = tensor_resampled_image.unsqueeze(
dim=0) # adding batch size
resampled_image = torch.nn.functional.interpolate(
input=tensor_resampled_image,
size=(256, 256, 166),
mode='trilinear'
) # trilinear because it had 5D (mini-batch x channels x height x width x depth)
resampled_image = np.reshape(resampled_image, (1, 256, 256, 166))
y_label = 0.0 if self.df.iloc[index, 2] == 'AD' else 1.0
y_label = torch.tensor(y_label, dtype=torch.float)
return resampled_image, y_label
def __getitem__(self, idx):
#modify the collate_fn from the dataloader so that it filters out None elements.
img_name = self.list_images[idx]
try:
_, image, spacing = load_reorient(img_name)
except:
spacing = [2, 2, 2]
print('error loading {0}'.format(img_name))
if self.remove_corrupt and os.path.isfile(img_name):
os.remove(img_name)
image, _ = self.get_random(fa=True)
if not np.any(image):
image, _ = self.get_random(fa=True)
#preprocessing
original_spacing = np.array(spacing)
get_foreground = tio.ZNormalization.mean
target_shape = 128, 128, 128
crop_pad = tio.CropOrPad(target_shape)
###operations###
standardize = tio.ZNormalization(masking_method=get_foreground)
if 'wb' not in self.class_names and 'abd-pel' not in self.class_names:
downsample = tio.Resample(
(2 / spacing[0], 2 / spacing[1], 2 / spacing[2]))
try:
image = standardize(crop_pad(downsample(image)))
except:
print(img_name)
else:
x, y, z = image.shape[1:] / np.asarray(target_shape)
downsample = tio.Resample((x, y, z))
image = standardize(crop_pad(downsample(image)))
if image.shape[0] > 1:
image = np.expand_dims(image[0, :, :, :], axis=0)
#print(image.shape)
print(img_name)
sample = {
'image': torch.from_numpy(image),
'label': np.array(0),
'spacing': original_spacing,
'fn': img_name
}
return sample
def get_dataset(
input_path,
tta_iterations=0,
interpolation='bspline',
tolerance=0.1,
mni_transform_path=None,
):
if mni_transform_path is None:
image = tio.ScalarImage(input_path)
else:
affine = tio.io.read_matrix(mni_transform_path)
image = tio.ScalarImage(input_path, **{TO_MNI: affine})
subject = tio.Subject({IMAGE_NAME: image})
landmarks = np.array([
0., 0.31331614, 0.61505419, 0.76732501, 0.98887953, 1.71169384,
3.21741126, 13.06931455, 32.70817796, 40.87807389, 47.83508873,
63.4408591, 100.
])
hist_std = tio.HistogramStandardization({IMAGE_NAME: landmarks})
preprocess_transforms = [
tio.ToCanonical(),
hist_std,
tio.ZNormalization(masking_method=tio.ZNormalization.mean),
]
zooms = nib.load(input_path).header.get_zooms()
pixdim = np.array(zooms)
diff_to_1_iso = np.abs(pixdim - 1)
if np.any(diff_to_1_iso > tolerance) or mni_transform_path is not None:
kwargs = {'image_interpolation': interpolation}
if mni_transform_path is not None:
kwargs['pre_affine_name'] = TO_MNI
kwargs['target'] = tio.datasets.Colin27().t1.path
resample_transform = tio.Resample(**kwargs)
preprocess_transforms.append(resample_transform)
preprocess_transforms.append(tio.EnsureShapeMultiple(8, method='crop'))
preprocess_transform = tio.Compose(preprocess_transforms)
no_aug_dataset = tio.SubjectsDataset([subject],
transform=preprocess_transform)
aug_subjects = tta_iterations * [subject]
if not aug_subjects:
return no_aug_dataset
augment_transform = tio.Compose((
preprocess_transform,
tio.RandomFlip(),
tio.RandomAffine(image_interpolation=interpolation),
))
aug_dataset = tio.SubjectsDataset(aug_subjects,
transform=augment_transform)
dataset = torch.utils.data.ConcatDataset((no_aug_dataset, aug_dataset))
return dataset
def __init__(self, foldername, annotations_data):
self.folder = foldername
self.filedata = annotations_data
self.fileinfo = np.array(self.filedata.filelist)
self.standardizer = tio.ZNormalization()
self.padder = tio.CropOrPad((144, 176, 144))
self.images = []
for i in range(len(self.fileinfo)):
self.images.append(
torch.from_numpy(
nib.load(os.path.join(
self.folder,
self.fileinfo[i])).get_fdata()).float().unsqueeze(0))
def get_transform(self, channels, is_3d=True, labels=True):
landmarks_dict = {
channel: np.linspace(0, 100, 13)
for channel in channels
}
disp = 1 if is_3d else (1, 1, 0.01)
elastic = tio.RandomElasticDeformation(max_displacement=disp)
cp_args = (9, 21, 30) if is_3d else (21, 30, 1)
resize_args = (10, 20, 30) if is_3d else (10, 20, 1)
flip_axes = axes_downsample = (0, 1, 2) if is_3d else (0, 1)
swap_patch = (2, 3, 4) if is_3d else (3, 4, 1)
pad_args = (1, 2, 3, 0, 5, 6) if is_3d else (0, 0, 3, 0, 5, 6)
crop_args = (3, 2, 8, 0, 1, 4) if is_3d else (0, 0, 8, 0, 1, 4)
remapping = {1: 2, 2: 1, 3: 20, 4: 25}
transforms = [
tio.CropOrPad(cp_args),
tio.EnsureShapeMultiple(2, method='crop'),
tio.Resize(resize_args),
tio.ToCanonical(),
tio.RandomAnisotropy(downsampling=(1.75, 2), axes=axes_downsample),
tio.CopyAffine(channels[0]),
tio.Resample((1, 1.1, 1.25)),
tio.RandomFlip(axes=flip_axes, flip_probability=1),
tio.RandomMotion(),
tio.RandomGhosting(axes=(0, 1, 2)),
tio.RandomSpike(),
tio.RandomNoise(),
tio.RandomBlur(),
tio.RandomSwap(patch_size=swap_patch, num_iterations=5),
tio.Lambda(lambda x: 2 * x, types_to_apply=tio.INTENSITY),
tio.RandomBiasField(),
tio.RescaleIntensity(out_min_max=(0, 1)),
tio.ZNormalization(),
tio.HistogramStandardization(landmarks_dict),
elastic,
tio.RandomAffine(),
tio.OneOf({
tio.RandomAffine(): 3,
elastic: 1,
}),
tio.RemapLabels(remapping=remapping, masking_method='Left'),
tio.RemoveLabels([1, 3]),
tio.SequentialLabels(),
tio.Pad(pad_args, padding_mode=3),
tio.Crop(crop_args),
]
if labels:
transforms.append(tio.RandomLabelsToImage(label_key='label'))
return tio.Compose(transforms)
def normalization(histogram_transform, dataset):
znorm_transform = tio.ZNormalization(
masking_method=tio.ZNormalization.mean)
sample = dataset[0]
transform = tio.Compose([histogram_transform, znorm_transform])
znormed = transform(sample)
fig, ax = plt.subplots(dpi=100)
plot_histogram(ax, znormed.mri.data, label='Z-normed', alpha=1)
ax.set_title('Intensity values of one sample after z-normalization')
ax.set_xlabel('Intensity')
ax.grid()
plt.show()
ax.show()
def get_transform(self, channels, is_3d=True, labels=True):
landmarks_dict = {
channel: np.linspace(0, 100, 13)
for channel in channels
}
disp = 1 if is_3d else (1, 1, 0.01)
elastic = torchio.RandomElasticDeformation(max_displacement=disp)
cp_args = (9, 21, 30) if is_3d else (21, 30, 1)
flip_axes = axes_downsample = (0, 1, 2) if is_3d else (0, 1)
swap_patch = (2, 3, 4) if is_3d else (3, 4, 1)
pad_args = (1, 2, 3, 0, 5, 6) if is_3d else (0, 0, 3, 0, 5, 6)
crop_args = (3, 2, 8, 0, 1, 4) if is_3d else (0, 0, 8, 0, 1, 4)
transforms = [
torchio.CropOrPad(cp_args),
torchio.ToCanonical(),
torchio.RandomDownsample(downsampling=(1.75, 2),
axes=axes_downsample),
torchio.Resample((1, 1.1, 1.25)),
torchio.RandomFlip(axes=flip_axes, flip_probability=1),
torchio.RandomMotion(),
torchio.RandomGhosting(axes=(0, 1, 2)),
torchio.RandomSpike(),
torchio.RandomNoise(),
torchio.RandomBlur(),
torchio.RandomSwap(patch_size=swap_patch, num_iterations=5),
torchio.Lambda(lambda x: 2 * x, types_to_apply=torchio.INTENSITY),
torchio.RandomBiasField(),
torchio.RescaleIntensity((0, 1)),
torchio.ZNormalization(),
torchio.HistogramStandardization(landmarks_dict),
elastic,
torchio.RandomAffine(),
torchio.OneOf({
torchio.RandomAffine(): 3,
elastic: 1,
}),
torchio.Pad(pad_args, padding_mode=3),
torchio.Crop(crop_args),
]
if labels:
transforms.append(torchio.RandomLabelsToImage(label_key='label'))
return torchio.Compose(transforms)
def test_z_normalization(self):
transform = tio.ZNormalization()
transformed = transform(self.sample_subject)
self.assertAlmostEqual(float(transformed.t1.data.mean()), 0., places=6)
self.assertAlmostEqual(float(transformed.t1.data.std()), 1.)
def test_no_std(self):
image = tio.ScalarImage(tensor=torch.ones(1, 2, 2, 2))
with self.assertRaises(RuntimeError):
tio.ZNormalization()(image)
"""
Exclude images from transform
=============================
In this example we show how the kwargs ``include`` and ``exclude`` can be
used to apply a transform to only some of the images within a subject.
"""
import torch
import torchio as tio
torch.manual_seed(0)
subject = tio.datasets.Pediatric(years=(4.5, 8.5))
subject.plot()
transform = tio.Compose([
tio.RandomAffine(degrees=(20, 30)),
tio.ZNormalization(),
tio.RandomBlur(std=(3, 4), include='t1'),
tio.RandomNoise(std=(1, 1.5), exclude='t1'),
])
transformed = transform(subject)
transformed.plot()
def __init__(self, foldername, annotations_data):
self.folder = foldername
self.filedata = annotations_data
self.fileinfo = np.array(self.filedata.filelist)
self.standardizer = tio.ZNormalization()
self.padder = tio.CropOrPad((144, 176, 144))
#Normalisation
landmarks = tio.HistogramStandardization.train(
image_paths,
output_path=histogram_landmarks_path,
)
np.set_printoptions(suppress=True, precision=3)
print('\nTrained landmarks:', landmarks)
#Histogram standardisation
#Hist standardization
landmarks_dict = {'mri': landmarks}
histogram_transform = tio.HistogramStandardization(landmarks_dict)
#Z-Norm
znorm_transform = tio.ZNormalization(masking_method=tio.ZNormalization.mean)
sample = dataset[0]
transform = tio.Compose([histogram_transform, znorm_transform])
znormed = transform(sample)
fig, ax = plt.subplots(dpi=100)
plot_histogram(ax, znormed.mri.data, label='Z-normed', alpha=1)
ax.set_title('Intensity values of one sample after z-normalization')
ax.set_xlabel('Intensity')
ax.grid()
training_transform = Compose([
ToCanonical(),
# Resample(4),
CropOrPad((112, 112, 48), padding_mode=0), #reflect , original 112,112,48
def test_bad_bounds_mask(self):
transform = tio.ZNormalization(masking_method='test')
with self.assertRaises(ValueError):
transform(self.sample_subject)
subject = tio.Subject(image=tio.ScalarImage(image_path),
mask=tio.LabelMap(label_path))
subjects.append(subject)
# собираем особый датасет torchio с пациентами
dataset = tio.SubjectsDataset(subjects)
# приводим маску к 1 классу
if config.to_one_class:
for subject in dataset.dry_iter():
subject['mask'] = one(subject['mask'])
training_transform = tio.Compose([
tio.Resample(4),
tio.ZNormalization(
masking_method=tio.ZNormalization.mean
), # вот эту штуку все рекомендовали на форумах torchio.
tio.RandomFlip(p=0.25),
tio.RandomNoise(p=0.25),
# !!! Приходится насильно переводить тензоры в float
tio.Lambda(to_float)
])
validation_transform = tio.Compose([
tio.Resample(4),
tio.ZNormalization(masking_method=tio.ZNormalization.mean),
tio.RandomNoise(p=0.25),
tio.Lambda(to_float)
])
create_images(true_gif_output_path,
channels[0],
channels[1],
channels[2],
mri_chan=subject['data'][0][1] > 0,
angle_num=gif_angle_rotation,
angle_view=gif_view_angle,
fig_size=fig_size_gif)
make_gif(true_gif_output_path,
os.path.join(true_gif_output_path, 'true.gif'),
angle_num=gif_angle_rotation)
if __name__ == "__main__":
validation_transform = tio.Compose([
tio.ZNormalization(masking_method=tio.ZNormalization.mean),
tio.CropOrPad((240, 240, 160)),
tio.OneHot(num_classes=5)
])
gen_visuals(
image_path=
"../brats_new/BraTS2020_TrainingData/MICCAI_BraTS2020_TrainingData/BraTS20_Training_010",
transforms=validation_transform,
model_path="./Models/test_train_many_1e-3.pt",
gen_pred=True,
gen_true=True,
input_channels_list=['flair', 't1', 't2', 't1ce'],
seg_channels=[1, 2, 4],
gen_gif=False,
true_gif_output_path="../output/true",
pred_gif_output_path="../output/pred",
rescaled = rescale(fpg_ras)
fig, axes = plt.subplots(2, 1)
sns.distplot(fpg.mri.data, ax=axes[0], kde=False)
sns.distplot(rescaled.mri.data, ax=axes[1], kde=False)
axes[0].set_title('Original histogram')
axes[1].set_title('Intensity rescaling with percentiles 1 and 99')
axes[0].set_ylim((0, 1e6))
axes[1].set_ylim((0, 1e6))
plt.tight_layout()
show_fpg(rescaled)
#Z-normalization
#Another common approach for normalization is forcing data points to have zero-mean
#and unit variance. We can use ZNormalization for this.
standardize = tio.ZNormalization()
standardized = standardize(fpg)
fig, axes = plt.subplots(2, 1)
sns.distplot(fpg.mri.data, ax=axes[0], kde=False)
sns.distplot(standardized.mri.data, ax=axes[1], kde=False)
axes[0].set_title('Original histogram')
axes[1].set_title('Z-normalization')
axes[0].set_ylim((0, 1e6))
axes[1].set_ylim((0, 1e6))
plt.tight_layout()
#The second mode in our distribution, corresponding to the foreground, is far from zero
#because the background contributes a lot to the mean computation.
#We can compute the stats using e.g. values above the mean only.
#Let's see if the mean is a good threshold to segment the foreground.
lr_1=tio.ScalarImage(t2_file),
)
if in_channels == 3:
subject = tio.Subject(
hr=tio.ScalarImage(t2_file),
lr_1=tio.ScalarImage(t2_file),
lr_2=tio.ScalarImage(t2_file),
lr_3=tio.ScalarImage(t2_file),
)
subjects.append(subject)
print('DHCP Dataset size:', len(subjects), 'subjects')
# DATA AUGMENTATION
normalization = tio.ZNormalization()
spatial = tio.RandomAffine(scales=0.1, degrees=10, translation=0, p=0.75)
flip = tio.RandomFlip(axes=('LR', ), flip_probability=0.5)
tocanonical = tio.ToCanonical()
b1 = tio.Blur(std=(0.001, 0.001, 1), include='lr_1') #blur
d1 = tio.Resample((0.8, 0.8, 2), include='lr_1') #downsampling
u1 = tio.Resample(target='hr', include='lr_1') #upsampling
if in_channels == 3:
b2 = tio.Blur(std=(0.001, 1, 0.001), include='lr_2') #blur
d2 = tio.Resample((0.8, 2, 0.8), include='lr_2') #downsampling
u2 = tio.Resample(target='hr', include='lr_2') #upsampling
b3 = tio.Blur(std=(1, 0.001, 0.001), include='lr_3') #blur
subject = tio.Subject(
t2=tio.ScalarImage(t2_file),
t1=tio.ScalarImage(t1_file),
label=tio.LabelMap(seg_file),
)
subjects.append(subject)
dataset = tio.SubjectsDataset(subjects)
print('Dataset size:', len(dataset), 'subjects')
onehot = tio.OneHot()
flip = tio.RandomFlip(axes=('LR', ), flip_probability=0.5)
bias = tio.RandomBiasField(coefficients=0.5, p=0.5)
noise = tio.RandomNoise(std=0.1, p=0.25)
normalization = tio.ZNormalization(masking_method='label')
spatial = tio.RandomAffine(scales=0.1, degrees=10, translation=0, p=0.75)
transforms = [flip, spatial, bias, normalization, noise, onehot]
training_transform = tio.Compose(transforms)
validation_transform = tio.Compose([normalization, onehot])
#%%
num_subjects = len(dataset)
num_training_subjects = int(training_split_ratio * num_subjects)
num_validation_subjects = num_subjects - num_training_subjects
num_split_subjects = num_training_subjects, num_validation_subjects
training_subjects, validation_subjects = torch.utils.data.random_split(
subjects,
def dataloader(handles, mode = 'train'):
# If pickle exists, load it
try:
with open('../inputs/flpickles/' + mode + '.pickle', 'rb') as f:
images = pickle.load(f)
except:
images = {}
images['Image'] = []
images['Label'] = []
images['Gap'] = []
images['ID'] = []
# Data augmentations
random_flip = tio.RandomFlip(axes=1)
random_flip2 = tio.RandomFlip(axes=2)
random_affine = tio.RandomAffine(seed=0, scales=(3, 3))
random_elastic = tio.RandomElasticDeformation(
max_displacement=(0, 20, 40),
num_control_points=20,
seed=0,
)
rescale = tio.RescaleIntensity((-1, 1), percentiles=(1, 99))
standardize_foreground = tio.ZNormalization(masking_method=lambda x: x > x.mean())
blur = tio.RandomBlur(seed=0)
standardize = tio.ZNormalization()
add_noise = tio.RandomNoise(std=0.5, seed=42)
add_spike = tio.RandomSpike(seed=42)
add_ghosts = tio.RandomGhosting(intensity=1.5, seed=42)
add_motion = tio.RandomMotion(num_transforms=6, image_interpolation='nearest', seed=42)
swap = tio.RandomSwap(patch_size = 7)
# For each image
for idx, row in handles.iterrows():
im_aug = []
lb_aug = []
gap_aug = []
imgs = np.zeros(shape=(1, 1,7,1024, 1024), dtype=np.float32) # change patch shape if necessary
lbs = np.zeros(shape=(1, 1,7,1024, 1024), dtype=np.float32)
gaps = np.zeros(shape=(1, 1,7,1024, 1024), dtype=np.float32)
im = io.imread(row['Image'])
im = im / 255 # Normalization
im = np.expand_dims(im, axis=0)
imgs[0] = im
im_aug.append(imgs)
images['ID'].append(row['ID'])
if mode == 'train':
im_flip1 = random_flip(im)
imgs[0] = im_flip1
im_aug.append(imgs)
im_flip2 = random_flip2(im)
imgs[0] = im_flip2
im_aug.append(imgs)
im_affine = random_affine(im)
imgs[0] = im_affine
im_aug.append(imgs)
im_elastic = random_elastic(im)
imgs[0] = im_elastic
im_aug.append(imgs)
im_rescale = rescale(im)
imgs[0] = im_rescale
im_aug.append(imgs)
im_standard = standardize_foreground(im)
imgs[0] = im_standard
im_aug.append(imgs)
im_blur = blur(im)
imgs[0] = im_blur
im_aug.append(imgs)
im_noisy = add_noise(standardize(im))
imgs[0] = im_noisy
im_aug.append(imgs)
im_spike = add_spike(im)
imgs[0] = im_spike
im_aug.append(imgs)
im_ghost = add_ghosts(im)
imgs[0] = im_ghost
im_aug.append(imgs)
im_motion = add_motion(im)
imgs[0] = im_motion
im_aug.append(imgs)
im_swap = swap(im)
imgs[0] = im_swap
im_aug.append(imgs)
images['Image'].append(np.array(im_aug))
if mode != 'test':
lb = io.imread(row['Label'])
lb = label_converter(lb)
lb = np.expand_dims(lb, axis=0)
lbs[0] = lb
lb_aug.append(lbs)
gap = io.imread(row['Gap'])
gap = np.expand_dims(gap, axis = 0)
gaps[0] = gap
gap_aug.append(gaps)
if mode == 'train':
lb_flip1 = random_flip(lb)
lbs[0] = lb_flip1
lb_aug.append(lbs)
lb_flip2 = random_flip2(lb)
lbs[0] = lb_flip2
lb_aug.append(lbs)
lb_affine = random_affine(lb)
lbs[0] = lb_affine
lb_aug.append(lbs)
lb_elastic = random_elastic(lb)
lbs[0] = lb_elastic
lb_aug.append(lbs)
lbs[0] = lb
lb_aug.append(lbs)
lbs[0] = lb
lb_aug.append(lbs)
lbs[0] = lb
lb_aug.append(lbs)
lbs[0] = lb
lb_aug.append(lbs)
lbs[0] = lb
lb_aug.append(lbs)
lbs[0] = lb
lb_aug.append(lbs)
lbs[0] = lb
lb_aug.append(lbs)
lbs[0] = lb
lb_aug.append(lbs)
gap_flip1 = random_flip(gap)
gaps[0] = gap_flip1
gap_aug.append(gaps)
gap_flip2 = random_flip2(gap)
gaps[0] = gap_flip2
gap_aug.append(gaps)
gap_affine = random_affine(gap)
gaps[0] = gap_affine
gap_aug.append(gaps)
gap_elastic = random_elastic(gap)
gaps[0] = gap_elastic
gap_aug.append(gaps)
gaps[0] = gap
gap_aug.append(gaps)
gaps[0] = gap
gap_aug.append(gaps)
gaps[0] = gap
gap_aug.append(gaps)
gaps[0] = gap
gap_aug.append(gaps)
gaps[0] = gap
gap_aug.append(gaps)
gaps[0] = gap
gap_aug.append(gaps)
gaps[0] = gap
gap_aug.append(gaps)
gaps[0] = gap
gap_aug.append(gaps)
images['Label'].append(np.array(lb_aug))
images['Gap'].append(np.array(gap_aug))
# Save images
with open("../inputs/flpickles/" + mode + '.pickle', 'wb') as f:
pickle.dump(images, f)
with open('../inputs/flpickles/' + mode + '.pickle', 'rb') as f:
images = pickle.load(f)
return images
