我们从Python开源项目中，提取了以下34个代码示例，用于说明如何使用scipy.ndimage.interpolation.map_coordinates()。
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;
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
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)
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 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(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, 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 elastictransform(sigma, alpha, randomstate=None, invert=False, padding=0, ignorechannels=True): # rng is going to end up in _elastictransform's closure, which should guarantee persistence over function calls if isinstance(randomstate, int): rng = np.random.RandomState(randomstate) elif isinstance(randomstate, np.random.RandomState): rng = randomstate else: rng = np.random.RandomState(None) # Define function on image def _elastictransform(image): assert image.ndim == 2, "Can only transform 2D images." # Pad image if required if not invert and padding > 0: # Pad image = np.pad(image, padding, mode='reflect') # Take measurements imshape = image.shape # Make random fields dx = rng.uniform(-1, 1, imshape) * alpha dy = rng.uniform(-1, 1, imshape) * alpha if __debug__ and False: print("RNG Debug on _elastictransform: ") print("Invert: {}, dx[0, 0]: {}".format(invert, dx[0, 0])) print("Invert: {}, dy[0, 0]: {}".format(invert, dy[0, 0])) # Smooth dx and dy sdx = gaussian_filter(dx, sigma=sigma, mode='reflect') sdy = gaussian_filter(dy, sigma=sigma, mode='reflect') # Make meshgrid x, y = np.meshgrid(np.arange(imshape[1]), np.arange(imshape[0])) # Distort meshgrid indices (invert if required) if not invert: distinds = (y + sdy).reshape(-1, 1), (x + sdx).reshape(-1, 1) else: distinds = (y - sdy).reshape(-1, 1), (x - sdx).reshape(-1, 1) # Map cooordinates from image to distorted index set transformedimage = map_coordinates(image, distinds, mode='reflect').reshape(imshape) # Crop image if required if invert and padding > 0: transformedimage= transformedimage[padding:-padding, padding:-padding] return transformedimage # Convert image function to batch function and return return image2batchfunc(_elastictransform, ignorechannels=ignorechannels) #: Function for random rotations of the image
def elastictransform(sigma, alpha, randomstate=None, invert=False, padding=0, interpolation=3, ignorechannels=True): # rng is going to end up in _elastictransform's closure, which should guarantee persistence over function calls if isinstance(randomstate, int): rng = np.random.RandomState(randomstate) elif isinstance(randomstate, np.random.RandomState): rng = randomstate else: rng = np.random.RandomState(None) # Define function on image def _elastictransform(image): # Pad image if required if not invert and padding > 0: # Pad image = np.pad(image, padding, mode='reflect') # Take measurements imshape = image.shape # Make random fields dx = rng.uniform(-1, 1, imshape) * alpha dy = rng.uniform(-1, 1, imshape) * alpha # Smooth dx and dy sdx = gaussian_filter(dx, sigma=sigma, mode='reflect') sdy = gaussian_filter(dy, sigma=sigma, mode='reflect') # Make meshgrid x, y = np.meshgrid(np.arange(imshape[1]), np.arange(imshape[0])) # Distort meshgrid indices (invert if required) if not invert: distinds = (y + sdy).reshape(-1, 1), (x + sdx).reshape(-1, 1) else: distinds = (y - sdy).reshape(-1, 1), (x - sdx).reshape(-1, 1) # Map cooordinates from image to distorted index set transformedimage = map_coordinates(image, distinds, mode='reflect', order=interpolation).reshape(imshape) # Crop image if required if invert and padding > 0: transformedimage= transformedimage[padding:-padding, padding:-padding] return transformedimage # Convert image function to batch function and return return image2batchfunc(_elastictransform, ignorechannels=ignorechannels) #: Function for random rotations of the image
def elastic_transform(image, alpha, sigma): """ Elastic deformation of images as described in [1]. [1] 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 gist https://gist.github.com/erniejunior/601cdf56d2b424757de5 Args: image (np.ndarray): image to be deformed alpha (list): scale of transformation for each dimension, where larger values have more deformation sigma (list): Gaussian window of deformation for each dimension, where smaller values have more localised deformation Returns: np.ndarray: deformed image """ assert len(alpha) == len(sigma), \ "Dimensions of alpha and sigma are different" channelbool = image.ndim - len(alpha) out = np.zeros((len(alpha) + channelbool, ) + image.shape) # Generate a Gaussian filter, leaving channel dimensions zeroes for jj in range(len(alpha)): array = (np.random.rand(*image.shape) * 2 - 1) out[jj] = gaussian_filter(array, sigma[jj], mode="constant", cval=0) * alpha[jj] # Map mask to indices shapes = list(map(lambda x: slice(0, x, None), image.shape)) grid = np.broadcast_arrays(*np.ogrid[shapes]) indices = list(map((lambda x: np.reshape(x, (-1, 1))), grid + np.array(out))) # Transform image based on masked indices transformed_image = map_coordinates(image, indices, order=0, mode='reflect').reshape(image.shape) return transformed_image
def convertToLogPolar(img, centerTrans, angleStep, logBase, mode = "nearest"): if mode == "nearest": # Step 1 - Initialize transformed image transformedImage = np.zeros(img.shape, dtype = img.dtype) # Step 2 - Apply reverse log polar transformation for radius in range(img.shape[COLS_AXIS]): # start with radius, because calculating exponential power is time consuming actRadius = logBase ** radius for angle in range(img.shape[ROWS_AXIS]): anglePi = angle * angleStep # calculate euclidian coordinates (source: https://en.wikipedia.org/wiki/Log-polar_coordinates) row = int(centerTrans[ROWS_AXIS] + actRadius * math.sin(anglePi)) col = int(centerTrans[COLS_AXIS] + actRadius * math.cos(anglePi)) # copy pixel from the location to log polar image if 0 <= row < img.shape[ROWS_AXIS] and 0 <= col < img.shape[COLS_AXIS]: transformedImage[angle, radius] = img[row, col] return transformedImage else: print("Base: " + str(logBase)) # create matrix with angles anglesMap = np.zeros(img.shape, dtype=np.float64) # each column has 0 in its first row and -pi in its last row anglesVector = -np.linspace(0, np.pi, img.shape[0], endpoint=False) # initialize it by columns using the same vector anglesMap.T[:] = anglesVector # create matrix with radii radiusMap = np.zeros(img.shape, dtype=np.float64) # each line contains a vector with numbers from in (0, cols) to power logBase radiusVector = np.power(logBase, np.arange(img.shape[1], dtype=np.float64)) - 1.0 # initialize it by rows using the same vector radiusMap[:] = radiusVector # calculate x coordinates (source: https://en.wikipedia.org/wiki/Log-polar_coordinates) x = radiusMap * np.sin(anglesMap) + centerTrans[1] # calculate y coordinates (source: https://en.wikipedia.org/wiki/Log-polar_coordinates) y = radiusMap * np.cos(anglesMap) + centerTrans[0] # initialize final image outputImg = np.zeros(img.shape) # use spline interpolation to map pixels from original image to calculated coordinates ndii.map_coordinates(img, [x, y], output=outputImg) return outputImg # computes phase correlation and returns position of pixel with highest value (row, column)
