def __call__(self, img):
self.img = img
min_val = torch.min(torch.flatten(self.img))
if self.img.shape[0] == 1: # 2D images
self.img = torch.squeeze(self.img)
pipeline = A.Compose([
A.Flip(p=0.5),
A.Rotate(self.params["rot"],
interpolation=1,
border_mode=0,
value=min_val.item(),
p=0.5),
A.RandomBrightnessContrast(
brightness_limit=self.params["bright"],
contrast_limit=self.params["contrast"],
p=0.5)
],
p=0.5)
data = {"image": np.float32(self.img)}
out = pipeline(**data)
out = np.expand_dims(out["image"], 0)
elif self.img.shape[0] > 1: # 2.5D images
pipeline = A.Compose([
A.Flip(p=0.5),
A.RandomBrightnessContrast(
brightness_limit=self.params["bright"],
contrast_limit=self.params["contrast"],
p=0.5)
],
p=0.75)
data = {"image": np.float32(self.img)}
out = pipeline(**data)
out = out["image"]
# Elastic deformations with library elasticdeform
if random.uniform(0, 1) < 0.5:
elasticdeform.deform_random_grid(
out,
self.params["sigma"],
self.params["points"],
order=self.params["resample_order"])
return torch.from_numpy(out).float()
def __getitem__(self, index):
# Load intensity image
img_path = self.img_paths[index]
img = np.load(img_path)
seg_exists = len(self.seg_paths) > 0
# Use elastic deformation https://pypi.org/project/elasticdeform/
# Load segmentation image if exists
if seg_exists:
seg_path = self.seg_paths[index]
seg = np.load(seg_path)
if self.sigma != 0:
# Form stack of image and segmentation and deform
def_input = np.concatenate(
(img, seg.reshape(1, seg.shape[0], seg.shape[1])), axis=0)
def_output = elasticdeform.deform_random_grid(def_input,
self.sigma,
self.points,
order=1,
axis=(1, 2))
# Separate image and segmentation in deformed stack
img = def_output[:img.shape[0], :, :]
seg = np.around(def_output[img.shape[0], :, :])
elif self.sigma != 0:
img = elasticdeform.deform_random_grid(img,
self.sigma,
self.points,
order=1,
axis=(1, 2))
# Convert images to pytorch tensors
X = Variable(torch.from_numpy(img)).float()
if seg_exists:
Y = Variable(torch.from_numpy(seg)).long()
else:
Y = torch.zeros(1) # dummy segmentation
name = os.path.basename(self.img_paths[index])
return X, Y, name
def elastic_deform(self,X,Y):
X = X.numpy()
Y = Y.numpy()
brain_region = (X > 0).astype('float') * 10 # Multiplying by 10 so there would be a bigger difference between foreground and background pixels to avoid voxels
# being assigned the wrong label after the elastic deformation
#Split the labels and deform them separately, as if done together together they'll get mixed up. 10 times multiplication again.
lbl1 = (Y == 1) * 10.0
lbl2 = (Y == 2) * 10.0
lbl3 = (Y == 3) * 10.0
sigma_nr = random.uniform(0, 7) # Random factor by which to deform - not too high
deform_axes = tuple(sorted(random.sample([1,2,3], k = 2))) # Random two axes in which to deform. Two to save on computational time. Need to sort the array as axis
#variable requires sorted input
[X, brain_region, lbl1, lbl2, lbl3] = elasticdeform.deform_random_grid([X, brain_region, lbl1, lbl2, lbl3], axis=deform_axes, sigma=sigma_nr, points=3)
brain_region = brain_region.astype('int') > 0
X = X * brain_region # To make sure background pixels remain 0 in the scans
X[X<0] = 0 # Remove any negative values - background values close 0
lbl1[lbl1 < 3] = -1
lbl2[lbl2 < 3] = -1
lbl3[lbl3 < 3] = -1
Y = np.argmax([np.zeros((1, 128, 128, 128)), lbl1, lbl2, lbl3], axis=0).astype('long')
X = torch.from_numpy(X)
Y = torch.from_numpy(Y)
return X,Y
def generator_tr():
for i in range(len(train_img_names)):
X_data = nib.load(train_img_names[i]).get_fdata()
## in case of high variation in the dataset, the data can be normalized
#X_data_norm = ( X_data - np.min(X_data) ) / ( np.max(X_data) - np.min(X_data) )
Y_data = nib.load(train_lbl_names[i]).get_fdata()
## apply registration based data augmentation
if(flags.registration_augmentation and (np.random.rand(1)[0]>0.667) ):
j = np.random.randint(0, high=len(augment_names))
fixed = nib.load(augment_names[j]).get_fdata()
## Need to change depending upon the input is normalized or not
## Here eneuronet does not take normalized input
## but registration model used for data aug takes normalized input
X_data, fixed = X_data/255, fixed/255 ## should be removed if using X_data_norm
X_data, Y_data = data_augment.register(X_data, Y_data, fixed, flags.register_modelfile)
X_data, fixed = X_data*255, fixed*255 ## should be removed if using X_data_norm
#apply elastic deformation
elif(flags.elastic_augmentation and (np.random.rand(1)[0]>0.5) ):
[X_data, Y_data] = elasticdeform.deform_random_grid([X_data, Y_data], sigma=flags.std_dev, order=[3, 0], points=flags.control_points)
#concat_data = np.stack((X_data_norm, Y_data), axis = -1)
concat_data = np.stack((X_data, Y_data), axis = -1)
yield concat_data
def random_elastic_deform(self, image, labels, sigma, points):
cropy, cropx = image.shape[1:]
image = ndimage.zoom(image, (1, self.zoom_factor, self.zoom_factor),
order=1)
labels = ndimage.zoom(labels, (1, self.zoom_factor, self.zoom_factor),
order=1)
y, x = image.shape[1:]
startx = x // 2 - (cropx // 2)
starty = y // 2 - (cropy // 2)
[image, labels] = elasticdeform.deform_random_grid(
X=[image, labels],
axis=(1, 2),
sigma=sigma,
points=points,
order=1,
crop=[
slice(starty, (starty + cropy)),
slice(startx, (startx + cropx))
],
mode="mirror")
return image, labels
def elastic_deform(self, X, Y):
# Elastic deformation with a random square deformation grid, where the displacements are sampled from a normal distribution with
# standard deviation sigma. Applies elastic deformation in all 3 axes, if you wish to speed up training time change the d variable
# to two axes chosen randomly. Uses elasticdeform package from gvtulder/elasticdeform.
X = X.numpy()
Y = Y.numpy()
brain_region = (X > 0).astype('float') * 10 # Multiplying by 10 so there would be a bigger difference between foreground and background pixels to avoid voxels
# being assigned the wrong label after the elastic deformation
#Split the labels and deform them separately, as if done together together they'll get mixed up. 10 times multiplication again.
lbl1 = (Y == 1) * 10.0
lbl2 = (Y == 2) * 10.0
lbl3 = (Y == 3) * 10.0
sigma_nr = 5 # Random factor by which to deform
# d = (1,2,3) # Axes in which to deform
d = tuple(sorted(random.sample([1, 2, 3], k=2))) # Use this instead if you wish to speed up training. Performs elastic transform over 2 axes only
[X, brain_region, lbl1, lbl2, lbl3] = elasticdeform.deform_random_grid([X, brain_region, lbl1, lbl2, lbl3], axis=[d]*5, sigma=sigma_nr, points=3)
brain_region = brain_region.astype('int') > 0
X = X * brain_region # To make sure background pixels remain 0 in the scans
X[X < 0] = 0 # Remove any negative values - background values close 0
lbl1[lbl1 < 3] = -1
lbl2[lbl2 < 3] = -1
lbl3[lbl3 < 3] = -1
Y = np.argmax([np.zeros((1, 128, 128, 128)), lbl1, lbl2, lbl3], axis=0).astype('long')
X = torch.from_numpy(X)
Y = torch.from_numpy(Y)
return X, Y
def imaugment(self, X, Y=None):
"""
Preprocess the tuple (image,mask) and then apply if selected:
augmentation techniques adapted from Keras ImageDataGenerator
elastic deformation
"""
if self.params["augmentation"][0] == True:
X, Y = random_transform(X, Y, **self.params["random_deform"])
if self.params["augmentation"][1] == True:
[X, Y] = elasticdeform.deform_random_grid([X, Y],
axis=[(0, 1), (0, 1)],
sigma=self.params["e_deform_g"]["sigma"],
points=self.params["e_deform_g"]["points"])
if self.params["augmentation"][2] == True:
r = np.random.normal(self.params["noise"]["mean"],
self.params["noise"]["std"], X.shape)
X = X + r.reshape(X.shape)
if self.params["augmentation"][3]:
g = 2 * self.params["gamma"]["range"][1]
while ((g < self.params["gamma"]["range"][0]) |
(g > self.params["gamma"]["range"][1])):
g = np.random.normal(self.params["gamma"]["mean"],
self.params["gamma"]["std"])
if self.params["norm"] is None:
temp = (X - np.min(X)) / (np.max(X) - np.min(X))
temp = np.power(temp, 1 / g)
X = temp * (np.max(X) - np.min(X)) + np.min(X)
else:
X = 2 * np.power(X / 2 + 0.5, 1 / g) - 1
return X, Y
def example_main(what_number_label, tuple_shape, max_data,
the_other_class_num):
randstart = np.random.randint(300)
randend = np.random.randint(500)
for i in range(randstart, 2000 + randend, 1):
if DB_MNIST_checkpunctual.data_sets.train.labels[
i] == what_number_label:
break
pick_a_random_input = i # AMONGST THE data_sets.train.images (28x28) and labels STORED in THE DB
im = DB_MNIST_checkpunctual.data_sets.train.images[pick_a_random_input]
im = np.reshape(im, (28, 28))
#plt.imshow(im, cmap = plt.cm.binary)
#plt.show()
print('LABEL corr to index', pick_a_random_input, 'of the DB is:',
DB_MNIST_checkpunctual.data_sets.train.labels[pick_a_random_input])
im_deformed = []
for i in range(max_data - 1):
im_d_pre = elasticdeform.deform_random_grid(im,
sigma=(0.25, 1, -0.5, 2,
-0.5),
points=5)
im_deformed.append(Normalize(im_d_pre, (28, 28)))
#plt.imshow(im_deformed[-1].reshape(28,28), cmap = plt.cm.binary)
#plt.show()
X = []
X.append(DB_MNIST_checkpunctual.REDUCEPIXELSTOTHEMAX__(im))
for e in im_deformed:
red = DB_MNIST_checkpunctual.REDUCEPIXELSTOTHEMAX__(e)
#norm = Normalize(red, tuple_shape)
X.append(red)
# FLATTEN X
X = np.reshape(X, (max_data, tuple_shape[0] * tuple_shape[1]))
#===========================================================================
# CHECK THE SAMPLE BUILT
#===========================================================================
#for e in X:
# plt.imshow(e.reshape(tuple_shape), cmap = plt.cm.binary)
# plt.show()
# CHECK THE ORIGINAL REDUCEPIZELTOTHEMAX
#just_to_check = DB_MNIST_checkpunctual.REDUCEPIXELSTOTHEMAX__(im)
#plt.imshow(just_to_check, cmap = plt.cm.binary)
#plt.show()
#plt.imshow(X[0].reshape(tuple_shape), cmap = plt.cm.binary)
#plt.show()
FLATTEN_MERG_MATR = stackflatmatrixes(max_data, X[0], X[1:],
the_other_class_num,
tuple_shape[0] * tuple_shape[1])
print('shape FLATTEN_MERG_MATR', np.shape(FLATTEN_MERG_MATR))
return FLATTEN_MERG_MATR
def augmentation(batch):
sigma = ran.uniform(0,5)
aug = edf.deform_random_grid(batch, axis=(1, 2), sigma=sigma, points=4)
up = [ident, flipud]
lr = [ident, fliplr]
aug = ran.choice(up)(aug)
aug = ran.choice(lr)(aug)
return aug
def test2():
X = numpy.array(Image.open(r'C:\proj\py\rw\source_images\3.jpg'))
X[::10, ::10] = 1
# apply deformation with a random 3 x 3 grid
X_deformed = elasticdeform.deform_random_grid(X, sigma=25, points=3)
Image.fromarray(X_deformed).show()
def rotate_and_deform(image, mask, sigma=25):
axes = sample(range(2,4), random.randint(0,3))
# Rotate image and deform
rot_im, rot_ma = torch.flip(image, dims=axes), torch.flip(mask, dims=axes)
rot_im, rot_ma = rot_im.numpy(), rot_ma.numpy()
[im_def, mask_def] = elasticdeform.deform_random_grid([rot_im, rot_ma], axis=(2,3), \
sigma=sigma, mode='mirror', prefilter=False, order = [3, 0])
return torch.as_tensor(im_def), torch.as_tensor(mask_def.round())
def _data_augmentation(self, X, y):
if (self.sigma is not None) and (self.points is not None):
X, y = elasticdeform.deform_random_grid([X, y],
sigma=self.sigma,
points=self.points)
if self.rotate:
rotation = np.random.choice(np.linspace(0, 360, 10))
X, y = ndimage.rotate(X, rotation), ndimage.rotate(y, rotation)
if self.force_zero:
y = np.where(y <= 0.5, 0, 1)
return X, y
def elastic(X, y):
"""
Elastic deformation on a image and its target
"""
[Xel, yel] = elasticdeform.deform_random_grid([X, y],
sigma=5,
axis=[(1, 2, 3), (1, 2, 3)],
order=[3, 0])
return Xel, yel
def random_elastic_deform(x, y):
# create a 5x5x5 grid of random displacement vectors
x, y = elasticdeform.deform_random_grid(
[x, y],
sigma=4,
points=(5, 5, 5),
order=[2, 0],
mode="reflect",
prefilter=False
) # use order 0 (nearest neigbour interpolation for mask)
return x, y
def process_MSD(root, task='Heart2', num_surf=5):
img_list, gt_list = get_MSD_list(root, task)
save_dir = os.path.join(root, task)
n = len(img_list)
for i in range(n):
print('Process img: {}'.format(img_list[i]))
img = ants.image_read(img_list[i])
gt = ants.image_read(gt_list[i])
# iso-resample
img_ = iso_resample(img, [1.5, 1.5, 1.5], islabel=False)
gt_ = iso_resample(gt, [1.5, 1.5, 1.5], islabel=True)
# crop
img_np = img_.numpy()
gt_np = gt_.numpy()
img_np = crop(img_np)
gt_np = crop(gt_np)
# normal
img_np = normalize(img_np)
# sample surf init
for j in tqdm(range(num_surf)):
gt_dfm = elasticdeform.deform_random_grid(gt_np, 4, 4, 0)
gt_dfm_smooth = mcubes.smooth_gaussian(gt_dfm, 1)
v, e = mcubes.marching_cubes(gt_dfm_smooth, 0)
mcubes.export_obj(
v, e,
os.path.join(
save_dir, 'surfs_unaligned',
'{:0>2d}_{:0>2d}surf_init.obj'.format(i + 1, j + 1)))
# write image
img_nii = ants.from_numpy(img_np, img_.origin, img_.spacing,
img_.direction, img_.has_components,
img_.is_rgb)
gt_nii = ants.from_numpy(gt_np, gt_.origin, gt_.spacing, gt_.direction,
gt_.has_components, gt_.is_rgb)
ants.image_write(
img_nii,
os.path.join(save_dir, 'images', '{:0>2d}img.nii'.format(i + 1)))
ants.image_write(
gt_nii,
os.path.join(save_dir, 'labels', '{:0>2d}gt.nii'.format(i + 1)))
gt_smooth = mcubes.smooth_gaussian(gt_np, 1)
v, e = mcubes.marching_cubes(gt_smooth, 0)
mcubes.export_obj(
v, e,
os.path.join(save_dir, 'surfs_unaligned',
'{:0>2d}surf.obj'.format(i + 1)))
def elastic(X, y):
"""
Elastic deformation on a image and its target
"""
[Xel, yel] = elasticdeform.deform_random_grid([X, y],
sigma=2,
axis=[(0, 1, 2), (0, 1, 2)],
order=[1, 0],
mode='constant')
return Xel, yel
def apply_deform(img, label):
"""Apply B-spline deformation to an image and label simultaneously - the same transform applies to both."""
# Note that the image and label must be the same size in order to use this
assert (
img.shape == label.shape
), f"Image and label must be the same shape but got image: {img.shape}, label: {label.shape}"
img, label = elasticdeform.deform_random_grid([img, label],
sigma=img.shape[0] /
500.0,
points=10,
order=[3, 0])
return img, label
def elastic_deform(self, img, seg):
i = random.randint(0, 2)
if i == 0:
img, seg = elasticdeform.deform_random_grid([img, seg],
order=[3, 0],
sigma=7,
points=3,
axis=[(0, 1), (0, 1)])
elif i == 1:
img, seg = elasticdeform.deform_random_grid([img, seg],
order=[3, 0],
sigma=7,
points=3,
axis=[(1, 2), (1, 2)])
else:
img, seg = elasticdeform.deform_random_grid([img, seg],
order=[3, 0],
sigma=7,
points=3,
axis=[(0, 2), (0, 2)])
return img, seg
def augment_and_crop(reps=5):
'''
Cropping down each n original images to 4 new (256x256) images, and also augmenting each original
image to reps new images, resulting in an extended dataset of size n*4 + n*reps.
The new dataset is saved in data/train and data/label and the original dataset
is expected to exist in data/train_original and data/label_original
'''
if os.path.isdir('data/label'):
shutil.rmtree('data/label') # FIY these are gitignored
shutil.rmtree('data/train') # FIY these are gitignored
os.mkdir('data/label')
os.mkdir('data/train')
n = 30
img_len = 512
border_pad = 256 // 2
for i in range(n):
# apply deformation with a random 3 x 3 grid and standard dev=10 pixels
x = np.asarray(imageio.imread("data/train_original/" + str(i) +
".jpg")).astype('float64')
y = np.asarray(imageio.imread("data/label_original/" + str(i) +
".jpg")).astype('float64')
print(i)
for (k, (u, v)) in enumerate(((0, 0), (0, 256), (256, 0), (256, 256))):
#crop down each original 512x512 image to 4 cropped 256x256 images
imageio.imsave(
'data/train/' + str(4 * i + k) + ".jpg",
x[u:u + 256, v:v + 256].clip(0, 255).astype('uint8'))
imageio.imsave(
'data/label/' + str(4 * i + k) + ".jpg",
y[u:u + 256, v:v + 256].clip(0, 255).astype('uint8'))
for j in range(reps):
[x0_ij, x1_ij, x2_ij, y_ij] = elasticdeform.deform_random_grid(
[x[:, :, 0], x[:, :, 1], x[:, :, 2], y], sigma=10, points=3)
x_ij = np.zeros((512, 512, 3))
x_ij[:, :, 0] = x0_ij
x_ij[:, :, 1] = x1_ij
x_ij[:, :, 2] = x2_ij
x_ij = x_ij[border_pad:img_len - border_pad, border_pad:img_len -
border_pad] # crop down to 256x256x3
y_ij = y_ij[border_pad:img_len - border_pad, border_pad:img_len -
border_pad] # crop down to 256x256
x_ij = x_ij.clip(0, 255).astype('uint8')
y_ij = y_ij.clip(0, 255).astype('uint8')
idx = 30 * 4 + i * reps + j
imageio.imsave('data/train/' + str(idx) + ".jpg", x_ij)
imageio.imsave('data/label/' + str(idx) + ".jpg", y_ij)
def generator_tr():
for i in range(len(train_img_names)):
X_data = nib.load(train_img_names[i]).get_fdata()
## in case of high variation in the dataset, the data can be normalized
#X_data_norm = ( X_data - np.min(X_data) ) / ( np.max(X_data) - np.min(X_data) )
Y_data = nib.load(train_lbl_names[i]).get_fdata()
#apply elastic deformation
if(flags.data_augmentation and (np.random.rand(1)[0]>0.5) ):
[X_data, Y_data] = elasticdeform.deform_random_grid([X_data, Y_data], sigma=flags.std_dev, order=[3, 0], points=flags.control_points)
#concat_data = np.stack((X_data_norm, Y_data), axis = -1)
concat_data = np.stack((X_data, Y_data), axis = -1)
yield concat_data
def aug_elastic_deform(img, label, wmap):
assert len(img.shape) == 2 and len(label.shape) == 2 and len(
wmap.shape) == 2
# Apply deformation with a random 3 x 3 grid to inputs X and Y,
# with a different interpolation for each input
img_distort, label_distort, wmap_distort = elasticdeform.deform_random_grid(
X=[img, label, wmap],
sigma=10,
points=3,
order=[2, 0, 0],
mode='mirror')
return img_distort, label_distort, wmap_distort
def DataAugmentation(images_input, aug_keys):
'''
DataAugmentation() applies the data augmentations specified in aug_par
to input images. It compiles a numpy array of batch_size images, as well as
concatenating ground truth masks and weight maps into a single numpy array.
'''
output = list(images_input)
# Apply augmentation operations if key word in aug_par:
if "horizontal_flip" in aug_keys:
if aug_keys["horizontal_flip"]:
if random.randint(0,1): #coin flip
for index, item in enumerate(output):
output[index] = np.fliplr(item)
if "vertical_flip" in aug_keys:
if aug_keys["vertical_flip"]:
if random.randint(0,1): #coin flip
for index, item in enumerate(output):
output[index] = np.flipud(item)
if "rotations_360" in aug_keys:
if aug_keys["rotations_360"]:
rot = random.randint(0,360)
if rot>0:
for index,item in enumerate(output):
output[index] = ndimage.rotate(item,rot,order=0,reshape=False)
if "elastic_deformation" in aug_keys:
if aug_keys['elastic_deformation']:
if random.randint(0,1): #coin flip
output = elasticdeform.deform_random_grid(output,
sigma=25,
points=3,
order=0,
axis=(0,1))
# Correct for large black patches in deformed raw image
img = output[0]
output[0] = np.where(img==0,np.mean(img),img)
if "histogram_voodoo" in aug_keys:
if aug_keys['histogram_voodoo']:
if random.randint(0,1): #coin flip
# Only transform the input image, not masks
output[0] = histogram_voodoo(output[0])
return output
def __call__(self, sample):
seed = random.randint(1, 9999999)
np.random.seed(seed + 1)
elastic_bool = bool(random.getrandbits(1))
if elastic_bool:
image, mask = sample['image'], sample['mask']
[deformed_img, deformed_mask] = elasticdeform.deform_random_grid([image, mask], axis=[(1, 2, 3), (0, 1, 2)],
sigma=self.sigma,
points=self.points,
order=self.order)
return {'image': deformed_img, 'mask': deformed_mask}
else:
return {'image': sample['image'], 'mask': sample['mask']}
def generate_offres(N, f=300, rotate=True, deform=True):
'''
Off-resonance generator
Parameters
----------
N : int
Grid size.
f : float or array_like
Off-resonance frequency.
rotate : bool
Rotation flag
deform : bool
Elastic Deformation flag
'''
max_rot = 360
offres = np.zeros((N, N))
rot_angle = max_rot * random.uniform(-1,1)
offres, _ = np.meshgrid(np.linspace(-f, f, N), np.linspace(-f, f, N))
if rotate == True:
offres = ndimage.rotate(offres, rot_angle, reshape=False, order=3, mode='nearest')
if deform == True:
offres = ed.deform_random_grid(offres, sigma=10, points=3, order=3, mode='nearest')
return offres
def elastic_deformation(image):
sigma = random.randint(1, 10)
image[:,:,0] = elasticdeform.deform_random_grid(image[:,:,0], sigma=sigma, points=3)
return image
def toy_voronoi_labels_affinities(
width_, height_, radius, opening_radius, deform_sigma, deform_points,
intensity_prob,
noise_sigma
):
# we will create bigger images such that we can crop out regions,
# that look good
offset = 2 * radius
height = height_ + 2 * offset
width = width_ + 2 * offset
shape = (height, width)
labels = np.zeros(shape, dtype=np.uint16)
sketch = np.zeros_like(labels, dtype=float)
# r is the distance between two center points, so we need to multiply by 2
centers = poisson_disc_samples(width=width, height=height, r=radius * 2)
# append far points to centers to complete voronoi regions
x_max = width + 1
y_max = height + 1
centers = centers + [(-1, -1), (-1, y_max), (x_max, -1), (x_max, y_max)]
vor = Voronoi(centers)
# create selem with provided radius to apply clsoing
selem = disk(opening_radius)
for i, region in enumerate(vor.regions):
if -1 in region or len(region) == 0:
continue
polygon = [vor.vertices[i] for i in region]
mask = polygon2mask(shape, polygon)
# close polygon mask with provided selem and radius
mask = binary_opening(mask, selem)
# enumerate starts at 0, but 0 is background
labels[mask] = i + 1
edt = distance_transform_edt(mask)
edt = edt / edt.max()
tmp_intensity = np.random.uniform(*intensity_prob)
sketch[mask] = edt[mask] * tmp_intensity
sketch = scipy.ndimage.gaussian_filter(sketch, radius / 4)
[labels, sketch] = elasticdeform.deform_random_grid(
[labels, sketch], sigma=deform_sigma, points=deform_points,
# labels must be interpolated by nearest neighbor
order=[0, 3],
crop=(
slice(offset, offset + height_ + 1),
slice(offset, offset + width_ + 1)
)
)
# labels = labels[offset:-offset + 1, offset:-offset + 1]
# sketch = sketch[offset:-offset + 1, offset:-offset + 1]
noise = sketch + np.random.normal(0, noise_sigma, size=sketch.shape)
affinities = get_affinities(labels)
return labels[:-1, :-1], sketch[:-1, :-1], noise[:-1, :-1], affinities
def data_augmentation(images_input, aug_par, order=0):
'''
Data augmentation function
Parameters
----------
images_input : list of 2D numpy arrays of floats
Images to apply augmentation operations to.
aug_par : dict
Augmentation operations parameters. Accepted key-value pairs:
illumination_voodoo: bool. Whether to apply the illumination
voodoo operation.
histogram_voodoo: bool. Whether to apply the histogram voodoo
operation.
elastic_deformation: dict. If key exists, the elastic deformation
operation is applied. The parameters are given as key-value
pairs. sigma values are given under the sigma key, deformation
points are given under the points key. See elasticdeform doc.
gaussian_noise: float. Apply gaussian noise to the image. The
sigma value of the gaussian noise is uniformly sampled between
0 and +gaussian_noise.
horizontal_flip: bool. Whether to flip the images horizontally.
Input images have a 50% chance of being flipped
vertical_flip: bool. Whether to flip the images vertically.
Input images have a 50% chance of being flipped
rotations90d: bool. Whether to randomly rotate the images in 90°
increments. Each 90° rotation has a 25% chance of happening
rotation: int/float. Range of random rotation to apply. The angle
is uniformly sampled in the range [-rotation, +rotation]
zoom: float. Range of random "zoom" to apply. The image
is randomly zoomed by a factor that is sampled from an
exponential distribution with a lamba of 3/zoom. The random
factor is clipped at +zoom.
shiftX: int/float. The range of random shifts to apply along X. A
uniformly sampled shift between [-shiftX, +shiftX] is applied
shiftY: int/float. The range of random shifts to apply along Y. A
uniformly sampled shift between [-shiftY, +shiftY] is applied
Note that the same operations are applied to all inputs.
order : int or list/tuple of ints, optional
Interpolation order to use for each image in the input stack. If order
is a scalar, the same order is applied to all images. If a list of
orders is provided, each image in the stack will have its own operaiton
order. See skimage.transform.wrap doc.
Note that the histogram voodoo operation is only applied to images with
a non-zero order.
The default is 0.
Returns
-------
output : list of 2D numpy arrays of floats
Augmented images array.
'''
#processing inputs / initializing variables::
output = list(images_input)
if np.isscalar(order):
orderlist = [order] * len(images_input)
else:
orderlist = list(order)
# Apply augmentation operations:
if "illumination_voodoo" in aug_par:
if aug_par["illumination_voodoo"]:
for index, item in enumerate(output):
if order[index] > 0: # Not super elegant, but tells me if binary or grayscale image
output[index] = illumination_voodoo(item)
#TODO: Illumination voodoo 2D
if "histogram_voodoo" in aug_par:
if aug_par["histogram_voodoo"]:
for index, item in enumerate(output):
if order[index] > 0: # Not super elegant, but tells me if binary or grayscale image
output[index] = histogram_voodoo(item)
if 'gaussian_noise' in aug_par:
if aug_par['gaussian_noise']:
sigma = np.random.rand() * aug_par['gaussian_noise']
for index, item in enumerate(output):
if order[index] > 0: # Not super elegant, but tells me if binary or grayscale image
item = item + np.random.normal(
0, sigma, item.shape) # Add Gaussian noise
output[index] = (item - np.min(item)) / np.ptp(
item) # Rescale to 0-1
if "elastic_deformation" in aug_par:
output = elasticdeform.deform_random_grid(
output,
sigma=aug_par["elastic_deformation"]["sigma"],
points=aug_par["elastic_deformation"]["points"],
order=[i * 3 for i in orderlist
], # Using bicubic interpolation instead of bilinear here
mode='nearest',
axis=(0, 1),
prefilter=False)
if "horizontal_flip" in aug_par:
if aug_par["horizontal_flip"]:
if random.randint(0, 1): #coin flip
for index, item in enumerate(output):
output[index] = np.fliplr(item)
if "vertical_flip" in aug_par:
if aug_par["vertical_flip"]:
if random.randint(0, 1): #coin flip
for index, item in enumerate(output):
output[index] = np.flipud(item)
if "rotations_90d" in aug_par: # Only works with square images right now!
if aug_par["rotations_90d"]:
rot = random.randint(0, 3) * 90
if rot > 0:
for index, item in enumerate(output):
output[index] = trans.rotate(item,
rot,
mode='edge',
order=orderlist[index])
if "rotation" in aug_par:
rot = random.uniform(-aug_par["rotation"], aug_par["rotation"])
for index, item in enumerate(output):
output[index] = trans.rotate(item,
rot,
mode='edge',
order=orderlist[index])
if "zoom" in aug_par:
zoom = random.expovariate(
3 * 1 /
aug_par["zoom"]) # I want most of them to not be too zoomed
zoom = aug_par["zoom"] if zoom > aug_par["zoom"] else zoom
else:
zoom = 0
if "shiftX" in aug_par:
shiftX = random.uniform(-aug_par["shiftX"], aug_par["shiftX"])
else:
shiftX = 0
if "shiftY" in aug_par:
shiftY = random.uniform(-aug_par["shiftY"], aug_par["shiftY"])
else:
shiftY = 0
if any(abs(x) > 0 for x in [zoom, shiftX, shiftY]):
for index, item in enumerate(output):
output[index] = zoomshift(item,
zoom + 1,
shiftX,
shiftY,
order=orderlist[index])
return output
data_shifts_cuda = data_shifts.clone().cuda()
data_shifts_scatter = scatter(data_shifts_cuda)
d_shifts_scatter = torch.mean((data_shifts_scatter - data_scatt)**2)
#print('Distance: {}, shifts std: {}'.format(d_shifts, d_shifts_l2))
print('shift size - INV {}: , scatter: P{}'.format(data_shifts_L2.shape,
data_shifts_scatter.shape))
print('Distance: {}, shifts (our): {}, scatter: {}'.format(
d_shifts, d_shifts_l2,
d_shifts_scatter.detach().cpu()))
# add Deformation
import elasticdeform
σ = 3
data_deformation = torch.tensor(
elasticdeform.deform_random_grid(data.numpy(), sigma=σ, axis=(2, 3)))
data_deformation_L2 = invariant_L2(model_new, data_deformation)
d_deformation = torch.mean((data_deformation - data)[:, :, 2 * σ:-2 * σ]**2)
d_deformation_L2 = torch.mean((data_deformation_L2 - data_L2)[:, :,
2 * σ:-2 * σ]**2)
data_deformation_cuda = data_deformation.clone().cuda()
data_deformation_scatter = scatter(data_deformation_cuda)
d_deformation_scatter = torch.mean((data_deformation_scatter - data_scatt)**2)
#print('Distance: {}, deformation std: {}'.format(d_deformation, d_deformation_L2))
print('deformation size - INV {}: , scatter: P{}'.format(
data_deformation_L2.shape, data_deformation_scatter.shape))
print('Distance: {}, deformation (our): {}, scatter: {} '.format(
d_deformation, d_deformation_L2,
d_deformation_scatter.detach().cpu()))
def test_random(self):
for points in (3, (3, 5)):
for shape in ((100, 100), (100, 75)):
for order in (0, 1, 2, 3, 4):
X = np.random.rand(*shape)
elasticdeform.deform_random_grid(X, points=points)
c = segFolder(
"C:\\Users\\Sharron\\Desktop\\pytorch\\ttt\\Unet-master\\train",
both_transform=Compose([
[
torchvision.transforms.Grayscale(),
torchvision.transforms.Grayscale()
],
[
torchvision.transforms.Resize(500),
torchvision.transforms.Resize(500)
],
[numpy.array, numpy.array],
lambda X: deform_random_grid(
X,
10,
5,
),
[
torchvision.transforms.ToPILImage(),
torchvision.transforms.ToPILImage()
],
RandomCrop(284,
padding=(92, 92, 92, 92),
padding_mode="symmetric",
pad_if_needed=False),
[None, torchvision.transforms.CenterCrop(100)],
[torchvision.transforms.ToTensor(),
torchvision.transforms.ToTensor()],
#[None,toint64],
[None, torch.squeeze],
