def elastic_transform(image, alpha, sigma, random_state=None):
"""Elastic deformation of images as described in [Simard2003]_.
.. [Simard2003] Simard, Steinkraus and Platt, "Best Practices for
Convolutional Neural Networks applied to Visual Document Analysis", in
Proc. of the International Conference on Document Analysis and
Recognition, 2003.
"""
if random_state is None:
random_state = np.random.RandomState(None)
shape = image.shape[1:];
dx = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma, mode="constant", cval=0) * alpha
dy = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma, mode="constant", cval=0) * alpha
x, y = np.meshgrid(np.arange(shape[1]), np.arange(shape[0]))
indices = np.reshape(y+dy, (-1, 1)), np.reshape(x+dx, (-1, 1))
#return map_coordinates(image, indices, order=1).reshape(shape)
res = np.zeros_like(image);
for i in xrange(image.shape[0]):
res[i] = map_coordinates(image[i], indices, order=1).reshape(shape)
return res;
python类map_coordinates()的实例源码
def map_data_cosinetolinear(self,values_on_cosine_grid,Ny,a,b):
"""
Map data on a cosine grid to a linear grid
"""
ycells = np.linspace(0, Ny, Ny)
ylin = np.linspace(a, b, Ny)
ycos = 0.5*(b+a) - 0.5*(b-a)*np.cos((ycells*np.pi)/(Ny-1))
#print(ycos.shape,values_on_cosine_grid.shape)
#plt.plot(ycos,values_on_cosine_grid,'x-',label='cosinetolinear Before')
values_on_linear_grid = interp.griddata(ycos, values_on_cosine_grid,
ylin, method='cubic',
fill_value=values_on_cosine_grid[-1])
#values_on_linear_grid = interp2.map_coordinates(values_on_cosine_grid,ycos,output=ylin)
#plt.plot(ylin,values_on_linear_grid,'o-',alpha=0.4,label='cosinetolinear After')
#plt.legend()
#plt.show()
return values_on_linear_grid
augmentation.py 文件源码
项目：ultrasound-nerve-segmentation
作者: EdwardTyantov
项目源码
文件源码
阅读 27
收藏 0
点赞 0
评论 0
def elastic_transform(image, mask, alpha, sigma, alpha_affine=None, random_state=None):
"""Elastic deformation of images as described in [Simard2003]_ (with modifications).
.. [Simard2003] Simard, Steinkraus and Platt, "Best Practices for
Convolutional Neural Networks applied to Visual Document Analysis", in
Proc. of the International Conference on Document Analysis and
Recognition, 2003.
Based on https://gist.github.com/erniejunior/601cdf56d2b424757de5
"""
if random_state is None:
random_state = np.random.RandomState(None)
shape = image.shape
dx = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma) * alpha
dy = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma) * alpha
x, y = np.meshgrid(np.arange(shape[1]), np.arange(shape[0]))
indices = np.reshape(y+dy, (-1, 1)), np.reshape(x+dx, (-1, 1))
res_x = map_coordinates(image, indices, order=1, mode='reflect').reshape(shape)
res_y = map_coordinates(mask, indices, order=1, mode='reflect').reshape(shape)
return res_x, res_y
def cmap_file2d(data, cmap, roll_x=0.):
cmap[:, -1] = cmap[:, 0]
data_dim, nrows, ncols = data.shape
data2 = np.copy(data)
#data2[1] = (data2[1] - roll_x) % 1.0
data2[0] *= cmap.shape[0]
data2[1] *= cmap.shape[1]
plt.figure()
plt.imshow(cmap)
data2 = data2.reshape(data_dim, nrows, ncols)
r = map_coordinates(cmap[:, :, 0], data2, order=1, mode='nearest')
g = map_coordinates(cmap[:, :, 1], data2, order=1, mode='nearest')
b = map_coordinates(cmap[:, :, 2], data2, order=1, mode='nearest')
rgb = np.array([r, g, b])
rgb = rgb.reshape(3, nrows, ncols).transpose(1, 2, 0)
return rgb
def TF_elastic_deform(img, alpha=1.0, sigma=1.0):
"""Elastic deformation of images as described in Simard 2003"""
assert len(img.shape) == 3
h, w, nc = img.shape
if nc != 1:
raise NotImplementedError("Multi-channel not implemented.")
# Generate uniformly random displacement vectors, then convolve with gaussian kernel
# and finally multiply by a magnitude coefficient alpha
dx = alpha * gaussian_filter(
(np.random.random((h, w)) * 2 - 1), sigma, mode="constant", cval=0
)
dy = alpha * gaussian_filter(
(np.random.random((h, w)) * 2 - 1), sigma, mode="constant", cval=0
)
# Map image to the deformation mesh
x, y = np.meshgrid(np.arange(h), np.arange(w), indexing='ij')
indices = np.reshape(x+dx, (-1, 1)), np.reshape(y+dy, (-1, 1))
return map_coordinates(img.reshape((h,w)), indices, order=1).reshape(h,w,nc)
def unwrap_ellipse(image, params, rad_range, num_points=None, spline_order=3):
""" Unwraps an circular or ellipse-shaped feature into elliptic coordinates.
Transforms an image in (y, x) space to (theta, r) space, using elliptic
coordinates. The theta coordinate is tangential to the ellipse, the r
coordinate is normal to the ellipse. r=0 at the ellipse: inside the ellipse,
r < 0.
Parameters
----------
image : ndarray, 2d
params : (yr, xr, yc, xc)
rad_range : tuple
A tuple defining the range of r to interpolate.
num_points : number, optional
The number of ``theta`` values. By default, this equals the
ellipse circumference: approx. every pixel there is an interpolation.
spline_order : number, optional
The order of the spline interpolation. Default 3.
Returns
-------
intensity : the interpolated image in (theta, r) space
pos : the (y, x) positions of the ellipse grid
normal : the (y, x) unit vectors normal to the ellipse grid
"""
yr, xr, yc, xc = params
# compute the r coordinates
steps = np.arange(rad_range[0], rad_range[1] + 1, 1)
# compute the (y, x) positions and unit normals of the ellipse
pos, normal = ellipse_grid((yr, xr), (yc, xc), n=num_points, spacing=1)
# calculate all the (y, x) coordinates on which the image interpolated.
# this is a 3D array of shape [n_theta, n_r, 2], with 2 being y and x.
coords = normal[:, :, np.newaxis] * steps[np.newaxis, np.newaxis, :] + \
pos[:, :, np.newaxis]
# interpolate the image on computed coordinates
intensity = map_coordinates(image, coords, order=spline_order,
output=np.float)
return intensity, pos, normal
def image_function(self, image):
# Cast image to one of the native dtypes (one which that is supported by scipy)
image = self.cast(image)
# Take measurements
imshape = image.shape
# Obtain flows
flows = self.get_random_variable('flow_y', imshape=imshape), \
self.get_random_variable('flow_x', imshape=imshape)
# Map cooordinates from image to distorted index set
transformed_image = map_coordinates(image, flows,
mode='reflect', order=self.order).reshape(imshape)
# Uncast image to the original dtype
transformed_image = self.uncast(transformed_image)
return transformed_image
def gauss_distort(images,maxdelta=2.0,sigma=10.0):
n,m = images[0].shape
deltas = randn(2,n,m)
deltas = gaussian_filter(deltas,(0,sigma,sigma))
deltas /= max(amax(deltas),-amin(deltas))
deltas *= maxdelta
xy = transpose(array(meshgrid(range(n),range(m))),axes=[0,2,1])
# print(xy.shape, deltas.shape)
deltas += xy
return [map_coordinates(image,deltas,order=1) for image in images]
def distort_elastic(image, smooth=10.0, scale=100.0, seed=0):
"""
Elastic distortion of images.
Channel axis in RGB images will not be distorted but grayscale or
RGB images are both valid inputs. RGB and grayscale images will be
distorted identically for the same seed.
Simard, et. al, "Best Practices for Convolutional Neural Networks
applied to Visual Document Analysis",
in Proc. of the International Conference on Document Analysis and
Recognition, 2003.
:param ndarayy image: Image of shape [h,w] or [h,w,c]
:param float smooth: Smoothes the distortion.
:param float scale: Scales the distortion.
:param int seed: Seed for random number generator. Ensures that for the
same seed images are distorted identically.
:return: Distorted image with same shape as input image.
:rtype: ndarray
"""
# create random, smoothed displacement field
rnd = np.random.RandomState(int(seed))
h, w = image.shape[:2]
dxy = rnd.rand(2, h, w, 3) * 2 - 1
dxy = gaussian_filter(dxy, smooth, mode="constant")
dxy = dxy / np.linalg.norm(dxy) * scale
dxyz = dxy[0], dxy[1], np.zeros_like(dxy[0])
# create transformation coordinates and deform image
is_color = len(image.shape) == 3
ranges = [np.arange(d) for d in image.shape]
grid = np.meshgrid(*ranges, indexing='ij')
add = lambda v, dv: v + dv if is_color else v + dv[:, :, 0]
idx = [np.reshape(add(v, dv), (-1, 1)) for v, dv in zip(grid, dxyz)]
distorted = map_coordinates(image, idx, order=1, mode='reflect')
return distorted.reshape(image.shape)
def __call__(self, xi):
"""Interpolate at the given coordinate.
Parameters
----------
xi : numpy.array
The coordinates to evaluate, with shape (..., ndim)
Returns
-------
val : numpy.array
The interpolated values at the given coordinates.
"""
ext = self._ext
ndim = self.ndim
xi = self._normalize_inputs(xi)
ans_shape = xi.shape[:-1]
xi = xi.reshape(-1, ndim)
ext_idx_vec = False
for idx in range(self.ndim):
ext_idx_vec = ext_idx_vec | (xi[:, idx] < ext) | (xi[:, idx] > self._max[idx])
int_idx_vec = ~ext_idx_vec
xi_ext = xi[ext_idx_vec, :]
xi_int = xi[int_idx_vec, :]
ans = np.empty(xi.shape[0])
ans[int_idx_vec] = imag_interp.map_coordinates(self._filt_values, xi_int.T, mode='nearest', prefilter=False)
if xi_ext.size > 0:
if not self._extrapolate:
raise ValueError('some inputs are out of bounds.')
ans[ext_idx_vec] = self._extfun(xi_ext)
if ans.size == 1:
return ans[0]
return ans.reshape(ans_shape)
def test_th_map_coordinates():
np.random.seed(42)
input = np.random.random((100, 100))
coords = (np.random.random((200, 2)) * 99)
sp_mapped_vals = map_coordinates(input, coords.T, order=1)
th_mapped_vals = th_map_coordinates(
Variable(torch.from_numpy(input)), Variable(torch.from_numpy(coords))
)
assert np.allclose(sp_mapped_vals, th_mapped_vals.data.numpy(), atol=1e-5)
spine_layers_nii.py 文件源码
项目：SemiSupervised_itterativeCNN
作者: styloInt
项目源码
文件源码
阅读 29
收藏 0
点赞 0
评论 0
def elastic_transform(image, alpha, sigma, alpha_affine, random_state=None):
"""Elastic deformation of images as described in [Simard2003]_ (with modifications).
.. [Simard2003] Simard, Steinkraus and Platt, "Best Practices for
Convolutional Neural Networks applied to Visual Document Analysis", in
Proc. of the International Conference on Document Analysis and
Recognition, 2003.
Based on https://gist.github.com/erniejunior/601cdf56d2b424757de5
"""
if random_state is None:
random_state = np.random.RandomState(None)
shape = image.shape
shape_size = shape[:2]
# Random affine
center_square = np.float32(shape_size) // 2
square_size = min(shape_size) // 3
pts1 = np.float32([center_square + square_size, [center_square[0]+square_size, center_square[1]-square_size], center_square - square_size])
pts2 = pts1 + random_state.uniform(-alpha_affine, alpha_affine, size=pts1.shape).astype(np.float32)
M = cv2.getAffineTransform(pts1, pts2)
image = cv2.warpAffine(image, M, shape_size[::-1], borderMode=cv2.BORDER_REFLECT_101)
dx = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma) * alpha
dy = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma) * alpha
dz = np.zeros_like(dx)
x, y, z = np.meshgrid(np.arange(shape[1]), np.arange(shape[0]), np.arange(shape[2]))
indices = np.reshape(y+dy, (-1, 1)), np.reshape(x+dx, (-1, 1)), np.reshape(z, (-1, 1))
return map_coordinates(image, indices, order=1, mode='reflect').reshape(shape)
def sample_point(img, point, order=1):
scale = np.mat(img.get_affine()[0:3, 0:3]).I
offset = np.dot(-scale, img.get_affine()[0:3, 3]).T
s_point = np.dot(scale, point).T + offset[:]
return ndinterp.map_coordinates(img.get_data().squeeze(), s_point, order=order)
def sample(self, img, order):
"""Samples an image using this slice"""
physical = self.get_physical(img.affine)
return ndinterp.map_coordinates(img.get_data().squeeze(), physical, order=order).T
def test_tf_map_coordinates():
np.random.seed(42)
input = np.random.random((100, 100))
coords = np.random.random((200, 2)) * 99
sp_mapped_vals = map_coordinates(input, coords.T, order=1)
tf_mapped_vals = tf_map_coordinates(
K.variable(input), K.variable(coords)
)
assert np.allclose(sp_mapped_vals, K.eval(tf_mapped_vals), atol=1e-5)
def elastic_transform(images, alpha_range=200, sigma=10, random_state=None):
"""Elastic deformation of images as described in [Simard2003]_.
.. [Simard2003] Simard, Steinkraus and Platt, "Best Practices for
Convolutional Neural Networks applied to Visual Document Analysis", in
Proc. of the International Conference on Document Analysis and
Recognition, 2003.
"""
alpha = np.random.uniform(0, alpha_range)
if random_state is None:
random_state = np.random.RandomState(None)
shape = images[0].shape
if len(shape) == 3:
shape = images[0].shape[1:]
dx = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma, mode="constant", cval=0) * alpha
dy = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma, mode="constant", cval=0) * alpha
x, y = np.meshgrid(np.arange(shape[0]), np.arange(shape[1]), indexing='ij')
indices = np.reshape(x+dx, (-1, 1)), np.reshape(y+dy, (-1, 1))
results = []
for image in images:
if len(images[0].shape) == 3:
im = np.zeros(image.shape)
for i, c_image in enumerate(image):
im[i] = map_coordinates(c_image, indices, order=1).reshape(shape)
else:
im = map_coordinates(image, indices, order=1).reshape(shape)
results.append(im)
return results
def elastic_transform_multi(x, alpha, sigma, mode="constant", cval=0, is_random=False):
"""Elastic deformation of images as described in `[Simard2003] <http://deeplearning.cs.cmu.edu/pdfs/Simard.pdf>`_.
Parameters
-----------
x : list of numpy array
others : see ``elastic_transform``.
"""
if is_random is False:
random_state = np.random.RandomState(None)
else:
random_state = np.random.RandomState(int(time.time()))
shape = x[0].shape
if len(shape) == 3:
shape = (shape[0], shape[1])
new_shape = random_state.rand(*shape)
results = []
for data in x:
is_3d = False
if len(data.shape) == 3 and data.shape[-1] == 1:
data = data[:,:,0]
is_3d = True
elif len(data.shape) == 3 and data.shape[-1] != 1:
raise Exception("Only support greyscale image")
assert len(data.shape)==2
dx = gaussian_filter((new_shape * 2 - 1), sigma, mode=mode, cval=cval) * alpha
dy = gaussian_filter((new_shape * 2 - 1), sigma, mode=mode, cval=cval) * alpha
x_, y_ = np.meshgrid(np.arange(shape[0]), np.arange(shape[1]), indexing='ij')
indices = np.reshape(x_ + dx, (-1, 1)), np.reshape(y_ + dy, (-1, 1))
# print(data.shape)
if is_3d:
results.append( map_coordinates(data, indices, order=1).reshape((shape[0], shape[1], 1)))
else:
results.append( map_coordinates(data, indices, order=1).reshape(shape) )
return np.asarray(results)
# zoom
def gauss_distort(images,maxdelta=2.0,sigma=10.0):
n,m = images[0].shape
deltas = randn(2,n,m)
deltas = gaussian_filter(deltas,(0,sigma,sigma))
deltas /= max(amax(deltas),-amin(deltas))
deltas *= maxdelta
xy = transpose(array(meshgrid(range(n),range(m))),axes=[0,2,1])
# print(xy.shape, deltas.shape)
deltas += xy
return [map_coordinates(image,deltas,order=1) for image in images]
def elastic_transform_multi(x, alpha, sigma, mode="constant", cval=0, is_random=False):
"""Elastic deformation of images as described in `[Simard2003] <http://deeplearning.cs.cmu.edu/pdfs/Simard.pdf>`_.
Parameters
-----------
x : list of numpy array
others : see ``elastic_transform``.
"""
if is_random is False:
random_state = np.random.RandomState(None)
else:
random_state = np.random.RandomState(int(time.time()))
shape = x[0].shape
if len(shape) == 3:
shape = (shape[0], shape[1])
new_shape = random_state.rand(*shape)
results = []
for data in x:
is_3d = False
if len(data.shape) == 3 and data.shape[-1] == 1:
data = data[:,:,0]
is_3d = True
elif len(data.shape) == 3 and data.shape[-1] != 1:
raise Exception("Only support greyscale image")
assert len(data.shape)==2
dx = gaussian_filter((new_shape * 2 - 1), sigma, mode=mode, cval=cval) * alpha
dy = gaussian_filter((new_shape * 2 - 1), sigma, mode=mode, cval=cval) * alpha
x_, y_ = np.meshgrid(np.arange(shape[0]), np.arange(shape[1]), indexing='ij')
indices = np.reshape(x_ + dx, (-1, 1)), np.reshape(y_ + dy, (-1, 1))
# print(data.shape)
if is_3d:
results.append( map_coordinates(data, indices, order=1).reshape((shape[0], shape[1], 1)))
else:
results.append( map_coordinates(data, indices, order=1).reshape(shape) )
return np.asarray(results)
# zoom
def gauss_distort(images,maxdelta=2.0,sigma=10.0):
n,m = images[0].shape
deltas = randn(2,n,m)
deltas = gaussian_filter(deltas,(0,sigma,sigma))
deltas /= max(amax(deltas),-amin(deltas))
deltas *= maxdelta
xy = transpose(array(meshgrid(range(n),range(m))),axes=[0,2,1])
# print(xy.shape, deltas.shape)
deltas += xy
return [map_coordinates(image,deltas,order=1) for image in images]
def cmap_file2d(data, cmap, roll_x=0.):
cmap[:, -1] = cmap[:, 0]
data_dim, nrows, ncols = data.shape
data2 = np.copy(data)
#data2[1] = (data2[1] - roll_x) % 1.0
data2[0] *= cmap.shape[0]
data2[1] *= cmap.shape[1]
data2 = data2.reshape(data_dim, nrows, ncols)
r = map_coordinates(cmap[:, :, 0], data2, order=1, mode='nearest')
g = map_coordinates(cmap[:, :, 1], data2, order=1, mode='nearest')
b = map_coordinates(cmap[:, :, 2], data2, order=1, mode='nearest')
rgb = np.array([r, g, b])
rgb = rgb.reshape(3, nrows, ncols).transpose(1, 2, 0)
return rgb
def elastic_transform_multi(x, alpha, sigma, mode="constant", cval=0, is_random=False):
"""Elastic deformation of images as described in `[Simard2003] <http://deeplearning.cs.cmu.edu/pdfs/Simard.pdf>`_.
Parameters
-----------
x : list of numpy array
others : see ``elastic_transform``.
"""
if is_random is False:
random_state = np.random.RandomState(None)
else:
random_state = np.random.RandomState(int(time.time()))
shape = x[0].shape
if len(shape) == 3:
shape = (shape[0], shape[1])
new_shape = random_state.rand(*shape)
results = []
for data in x:
is_3d = False
if len(data.shape) == 3 and data.shape[-1] == 1:
data = data[:,:,0]
is_3d = True
elif len(data.shape) == 3 and data.shape[-1] != 1:
raise Exception("Only support greyscale image")
assert len(data.shape)==2
dx = gaussian_filter((new_shape * 2 - 1), sigma, mode=mode, cval=cval) * alpha
dy = gaussian_filter((new_shape * 2 - 1), sigma, mode=mode, cval=cval) * alpha
x_, y_ = np.meshgrid(np.arange(shape[0]), np.arange(shape[1]), indexing='ij')
indices = np.reshape(x_ + dx, (-1, 1)), np.reshape(y_ + dy, (-1, 1))
# print(data.shape)
if is_3d:
results.append( map_coordinates(data, indices, order=1).reshape((shape[0], shape[1], 1)))
else:
results.append( map_coordinates(data, indices, order=1).reshape(shape) )
return np.asarray(results)
# zoom
def test_th_map_coordinates():
np.random.seed(42)
input = np.random.random((100, 100))
coords = (np.random.random((200, 2)) * 99)
sp_mapped_vals = map_coordinates(input, coords.T, order=1)
th_mapped_vals = th_map_coordinates(
Variable(torch.from_numpy(input)), Variable(torch.from_numpy(coords))
)
assert np.allclose(sp_mapped_vals, th_mapped_vals.data.numpy(), atol=1e-5)
processing.py 文件源码
项目：Ultras-Sound-Nerve-Segmentation---Kaggle
作者: Simoncarbo
项目源码
文件源码
阅读 34
收藏 0
点赞 0
评论 0
def elastic_transform(image, alpha, sigma, random_state=None):
"""Elastic deformation of images as described in [Simard2003]_.
.. [Simard2003] Simard, Steinkraus and Platt, "Best Practices for
Convolutional Neural Networks applied to Visual Document Analysis", in
Proc. of the International Conference on Document Analysis and
Recognition, 2003.
Code taken from https://gist.github.com/fmder/e28813c1e8721830ff9c
slightly modified
"""
min_im = np.min(image)
max_im = np.max(image)
if random_state is None:
random_state = np.random.RandomState(None)
shape = image.shape
dx = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma, mode="constant", cval=0)
dx = dx/np.max(dx)* alpha
dy = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma, mode="constant", cval=0)
dy = dy/np.max(dy)* alpha
x, y = np.meshgrid(np.arange(shape[1]), np.arange(shape[0]))
indices = np.reshape(y+dy, (-1, 1)), np.reshape(x+dx, (-1, 1))
image_tfd = map_coordinates(image,indices,order=3).reshape(shape)
image_tfd[image_tfd>max_im] = max_im
image_tfd[image_tfd<min_im] = min_im
return image_tfd
def elastic_transform(image, alpha, sigma, alpha_affine, random_state=None):
"""Elastic deformation of images as described in [Simard2003]_ (with modifications).
.. [Simard2003] Simard, Steinkraus and Platt, "Best Practices for
Convolutional Neural Networks applied to Visual Document Analysis", in
Proc. of the International Conference on Document Analysis and
Recognition, 2003.
Based on https://gist.github.com/erniejunior/601cdf56d2b424757de5
"""
if random_state is None:
random_state = np.random.RandomState(None)
shape = image.shape
shape_size = shape[:2]
# Random affine
center_square = np.float32(shape_size) // 2
square_size = min(shape_size) // 3
pts1 = np.float32([center_square + square_size, [center_square[0]+square_size, center_square[1]-square_size], center_square - square_size])
pts2 = pts1 + random_state.uniform(-alpha_affine, alpha_affine, size=pts1.shape).astype(np.float32)
M = cv2.getAffineTransform(pts1, pts2)
image = cv2.warpAffine(image, M, shape_size[::-1], borderMode=cv2.BORDER_REFLECT_101)
dx = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma) * alpha
dy = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma) * alpha
dz = np.zeros_like(dx)
x, y, z = np.meshgrid(np.arange(shape[1]), np.arange(shape[0]), np.arange(shape[2]))
indices = np.reshape(y+dy, (-1, 1)), np.reshape(x+dx, (-1, 1)), np.reshape(z, (-1, 1))
return map_coordinates(image, indices, order=1, mode='reflect').reshape(shape)
step2_train_mass_segmenter.py 文件源码
项目：kaggle_ndsb2017
作者: juliandewit
项目源码
文件源码
阅读 21
收藏 0
点赞 0
评论 0
def elastic_transform(image, alpha, sigma, random_state=None):
global ELASTIC_INDICES
shape = image.shape
if ELASTIC_INDICES == None:
if random_state is None:
random_state = numpy.random.RandomState(1301)
dx = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma, mode="constant", cval=0) * alpha
dy = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma, mode="constant", cval=0) * alpha
x, y = numpy.meshgrid(numpy.arange(shape[0]), numpy.arange(shape[1]))
ELASTIC_INDICES = numpy.reshape(y + dy, (-1, 1)), numpy.reshape(x + dx, (-1, 1))
return map_coordinates(image, ELASTIC_INDICES, order=1).reshape(shape)
def refine_ellipsoid(image3d, params, spacing=1, rad_range=None, maxfit_size=2,
spline_order=3, threshold=0.1):
""" Refines coordinates of a 3D ellipsoid, starting from given parameters.
Interpolates the image along lines perpendicular to the ellipsoid.
The maximum along each line is found using linear regression of the
descrete derivative.
Parameters
----------
image3d : 3d numpy array of numbers
Image indices are interpreted as (z, y, x)
params : tuple
zr, yr, xr, zc, yc, xc
spacing: number
spacing along radial direction
rad_range: tuple of floats
length of the line (distance inwards, distance outwards)
maxfit_size: integer
pixels around maximum pixel that will be used in linear regression
spline_order: integer
interpolation order for edge crossections
threshold: float
a threshold is calculated based on the global maximum
fitregions are rejected if their average value is lower than this
Returns
-------
- zr, yr, xr, zc, yc, xc, skew_y, skew_x
- contour coordinates at z = 0
"""
if not np.all([x > 0 for x in params]):
raise ValueError("All zc, yc, xc, zr, yr, xr params should be positive")
assert image3d.ndim == 3
zr, yr, xr, zc, yc, xc = params
if rad_range is None:
rad_range = (-min(zr, yr, xr) / 2, min(zr, yr, xr) / 2)
steps = np.arange(rad_range[0], rad_range[1] + 1, 1)
pos, normal = ellipsoid_grid((zr, yr, xr), (zc, yc, xc), spacing=spacing)
coords = normal[:, :, np.newaxis] * steps[np.newaxis, np.newaxis, :] + \
pos[:, :, np.newaxis]
# interpolate the image on calculated coordinates
intensity = map_coordinates(image3d, coords, order=spline_order)
# identify the regions around the max value
r_dev = max_linregress(intensity, maxfit_size, threshold)
# calculate new coords
coord_new = pos + (r_dev + rad_range[0])*normal
coord_new = coord_new[:, np.isfinite(coord_new).all(0)]
# fit ellipsoid
radius, center, skew = fit_ellipsoid(coord_new, mode='xy',
return_mode='skew')
return tuple(radius) + tuple(center) + tuple(skew), coord_new.T
def elastic_transform(x, alpha, sigma, mode="constant", cval=0, is_random=False):
"""Elastic deformation of images as described in `[Simard2003] <http://deeplearning.cs.cmu.edu/pdfs/Simard.pdf>`_ .
Parameters
-----------
x : numpy array, a greyscale image.
alpha : scalar factor.
sigma : scalar or sequence of scalars, the smaller the sigma, the more transformation.
Standard deviation for Gaussian kernel. The standard deviations of the Gaussian filter are given for each axis as a sequence, or as a single number, in which case it is equal for all axes.
mode : default constant, see `scipy.ndimage.filters.gaussian_filter <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.filters.gaussian_filter.html>`_.
cval : float, optional. Used in conjunction with mode ‘constant’, the value outside the image boundaries.
is_random : boolean, default False
Examples
---------
>>> x = elastic_transform(x, alpha = x.shape[1] * 3, sigma = x.shape[1] * 0.07)
References
------------
- `Github <https://gist.github.com/chsasank/4d8f68caf01f041a6453e67fb30f8f5a>`_.
- `Kaggle <https://www.kaggle.com/pscion/ultrasound-nerve-segmentation/elastic-transform-for-data-augmentation-0878921a>`_
"""
if is_random is False:
random_state = np.random.RandomState(None)
else:
random_state = np.random.RandomState(int(time.time()))
#
is_3d = False
if len(x.shape) == 3 and x.shape[-1] == 1:
x = x[:,:,0]
is_3d = True
elif len(x.shape) == 3 and x.shape[-1] != 1:
raise Exception("Only support greyscale image")
assert len(x.shape)==2
shape = x.shape
dx = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma, mode=mode, cval=cval) * alpha
dy = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma, mode=mode, cval=cval) * alpha
x_, y_ = np.meshgrid(np.arange(shape[0]), np.arange(shape[1]), indexing='ij')
indices = np.reshape(x_ + dx, (-1, 1)), np.reshape(y_ + dy, (-1, 1))
if is_3d:
return map_coordinates(x, indices, order=1).reshape((shape[0], shape[1], 1))
else:
return map_coordinates(x, indices, order=1).reshape(shape)
def elastic_transform(x, alpha, sigma, mode="constant", cval=0, is_random=False):
"""Elastic deformation of images as described in `[Simard2003] <http://deeplearning.cs.cmu.edu/pdfs/Simard.pdf>`_ .
Parameters
-----------
x : numpy array, a greyscale image.
alpha : scalar factor.
sigma : scalar or sequence of scalars, the smaller the sigma, the more transformation.
Standard deviation for Gaussian kernel. The standard deviations of the Gaussian filter are given for each axis as a sequence, or as a single number, in which case it is equal for all axes.
mode : default constant, see `scipy.ndimage.filters.gaussian_filter <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.filters.gaussian_filter.html>`_.
cval : float, optional. Used in conjunction with mode ‘constant’, the value outside the image boundaries.
is_random : boolean, default False
Examples
---------
>>> x = elastic_transform(x, alpha = x.shape[1] * 3, sigma = x.shape[1] * 0.07)
References
------------
- `Github <https://gist.github.com/chsasank/4d8f68caf01f041a6453e67fb30f8f5a>`_.
- `Kaggle <https://www.kaggle.com/pscion/ultrasound-nerve-segmentation/elastic-transform-for-data-augmentation-0878921a>`_
"""
if is_random is False:
random_state = np.random.RandomState(None)
else:
random_state = np.random.RandomState(int(time.time()))
#
is_3d = False
if len(x.shape) == 3 and x.shape[-1] == 1:
x = x[:,:,0]
is_3d = True
elif len(x.shape) == 3 and x.shape[-1] != 1:
raise Exception("Only support greyscale image")
assert len(x.shape)==2
shape = x.shape
dx = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma, mode=mode, cval=cval) * alpha
dy = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma, mode=mode, cval=cval) * alpha
x_, y_ = np.meshgrid(np.arange(shape[0]), np.arange(shape[1]), indexing='ij')
indices = np.reshape(x_ + dx, (-1, 1)), np.reshape(y_ + dy, (-1, 1))
if is_3d:
return map_coordinates(x, indices, order=1).reshape((shape[0], shape[1], 1))
else:
return map_coordinates(x, indices, order=1).reshape(shape)
def elastic_transform(x, alpha, sigma, mode="constant", cval=0, is_random=False):
"""Elastic deformation of images as described in `[Simard2003] <http://deeplearning.cs.cmu.edu/pdfs/Simard.pdf>`_ .
Parameters
-----------
x : numpy array, a greyscale image.
alpha : scalar factor.
sigma : scalar or sequence of scalars, the smaller the sigma, the more transformation.
Standard deviation for Gaussian kernel. The standard deviations of the Gaussian filter are given for each axis as a sequence, or as a single number, in which case it is equal for all axes.
mode : default constant, see `scipy.ndimage.filters.gaussian_filter <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.filters.gaussian_filter.html>`_.
cval : float, optional. Used in conjunction with mode ‘constant’, the value outside the image boundaries.
is_random : boolean, default False
Examples
---------
>>> x = elastic_transform(x, alpha = x.shape[1] * 3, sigma = x.shape[1] * 0.07)
References
------------
- `Github <https://gist.github.com/chsasank/4d8f68caf01f041a6453e67fb30f8f5a>`_.
- `Kaggle <https://www.kaggle.com/pscion/ultrasound-nerve-segmentation/elastic-transform-for-data-augmentation-0878921a>`_
"""
if is_random is False:
random_state = np.random.RandomState(None)
else:
random_state = np.random.RandomState(int(time.time()))
#
is_3d = False
if len(x.shape) == 3 and x.shape[-1] == 1:
x = x[:,:,0]
is_3d = True
elif len(x.shape) == 3 and x.shape[-1] != 1:
raise Exception("Only support greyscale image")
assert len(x.shape)==2
shape = x.shape
dx = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma, mode=mode, cval=cval) * alpha
dy = gaussian_filter((random_state.rand(*shape) * 2 - 1), sigma, mode=mode, cval=cval) * alpha
x_, y_ = np.meshgrid(np.arange(shape[0]), np.arange(shape[1]), indexing='ij')
indices = np.reshape(x_ + dx, (-1, 1)), np.reshape(y_ + dy, (-1, 1))
if is_3d:
return map_coordinates(x, indices, order=1).reshape((shape[0], shape[1], 1))
else:
return map_coordinates(x, indices, order=1).reshape(shape)
