def derive(self, samples):
samples = samples[0]
uuids = [s['uuid'] for s in samples]
image_paths = [os.path.join(self.path, 'images', '{}.png'.format(u)) for u in uuids]
derived = numpy.array([scipy.ndimage.imread(p).transpose() for p in image_paths])
derived = derived.astype(numpy.float32)
derived /= 255
return derived
python类ndimage()的实例源码
def get_batch(self, subset, batch_size, use_target_distribution=False):
# Select a subset
if subset == 'train':
X = self.X_train
y = self.y_train
elif subset == 'valid':
X = self.X_val
y = self.y_val
elif subset == 'test':
X = self.X_test
y = self.y_test
# Random choice of samples
idx = np.random.choice(X.shape[0], batch_size)
batch = X[idx, 0, :].reshape((batch_size, 28, 28))
# Resize from 28x28 to 64x64
batch_resized = []
factor = self.image_size / 28.0
for i in range(batch.shape[0]):
# resize to 64x64 pixels
batch_resized.append(scipy.ndimage.zoom(batch[i, :, :], factor, order=1))
batch = np.stack(batch_resized)
batch = batch.reshape((batch_size, 1, self.image_size, self.image_size))
# Convert to RGB
batch = np.concatenate([batch, batch, batch], axis=1)
# Modify images if target distribution requested
if use_target_distribution:
# Binarize images
batch[batch >= 0.5] = 1
batch[batch < 0.5] = 0
# For each image in the mini batch
for i in range(batch_size):
# Take a random crop of the Lena image (background)
x_c = np.random.randint(0, self.lena.size[0] - self.image_size)
y_c = np.random.randint(0, self.lena.size[1] - self.image_size)
image = self.lena.crop((x_c, y_c, x_c + self.image_size, y_c + self.image_size))
image = np.asarray(image).transpose((2, 0, 1)) / 255.0
# Randomly alter the color distribution of the crop
for j in range(3):
image[j, :, :] = (image[j, :, :] + np.random.uniform(0, 1)) / 2.0
# Invert the color of pixels where there is a number
image[batch[i, :, :, :] == 1] = 1 - image[batch[i, :, :, :] == 1]
batch[i, :, :, :] = image
# Rescale to range [-1, +1]
# batch = batch * 2 - 1
# Image label
labels = y[idx]
return batch.astype('float32'), labels.astype('int32')
def get_edgemask(a, edge_env=False, convex=False, dilate=False):
a = checkma(a)
#Need to deal with RGB images here
#Need to be careful, probably want to take minimum value from masks
if a.ndim == 3:
#Assume that the same mask applies to each band
#Only create edges for one band
b = a[:,:,0]
#Could convert to HSL and do edges for L channel
#b = a[:,:,0].mask + a[:,:,1].mask + a[:,:,2].mask
else:
b = a
#Get pixel locations of edges
edges0, edges1, edges = get_edges(b, convex)
#Compute min/max indices
#minrow, maxrow, mincol, maxcol
#edge_bbox = [edges0[0][0].min(), edges0[1][0].max() + 1, edges0[0][1].min(), edges0[1][1].max() + 1]
edge_bbox = [edges[0].min(), edges[0].max() + 1, edges[1].min(), edges[1].max() + 1]
#Initialize new mask arrays
#Need both to deal with undercuts
colmask = np.empty_like(b.mask)
colmask[:] = True
rowmask = np.empty_like(b.mask)
rowmask[:] = True
#Loop through each item in the edge list
#i is index, col is the column number listed at index i
#unmask pixels between specified row numbers at index i
for i,col in enumerate(edges0[0][1]):
colmask[edges0[0][0][i]:edges0[1][0][i], col] = False
for j,row in enumerate(edges1[0][0]):
rowmask[row, edges1[0][1][j]:edges1[1][1][j]] = False
#Combine the two masks with or operator
newmask = np.logical_or(colmask, rowmask)
if dilate:
print("Dilating edgemask")
import scipy.ndimage as ndimage
n = 3
#Note: this results in unmasked elements near image corners
#This will erode True values, which correspond to masked elements
#Effect is to expand the unmasked area
#newmask = ndimage.morphology.binary_erosion(newmask, iterations=n)
#Now dilate to return to original size
#newmask = ndimage.morphology.binary_dilation(newmask, iterations=n)
#This is a more logical approach, dilating unmasked areas
newmask = ~ndimage.morphology.binary_dilation(~newmask, iterations=n)
newmask = ~ndimage.morphology.binary_erosion(~newmask, iterations=n)
if edge_env:
return newmask, edge_bbox
else:
return newmask
#This will update the mask to remove interior holes from unmasked region
def imblur(Y, sig=5, siz=11, nDimBlur=None, kernel=None):
"""Spatial filtering with a Gaussian or user defined kernel
The parameters are specified in GreedyROI
"""
from scipy.ndimage.filters import correlate
X = np.zeros(np.shape(Y))
if kernel is None:
if nDimBlur is None:
nDimBlur = Y.ndim - 1
else:
nDimBlur = np.min((Y.ndim, nDimBlur))
if np.isscalar(sig):
sig = sig * np.ones(nDimBlur)
if np.isscalar(siz):
siz = siz * np.ones(nDimBlur)
# xx = np.arange(-np.floor(siz[0] / 2), np.floor(siz[0] / 2) + 1)
# yy = np.arange(-np.floor(siz[1] / 2), np.floor(siz[1] / 2) + 1)
# hx = np.exp(-xx**2 / (2 * sig[0]**2))
# hx /= np.sqrt(np.sum(hx**2))
# hy = np.exp(-yy**2 / (2 * sig[1]**2))
# hy /= np.sqrt(np.sum(hy**2))
# temp = correlate(Y, hx[:, np.newaxis, np.newaxis], mode='constant')
# X = correlate(temp, hy[np.newaxis, :, np.newaxis], mode='constant')
# the for loop helps with memory
# for t in range(np.shape(Y)[-1]):
# temp = correlate(Y[:,:,t],hx[:,np.newaxis])#,mode='constant', cval=0.0)
# X[:,:,t] = correlate(temp,hy[np.newaxis,:])#,mode='constant', cval=0.0)
X = Y.copy()
for i in range(nDimBlur):
h = np.exp(-np.arange(-np.floor(siz[i] / 2), np.floor(siz[i] / 2) + 1)**2
/ (2 * sig[i]**2))
h /= np.sqrt(h.dot(h))
shape = [1] * len(Y.shape)
shape[i] = -1
X = correlate(X, h.reshape(shape), mode='constant')
else:
X = correlate(Y, kernel[..., np.newaxis], mode='constant')
# for t in range(np.shape(Y)[-1]):
# X[:,:,t] = correlate(Y[:,:,t],kernel,mode='constant', cval=0.0)
return X
#%%
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 zoom(x, zoom_range=(0.9, 1.1), is_random=False, row_index=0, col_index=1, channel_index=2,
fill_mode='nearest', cval=0.):
"""Zoom in and out of a single image, randomly or non-randomly.
Parameters
-----------
x : numpy array
An image with dimension of [row, col, channel] (default).
zoom_range : list or tuple
- If is_random=False, (h, w) are the fixed zoom factor for row and column axies, factor small than one is zoom in.
- If is_random=True, (min zoom out, max zoom out) for x and y with different random zoom in/out factor.
e.g (0.5, 1) zoom in 1~2 times.
is_random : boolean, default False
If True, randomly zoom.
row_index, col_index, channel_index : int
Index of row, col and channel, default (0, 1, 2), for theano (1, 2, 0).
fill_mode : string
Method to fill missing pixel, default ‘nearest’, more options ‘constant’, ‘reflect’ or ‘wrap’.
- `scipy ndimage affine_transform <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.interpolation.affine_transform.html>`_
cval : scalar, optional
Value used for points outside the boundaries of the input if mode='constant'. Default is 0.0.
- `scipy ndimage affine_transform <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.interpolation.affine_transform.html>`_
"""
if len(zoom_range) != 2:
raise Exception('zoom_range should be a tuple or list of two floats. '
'Received arg: ', zoom_range)
if is_random:
if zoom_range[0] == 1 and zoom_range[1] == 1:
zx, zy = 1, 1
print(" random_zoom : not zoom in/out")
else:
zx, zy = np.random.uniform(zoom_range[0], zoom_range[1], 2)
else:
zx, zy = zoom_range
# print(zx, zy)
zoom_matrix = np.array([[zx, 0, 0],
[0, zy, 0],
[0, 0, 1]])
h, w = x.shape[row_index], x.shape[col_index]
transform_matrix = transform_matrix_offset_center(zoom_matrix, h, w)
x = apply_transform(x, transform_matrix, channel_index, fill_mode, cval)
return x
def get_batch(self, subset, batch_size, use_target_distribution=False):
# Select a subset
if subset == 'train':
X = self.X_train
y = self.y_train
elif subset == 'valid':
X = self.X_val
y = self.y_val
elif subset == 'test':
X = self.X_test
y = self.y_test
# Random choice of samples
idx = np.random.choice(X.shape[0], batch_size)
batch = X[idx, 0, :].reshape((batch_size, 28, 28))
# Resize from 28x28 to 64x64
batch_resized = []
for i in range(batch.shape[0]):
# resize to 64x64 pixels
batch_resized.append(scipy.ndimage.zoom(batch[i, :, :], 2.3, order=1))
batch = np.stack(batch_resized)
batch = batch.reshape((batch_size, 1, 64, 64))
# Convert to RGB
batch = np.concatenate([batch, batch, batch], axis=1)
# Modify images if target distribution requested
if use_target_distribution:
# Binarize images
batch[batch >= 0.5] = 1
batch[batch < 0.5] = 0
# For each image in the mini batch
for i in range(batch_size):
# Take a random crop of the Lena image (background)
x_c = np.random.randint(0, self.lena.size[0] - 64)
y_c = np.random.randint(0, self.lena.size[1] - 64)
image = self.lena.crop((x_c, y_c, x_c + 64, y_c + 64))
image = np.asarray(image).transpose((2, 0, 1)) / 255.0
# Randomly alter the color distribution of the crop
for j in range(3):
image[j, :, :] = (image[j, :, :] + np.random.uniform(0, 1)) / 2.0
# Invert the color of pixels where there is a number
image[batch[i, :, :, :] == 1] = 1 - image[batch[i, :, :, :] == 1]
batch[i, :, :, :] = image
# Rescale to range [-1, +1]
batch = batch * 2 - 1
# Image label
labels = y[idx]
return batch.astype('float32'), labels.astype('int32')
def rotation(x, rg=20, is_random=False, row_index=0, col_index=1, channel_index=2,
fill_mode='nearest', cval=0., order=1):
"""Rotate an image randomly or non-randomly.
Parameters
-----------
x : numpy array
An image with dimension of [row, col, channel] (default).
rg : int or float
Degree to rotate, usually 0 ~ 180.
is_random : boolean, default False
If True, randomly rotate.
row_index, col_index, channel_index : int
Index of row, col and channel, default (0, 1, 2), for theano (1, 2, 0).
fill_mode : string
Method to fill missing pixel, default ‘nearest’, more options ‘constant’, ‘reflect’ or ‘wrap’
- `scipy ndimage affine_transform <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.interpolation.affine_transform.html>`_
cval : scalar, optional
Value used for points outside the boundaries of the input if mode='constant'. Default is 0.0
order : int, optional
The order of interpolation. The order has to be in the range 0-5. See ``apply_transform``.
- `scipy ndimage affine_transform <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.interpolation.affine_transform.html>`_
Examples
---------
>>> x --> [row, col, 1] greyscale
>>> x = rotation(x, rg=40, is_random=False)
>>> tl.visualize.frame(x[:,:,0], second=0.01, saveable=True, name='temp',cmap='gray')
"""
if is_random:
theta = np.pi / 180 * np.random.uniform(-rg, rg)
else:
theta = np.pi /180 * rg
rotation_matrix = np.array([[np.cos(theta), -np.sin(theta), 0],
[np.sin(theta), np.cos(theta), 0],
[0, 0, 1]])
h, w = x.shape[row_index], x.shape[col_index]
transform_matrix = transform_matrix_offset_center(rotation_matrix, h, w)
x = apply_transform(x, transform_matrix, channel_index, fill_mode, cval, order)
return x
def shear(x, intensity=0.1, is_random=False, row_index=0, col_index=1, channel_index=2,
fill_mode='nearest', cval=0., order=1):
"""Shear an image randomly or non-randomly.
Parameters
-----------
x : numpy array
An image with dimension of [row, col, channel] (default).
intensity : float
Percentage of shear, usually -0.5 ~ 0.5 (is_random==True), 0 ~ 0.5 (is_random==False),
you can have a quick try by shear(X, 1).
is_random : boolean, default False
If True, randomly shear.
row_index, col_index, channel_index : int
Index of row, col and channel, default (0, 1, 2), for theano (1, 2, 0).
fill_mode : string
Method to fill missing pixel, default ‘nearest’, more options ‘constant’, ‘reflect’ or ‘wrap’.
- `scipy ndimage affine_transform <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.interpolation.affine_transform.html>`_
cval : scalar, optional
Value used for points outside the boundaries of the input if mode='constant'. Default is 0.0.
order : int, optional
The order of interpolation. The order has to be in the range 0-5. See ``apply_transform``.
- `scipy ndimage affine_transform <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.interpolation.affine_transform.html>`_
References
-----------
- `Affine transformation <https://uk.mathworks.com/discovery/affine-transformation.html>`_
"""
if is_random:
shear = np.random.uniform(-intensity, intensity)
else:
shear = intensity
shear_matrix = np.array([[1, -np.sin(shear), 0],
[0, np.cos(shear), 0],
[0, 0, 1]])
h, w = x.shape[row_index], x.shape[col_index]
transform_matrix = transform_matrix_offset_center(shear_matrix, h, w)
x = apply_transform(x, transform_matrix, channel_index, fill_mode, cval, order)
return x
def shear2(x, shear=(0.1, 0.1), is_random=False, row_index=0, col_index=1, channel_index=2,
fill_mode='nearest', cval=0., order=1):
"""Shear an image randomly or non-randomly.
Parameters
-----------
x : numpy array
An image with dimension of [row, col, channel] (default).
shear : tuple of two floats
Percentage of shear for height and width direction (0, 1).
is_random : boolean, default False
If True, randomly shear.
row_index, col_index, channel_index : int
Index of row, col and channel, default (0, 1, 2), for theano (1, 2, 0).
fill_mode : string
Method to fill missing pixel, default ‘nearest’, more options ‘constant’, ‘reflect’ or ‘wrap’.
- `scipy ndimage affine_transform <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.interpolation.affine_transform.html>`_
cval : scalar, optional
Value used for points outside the boundaries of the input if mode='constant'. Default is 0.0.
order : int, optional
The order of interpolation. The order has to be in the range 0-5. See ``apply_transform``.
- `scipy ndimage affine_transform <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.interpolation.affine_transform.html>`_
References
-----------
- `Affine transformation <https://uk.mathworks.com/discovery/affine-transformation.html>`_
"""
assert len(shear) == 2, "shear should be tuple of 2 floats, or you want to use tl.prepro.shear rather than tl.prepro.shear2 ?"
if is_random:
shear[0] = np.random.uniform(-shear[0], shear[0])
shear[1] = np.random.uniform(-shear[1], shear[1])
shear_matrix = np.array([[1, shear[0], 0],
[shear[1], 1, 0],
[0, 0, 1]])
h, w = x.shape[row_index], x.shape[col_index]
transform_matrix = transform_matrix_offset_center(shear_matrix, h, w)
x = apply_transform(x, transform_matrix, channel_index, fill_mode, cval, order)
return x
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 zoom(x, zoom_range=(0.9, 1.1), is_random=False, row_index=0, col_index=1, channel_index=2,
fill_mode='nearest', cval=0.):
"""Zoom in and out of a single image, randomly or non-randomly.
Parameters
-----------
x : numpy array
An image with dimension of [row, col, channel] (default).
zoom_range : list or tuple
- If is_random=False, (h, w) are the fixed zoom factor for row and column axies, factor small than one is zoom in.
- If is_random=True, (min zoom out, max zoom out) for x and y with different random zoom in/out factor.
e.g (0.5, 1) zoom in 1~2 times.
is_random : boolean, default False
If True, randomly zoom.
row_index, col_index, channel_index : int
Index of row, col and channel, default (0, 1, 2), for theano (1, 2, 0).
fill_mode : string
Method to fill missing pixel, default ‘nearest’, more options ‘constant’, ‘reflect’ or ‘wrap’.
- `scipy ndimage affine_transform <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.interpolation.affine_transform.html>`_
cval : scalar, optional
Value used for points outside the boundaries of the input if mode='constant'. Default is 0.0.
- `scipy ndimage affine_transform <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.interpolation.affine_transform.html>`_
"""
if len(zoom_range) != 2:
raise Exception('zoom_range should be a tuple or list of two floats. '
'Received arg: ', zoom_range)
if is_random:
if zoom_range[0] == 1 and zoom_range[1] == 1:
zx, zy = 1, 1
print(" random_zoom : not zoom in/out")
else:
zx, zy = np.random.uniform(zoom_range[0], zoom_range[1], 2)
else:
zx, zy = zoom_range
# print(zx, zy)
zoom_matrix = np.array([[zx, 0, 0],
[0, zy, 0],
[0, 0, 1]])
h, w = x.shape[row_index], x.shape[col_index]
transform_matrix = transform_matrix_offset_center(zoom_matrix, h, w)
x = apply_transform(x, transform_matrix, channel_index, fill_mode, cval)
return x
def zoom(x, zoom_range=(0.9, 1.1), is_random=False, row_index=0, col_index=1, channel_index=2,
fill_mode='nearest', cval=0.):
"""Zoom in and out of a single image, randomly or non-randomly.
Parameters
-----------
x : numpy array
An image with dimension of [row, col, channel] (default).
zoom_range : list or tuple
- If is_random=False, (h, w) are the fixed zoom factor for row and column axies, factor small than one is zoom in.
- If is_random=True, (min zoom out, max zoom out) for x and y with different random zoom in/out factor.
e.g (0.5, 1) zoom in 1~2 times.
is_random : boolean, default False
If True, randomly zoom.
row_index, col_index, channel_index : int
Index of row, col and channel, default (0, 1, 2), for theano (1, 2, 0).
fill_mode : string
Method to fill missing pixel, default ‘nearest’, more options ‘constant’, ‘reflect’ or ‘wrap’.
- `scipy ndimage affine_transform <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.interpolation.affine_transform.html>`_
cval : scalar, optional
Value used for points outside the boundaries of the input if mode='constant'. Default is 0.0.
- `scipy ndimage affine_transform <https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.ndimage.interpolation.affine_transform.html>`_
"""
if len(zoom_range) != 2:
raise Exception('zoom_range should be a tuple or list of two floats. '
'Received arg: ', zoom_range)
if is_random:
if zoom_range[0] == 1 and zoom_range[1] == 1:
zx, zy = 1, 1
print(" random_zoom : not zoom in/out")
else:
zx, zy = np.random.uniform(zoom_range[0], zoom_range[1], 2)
else:
zx, zy = zoom_range
# print(zx, zy)
zoom_matrix = np.array([[zx, 0, 0],
[0, zy, 0],
[0, 0, 1]])
h, w = x.shape[row_index], x.shape[col_index]
transform_matrix = transform_matrix_offset_center(zoom_matrix, h, w)
x = apply_transform(x, transform_matrix, channel_index, fill_mode, cval)
return x
def main():
parse_args()
if (opt.input_image == '') and (opt.input_dir == ''):
raise Exception('Must give exactly one of -input_image or -input_dir')
checkpoint = load_t7checkpoint(opt.model, custom_layers=custom_layers)
model = checkpoint.model
model.evaluate()
gc.collect()
preprocess_method = checkpoint.opt.preprocessing or 'vgg'
preprocess = methods[preprocess_method]
def run_image(in_path, out_path):
img = imread(in_path)
img = np.array(img, dtype=np.float64)
if opt.image_size > 0:
img = scipy.misc.imresize(img, np.float(opt.image_size)/np.float(np.max(img.shape))) #
#(768, 1153, 3)) # FIXME: IT WORKS ONLY WITH THESE DIMS
import pdb; pdb.set_trace()
img = img.transpose(2, 0, 1)
_, H, W = img.shape
img = img.reshape(1, 3, H, W)
img_pre = preprocess.preprocess(img)
img_out = model.forward(img_pre)
img_out = preprocess.deprocess(img_out)[0]
img_out = img_out.transpose(1, 2, 0)
if opt.median_filter > 0:
img_out = scipy.ndimage.filters.median_filter(
img_out, opt.median_filter)
scipy.misc.imsave(out_path, img_out)
print('Writing output image to ' + out_path)
outdir = os.path.dirname(out_path)
if outdir is not '' and not os.path.exists(outdir):
os.makedirs(outdir)
scipy.misc.imsave(out_path, img_out)
if opt.input_dir != '':
if opt.output_dir == '':
raise Exception('Must give -output_dir with -input_dir')
for fn in os.path.isfile(opt.input_dir):
if is_image_file(fn):
in_path = os.path.concat(opt.input_dir, fn)
out_path = os.path.concat(opt.output_dir, fn)
run_image(in_path, out_path)
elif opt.input_image != '':
if opt.output_image == '':
raise Exception('Must give -output_image with -input_image')
run_image(opt.input_image, opt.output_image)
def renderView(self, camera_pos, light_sources,
blur, blending, spher=True, default_bg_setting=True):
self.setCameraPosition(camera_pos[0],
math.radians(camera_pos[1]),
math.radians(camera_pos[2]))
self.activateLightSources(light_sources, spher)
base.graphicsEngine.renderFrame()
tex = base.win.getScreenshot()
im = self.textureToImage(tex)
if self.generate_depth is True:
depth_im = PNMImage()
self.depth_tex.store(depth_im)
depth_map = np.zeros([self.resolution,
self.resolution], dtype='float')
for i in range(0, self.resolution):
for j in range(0, self.resolution):
depth_val = depth_im.getGray(j, i)
depth_map[i, j] = self.far_plane * self.near_plane /\
(self.far_plane - depth_val *
(self.far_plane - self.near_plane))
depth_map[i, j] = depth_map[i, j] / self.far_plane
dm_uint = np.round(depth_map * self.max_16bit_val).astype('uint16')
if self.replace_background is True and default_bg_setting is True:
mask = (dm_uint == self.max_16bit_val)
temp = np.multiply(
mask.astype(dtype=np.float32).reshape(
self.resolution, self.resolution, 1), im)
im = im - temp
blurred_mask = scipy.ndimage.gaussian_filter(
mask.astype(dtype=np.float32), blending)
inv_mask = (blurred_mask - 1)*(-1)
bg_ind = random.randint(0, len(self.backgrounds)-1)
im = np.multiply(
self.backgrounds[bg_ind],
blurred_mask.reshape(self.resolution, self.resolution, 1)) + \
np.multiply(im, inv_mask.reshape(self.resolution,
self.resolution, 1))
im = scipy.ndimage.gaussian_filter(im, sigma=blur)
im = im.astype(dtype=np.uint8)
self.deactivateLightSources()
return im, dm_uint
