def extract(image,y0,x0,y1,x1,mode='nearest',cval=0):
h,w = image.shape
ch,cw = y1-y0,x1-x0
y,x = clip(y0,0,max(h-ch,0)),clip(x0,0,max(w-cw, 0))
sub = image[y:y+ch,x:x+cw]
# print("extract", image.dtype, image.shape)
try:
r = interpolation.shift(sub,(y-y0,x-x0),mode=mode,cval=cval,order=0)
if cw > w or ch > h:
pady0, padx0 = max(-y0, 0), max(-x0, 0)
r = interpolation.affine_transform(r, eye(2), offset=(pady0, padx0), cval=1, output_shape=(ch, cw))
return r
except RuntimeError:
# workaround for platform differences between 32bit and 64bit
# scipy.ndimage
dtype = sub.dtype
sub = array(sub,dtype='float64')
sub = interpolation.shift(sub,(y-y0,x-x0),mode=mode,cval=cval,order=0)
sub = array(sub,dtype=dtype)
return sub
python类shift()的实例源码
def apply(self, im):
"""
Apply axis-localized displacements.
Parameters
----------
im : ndarray
The image or volume to shift
"""
from scipy.ndimage.interpolation import shift
im = rollaxis(im, self.axis)
im.setflags(write=True)
for ind in range(0, im.shape[0]):
im[ind] = shift(im[ind], map(lambda x: -x, self.delta[ind]), mode='nearest')
im = rollaxis(im, 0, self.axis+1)
return im
def drop_shadow(self, alpha, theta, shift, size, op=0.80):
"""
alpha : alpha layer whose shadow need to be cast
theta : [0,2pi] -- the shadow direction
shift : shift in pixels of the shadow
size : size of the GaussianBlur filter
op : opacity of the shadow (multiplying factor)
@return : alpha of the shadow layer
(it is assumed that the color is black/white)
"""
if size%2==0:
size -= 1
size = max(1,size)
shadow = cv.GaussianBlur(alpha,(size,size),0)
[dx,dy] = shift * np.array([-np.sin(theta), np.cos(theta)])
shadow = op*sii.shift(shadow, shift=[dx,dy],mode='constant',cval=0)
return shadow.astype('uint8')
def extract(image,y0,x0,y1,x1,mode='nearest',cval=0):
h,w = image.shape
ch,cw = y1-y0,x1-x0
y,x = clip(y0,0,max(h-ch,0)),clip(x0,0,max(w-cw, 0))
sub = image[y:y+ch,x:x+cw]
# print("extract", image.dtype, image.shape)
try:
r = interpolation.shift(sub,(y-y0,x-x0),mode=mode,cval=cval,order=0)
if cw > w or ch > h:
pady0, padx0 = max(-y0, 0), max(-x0, 0)
r = interpolation.affine_transform(r, eye(2), offset=(pady0, padx0), cval=1, output_shape=(ch, cw))
return r
except RuntimeError:
# workaround for platform differences between 32bit and 64bit
# scipy.ndimage
dtype = sub.dtype
sub = array(sub,dtype='float64')
sub = interpolation.shift(sub,(y-y0,x-x0),mode=mode,cval=cval,order=0)
sub = array(sub,dtype=dtype)
return sub
def extract(image,y0,x0,y1,x1,mode='nearest',cval=0):
h,w = image.shape
ch,cw = y1-y0,x1-x0
y,x = clip(y0,0,max(h-ch,0)),clip(x0,0,max(w-cw, 0))
sub = image[y:y+ch,x:x+cw]
# print("extract", image.dtype, image.shape)
try:
r = interpolation.shift(sub,(y-y0,x-x0),mode=mode,cval=cval,order=0)
if cw > w or ch > h:
pady0, padx0 = max(-y0, 0), max(-x0, 0)
r = interpolation.affine_transform(r, eye(2), offset=(pady0, padx0), cval=1, output_shape=(ch, cw))
return r
except RuntimeError:
# workaround for platform differences between 32bit and 64bit
# scipy.ndimage
dtype = sub.dtype
sub = array(sub,dtype='float64')
sub = interpolation.shift(sub,(y-y0,x-x0),mode=mode,cval=cval,order=0)
sub = array(sub,dtype=dtype)
return sub
def random_track_shift(track, out=None, shift_delta='auto'):
if out is None:
out = np.ndarray(shape=track.shape, dtype=track.dtype)
if shift_delta == 'auto':
track_x, track_y = np.where(track > 0)
x_from, x_to = np.min(track_x), np.max(track_x)
y_from, y_to = np.min(track_y), np.max(track_y)
x_delta = np.random.randint(-x_from, out.shape[0] - x_to)
y_delta = np.random.randint(-y_from, out.shape[1] - y_to)
out = np.roll(track, x_delta, axis=0)
out = np.roll(out, y_delta, axis=1)
return out
else:
delta = np.random.uniform(-1.0, 1.0, size=2) * shift_delta
return shift(track, delta, output=out, order=0, prefilter=False)
def draw_ellipse(shape, radius, center, FWHM, noise=0):
sigma = FWHM / 2.35482
cutoff = 2 * FWHM
# draw a circle
R = max(radius)
zoom_factor = np.array(radius) / R
size = int((R + cutoff)*2)
c = size // 2
y, x = np.meshgrid(*([np.arange(size)] * 2), indexing='ij')
h = np.sqrt((y - c)**2+(x - c)**2) - R
mask = np.abs(h) < cutoff
im = np.zeros((size,)*2, dtype=np.float)
im[mask] += np.exp((h[mask] / sigma)**2/-2)/(sigma*np.sqrt(2*np.pi))
# zoom so that radii are ok
with warnings.catch_warnings():
warnings.simplefilter("ignore")
im = zoom(im, zoom_factor)
# shift and make correct shape
center_diff = center - np.array(center_of_mass(im))
left_padding = np.round(center_diff).astype(np.int)
subpx_shift = center_diff - left_padding
im = shift(im, subpx_shift)
im = crop_pad(im, -left_padding, shape)
im[im < 0] = 0
assert_almost_equal(center_of_mass(im), center, decimal=2)
if noise > 0:
im += np.random.random(shape) * noise * im.max()
return (im / im.max() * 255).astype(np.uint8)
def draw_ellipsoid(shape, radius, center, FWHM, noise=0):
sigma = FWHM / 2.35482
cutoff = 2 * FWHM
# draw a sphere
R = max(radius)
zoom_factor = np.array(radius) / R
size = int((R + cutoff)*2)
c = size // 2
z, y, x = np.meshgrid(*([np.arange(size)] * 3), indexing='ij')
h = np.sqrt((z - c)**2+(y - c)**2+(x - c)**2) - R
mask = np.abs(h) < cutoff
im = np.zeros((size,)*3, dtype=np.float)
im[mask] += np.exp((h[mask] / sigma)**2/-2)/(sigma*np.sqrt(2*np.pi))
# zoom so that radii are ok
with warnings.catch_warnings():
warnings.simplefilter("ignore")
im = zoom(im, zoom_factor)
# shift and make correct shape
center_diff = center - np.array(center_of_mass(im))
left_padding = np.round(center_diff).astype(np.int)
subpx_shift = center_diff - left_padding
im = shift(im, subpx_shift)
im = crop_pad(im, -left_padding, shape)
im[im < 0] = 0
assert_almost_equal(center_of_mass(im), center, decimal=2)
if noise > 0:
im += np.random.random(shape) * noise * im.max()
return (im / im.max() * 255).astype(np.uint8)
def test_fit(eng):
reference = arange(25).reshape(5, 5)
algorithm = CrossCorr()
deltas = [[1, 2], [-2, 1]]
shifted = [shift(reference, delta, mode='wrap', order=0) for delta in deltas]
model = algorithm.fit(shifted, reference=reference)
assert allclose(model.toarray(), deltas)
def test_fit_3d(eng):
reference = arange(125).reshape(5, 5, 5)
algorithm = CrossCorr()
deltas = [[1, 0, 2], [0, 1, 2]]
shifted = [shift(reference, delta, mode='wrap', order=0) for delta in deltas]
model = algorithm.fit(shifted, reference=reference)
assert allclose(model.toarray(), deltas)
def test_fit_axis(eng):
reference = arange(60).reshape(2, 5, 6)
algorithm = CrossCorr(axis=0)
a = shift(reference[0], [1, 2], mode='wrap', order=0)
b = shift(reference[1], [-2, 1], mode='wrap', order=0)
c = shift(reference[0], [2, 1], mode='wrap', order=0)
d = shift(reference[1], [1, -2], mode='wrap', order=0)
shifted = [asarray([a, b]), asarray([c, d]),]
model = algorithm.fit(shifted, reference=reference)
assert allclose(model.toarray(), [[[1, 2], [-2, 1]], [[2, 1], [1, -2]]])
def apply(self, im):
"""
Apply an n-dimensional displacement by shifting an image or volume.
Parameters
----------
im : ndarray
The image or volume to shift
"""
from scipy.ndimage.interpolation import shift
return shift(im, map(lambda x: -x, self.delta), mode='nearest')
def testtime_augmentation(image, label):
labels = []
images = []
rotations = [0]
flips = [[0,0],[1,0],[0,1],[1,1]]
shifts = [[0,0]]
zooms = [1]
for r in rotations:
for f in flips:
for s in shifts:
for z in zooms:
image2 = np.array(image)
if f[0]:
image2[:,:] = image2[::-1,:]
if f[1]:
image2 = image2.transpose(1,0)
image2[:,:] = image2[::-1,:]
image2 = image2.transpose(1,0)
#rotate(image2, r, reshape=False, output=image2)
#image3 = zoom(image2, [z,z])
#image3 = crop_or_pad(image3, P.INPUT_SIZE, 0)
#image2 = image3
# #shift(image2, [s[0],s[1]], output=image2)
images.append([image2]) #Adds color channel dimension!
labels.append(label)
return images, labels
def augment_multi(images,random_flip_x,shift_x,shift_y,rotation_degrees,zoom_factor):
pixels = images[0].shape[2]
center = pixels/2.-0.5
for i in range(len(images)):
image = images[i]
if random_flip_x:
print "flipping image"
#image[:,:] = image[:,::-1]
image[:,:,:] = image[:,:,::-1] #original
print image.shape
if rotation_degrees != 0:
print "rotating images"
if i == 0: #lung
image = rotate(image, rotation_degrees, axes=(1,2), reshape=False,cval=-3000,order=0)
else:
image = rotate(image, rotation_degrees, axes=(1,2), reshape=False,order=0)
print "post rotate ",image.shape
image = crop_or_pad_multi(image, pixels, -3000)
print image.shape
if shift_x != 0 or shift_y != 0:
print "shifting images by ",shift_x,shift_y, image.shape
if i == 0:
image = shift(image, [0,shift_x,shift_y],order=0,cval=-3000)
else:
image = shift(image, [0,shift_x,shift_y],order=0)
images[i] = image
return images
def testtime_augmentation(image, label):
labels = []
images = []
rotations = [0]
flips = [[0,0],[1,0],[0,1],[1,1]]
shifts = [[0,0]]
zooms = [1]
for r in rotations:
for f in flips:
for s in shifts:
for z in zooms:
image2 = np.array(image)
if f[0]:
image2[:,:] = image2[::-1,:]
if f[1]:
image2 = image2.transpose(1,0)
image2[:,:] = image2[::-1,:]
image2 = image2.transpose(1,0)
#rotate(image2, r, reshape=False, output=image2)
#image3 = zoom(image2, [z,z])
#image3 = crop_or_pad(image3, P.INPUT_SIZE, 0)
#image2 = image3
# #shift(image2, [s[0],s[1]], output=image2)
images.append([image2]) #Adds color channel dimension!
labels.append(label)
return images, labels
def center_tracks(tracks, out=None):
c = np.array(tracks.shape[1:], dtype='int') / 2
if out is None:
out = np.ndarray(shape=tracks.shape, dtype=tracks.dtype)
for i in xrange(tracks.shape[0]):
cm = np.array(center_of_mass(tracks[i, :, :]), dtype='int32')
out[i, :, :] = shift(tracks[i, :, :], c - cm)
return out
def augment(images):
pixels = images[0].shape[1]
center = pixels/2.-0.5
random_flip_x = P.AUGMENTATION_PARAMS['flip'] and np.random.randint(2) == 1
random_flip_y = P.AUGMENTATION_PARAMS['flip'] and np.random.randint(2) == 1
# Translation shift
shift_x = np.random.uniform(*P.AUGMENTATION_PARAMS['translation_range'])
shift_y = np.random.uniform(*P.AUGMENTATION_PARAMS['translation_range'])
rotation_degrees = np.random.uniform(*P.AUGMENTATION_PARAMS['rotation_range'])
zoom_factor = np.random.uniform(*P.AUGMENTATION_PARAMS['zoom_range'])
#zoom_factor = 1 + (zoom_f/2-zoom_f*np.random.random())
if CV2_AVAILABLE:
M = cv2.getRotationMatrix2D((center, center), rotation_degrees, zoom_factor)
M[0, 2] += shift_x
M[1, 2] += shift_y
for i in range(len(images)):
image = images[i]
if CV2_AVAILABLE:
#image = image.transpose(1,2,0)
image = cv2.warpAffine(image, M, (pixels, pixels))
if random_flip_x:
image = cv2.flip(image, 0)
if random_flip_y:
image = cv2.flip(image, 1)
#image = image.transpose(2,0,1)
images[i] = image
else:
if random_flip_x:
#image = image.transpose(1,0)
image[:,:] = image[::-1,:]
#image = image.transpose(1,0)
if random_flip_y:
image = image.transpose(1,0)
image[:,:] = image[::-1,:]
image = image.transpose(1,0)
rotate(image, rotation_degrees, reshape=False, output=image)
#image2 = zoom(image, [zoom_factor,zoom_factor])
image2 = crop_or_pad(image, pixels, -3000)
shift(image2, [shift_x,shift_y], output=image)
#affine_transform(image, np.array([[zoom_x,0], [0,zoom_x]]), output=image)
#z = AffineTransform(scale=(2,2))
#image = warp(image, z.params)
images[i] = image
return images
def recenter(self, centroid_method="2dg"):
"""
This function ...
:return:
"""
center_x = 0.5 * (self.xsize - 1)
center_y = 0.5 * (self.ysize - 1)
if centroid_method == "com": x_centroid, y_centroid = self.centroid_com()
elif centroid_method == "fit": x_centroid, y_centroid = self.centroid_fit()
elif centroid_method == "2dg": x_centroid, y_centroid = self.centroid_2dg()
elif centroid_method == "aniano": x_centroid, y_centroid = self.get_maximum_aniano()
else: raise ValueError("Invalid centroid method")
# Debugging
log.debug("The centroid coordinate of the kernel was found to be " + str(x_centroid) + ", " + str(y_centroid))
log.debug("The center of the kernel image is " + str(center_x) + ", " + str(center_y))
# Calculate shift
shift_x = center_x - x_centroid
shift_y = center_y - y_centroid
# If the shift is less than 0.2 pixel, don't shift
if shift_x < 0.2 and shift_y <= 0.2:
log.debug("Kernel is already perfectly aligned with the center: skipping recentering ...")
return
# Debugging
log.debug("Shifting the kernel center by (" + str(shift_x) + ", " + str(shift_y) + " pixels ...")
# Shift
self._data = shift(self._data, [shift_x, shift_y])
# CHECK AGAIN
if centroid_method == "com": x_centroid, y_centroid = self.centroid_com()
elif centroid_method == "fit": x_centroid, y_centroid = self.centroid_fit()
elif centroid_method == "2dg": x_centroid, y_centroid = self.centroid_2dg()
elif centroid_method == "aniano": x_centroid, y_centroid = self.get_maximum_aniano()
else: raise ValueError("Invalid centroid method")
new_shift_x = center_x - x_centroid
new_shift_y = center_y - y_centroid
new_shift_x_relative = abs(new_shift_x) / abs(shift_x)
new_shift_y_relative = abs(new_shift_y) / abs(shift_y)
#print("new shift x relative " + str(new_shift_x_relative))
#print("new shift y relative " + str(new_shift_y_relative))
if new_shift_x_relative >= 0.1: raise RuntimeError("The recentering of the kernel failed: new x shift = " + str(new_shift_x) + ", previous x shift = " + str(shift_x))
if new_shift_y_relative >= 0.1: raise RuntimeError("The recentering of the kernel failed: new y shift = " + str(new_shift_y) + ", previous y shift = " + str(shift_y))
# -----------------------------------------------------------------
def center_aniano(self):
"""
This function ...
:return:
"""
# Debugging
log.debug("Centering the kernel ...")
# FROM CONVOLVE_IMAGE.PRO (G. Aniano)
center_x = int(0.5 * (self.xsize - 1))
center_y = int(0.5 * (self.ysize - 1))
# get_maximun,image,x_max,y_max
x_max, y_max = self.get_maximum()
# ; determine the needed shifts
shift_x = center_x - x_max
shift_y = center_y - y_max
# ; make the shift if nonzero
if (shift_x != 0) or (shift_y != 0):
# Debugging
log.debug("Shifting the kernel center by (" + str(shift_x) + ", " + str(shift_y) + " pixels ...")
self._data = shift(self._data, [shift_x,shift_y])
# Y
self._data[:abs(shift_y),:] = 0.0
self._data[self.ysize-1-abs(shift_y):self.ysize,:] = 0.0
# X
self._data[:,:abs(shift_x)] = 0.0
self._data[:,self.xsize-1-abs(shift_x):] = 0.0
# CHECK
# Calculate shift again
x_max, y_max = self.get_maximum()
new_shift_x = center_x - x_max
new_shift_y = center_y - y_max
# Raise exception if there is still a shift
if (new_shift_x != 0) or (new_shift_y != 0): raise RuntimeError("Something went wrong during the kernel centering: "
"new shift x = " + str(new_shift_x) + ", new shift y = "
+ str(new_shift_y) + " (previous shift x = " + str(shift_x)
+ ", previous shift y = " + str(shift_y))
# -----------------------------------------------------------------
def get_maximum_aniano(self):
"""
This function ...
:return:
"""
rad_to_mean = 5
data_copy = self._data.copy()
#
mean_im = data_copy * 0.0
i_range = range(-int(rad_to_mean), int(rad_to_mean)+1)
#print("irange", i_range)
for i in i_range:
j_range = range(-int(math.sqrt(rad_to_mean ** 2 - i ** 2)), int(math.sqrt(rad_to_mean ** 2 - i ** 2))+1)
#print("jrange", j_range)
for j in j_range:
mean_im += shift(data_copy, [i, j])
mean_im_sum = np.sum(mean_im)
#mx = max(mean_im, location)
#index = ARRAY_INDICES(mean_im, location)
#x_max = index[0]
#y_max = index[1]
# Get x and y max
max_index = np.argmax(mean_im)
c = (max_index // len(mean_im[0]), max_index % len(mean_im[0]))
x_max = c[1]
y_max = c[0]
max_value = mean_im[y_max, x_max]
where = np.abs(mean_im - max_value) < (5e-4 * mean_im_sum)
count = np.sum(where)
if count > 1:
log.debug("WARNING: The PSF has " + str(count) + "pixels with values similar to its maximum... we will take their centroid...")
xsize = data_copy.shape[1]
ysize = data_copy.shape[0]
xv, yv = np.meshgrid(np.arange(xsize), np.arange(ysize))
# Average x max
x_max = np.sum(xv[where]) / float(count)
# Average y max
y_max = np.sum(xv[where]) / float(count)
# Return xmax and ymax position
return x_max, y_max
# -----------------------------------------------------------------
def recenter(self, centroid_method="2dg"):
"""
This function ...
:return:
"""
center_x = 0.5 * (self.xsize - 1)
center_y = 0.5 * (self.ysize - 1)
if centroid_method == "com": x_centroid, y_centroid = self.centroid_com()
elif centroid_method == "fit": x_centroid, y_centroid = self.centroid_fit()
elif centroid_method == "2dg": x_centroid, y_centroid = self.centroid_2dg()
elif centroid_method == "aniano": x_centroid, y_centroid = self.get_maximum_aniano()
else: raise ValueError("Invalid centroid method")
# Debugging
log.debug("The centroid coordinate of the kernel was found to be " + str(x_centroid) + ", " + str(y_centroid))
log.debug("The center of the kernel image is " + str(center_x) + ", " + str(center_y))
# Calculate shift
shift_x = center_x - x_centroid
shift_y = center_y - y_centroid
# If the shift is less than 0.2 pixel, don't shift
if shift_x < 0.2 and shift_y <= 0.2:
log.debug("Kernel is already perfectly aligned with the center: skipping recentering ...")
return
# Debugging
log.debug("Shifting the kernel center by (" + str(shift_x) + ", " + str(shift_y) + " pixels ...")
# Shift
self._data = shift(self._data, [shift_x, shift_y])
# CHECK AGAIN
if centroid_method == "com": x_centroid, y_centroid = self.centroid_com()
elif centroid_method == "fit": x_centroid, y_centroid = self.centroid_fit()
elif centroid_method == "2dg": x_centroid, y_centroid = self.centroid_2dg()
elif centroid_method == "aniano": x_centroid, y_centroid = self.get_maximum_aniano()
else: raise ValueError("Invalid centroid method")
new_shift_x = center_x - x_centroid
new_shift_y = center_y - y_centroid
new_shift_x_relative = abs(new_shift_x) / abs(shift_x)
new_shift_y_relative = abs(new_shift_y) / abs(shift_y)
#print("new shift x relative " + str(new_shift_x_relative))
#print("new shift y relative " + str(new_shift_y_relative))
if new_shift_x_relative >= 0.1: raise RuntimeError("The recentering of the kernel failed: new x shift = " + str(new_shift_x) + ", previous x shift = " + str(shift_x))
if new_shift_y_relative >= 0.1: raise RuntimeError("The recentering of the kernel failed: new y shift = " + str(new_shift_y) + ", previous y shift = " + str(shift_y))
# -----------------------------------------------------------------
def center_aniano(self):
"""
This function ...
:return:
"""
# Debugging
log.debug("Centering the kernel ...")
# FROM CONVOLVE_IMAGE.PRO (G. Aniano)
center_x = int(0.5 * (self.xsize - 1))
center_y = int(0.5 * (self.ysize - 1))
# get_maximun,image,x_max,y_max
x_max, y_max = self.get_maximum()
# ; determine the needed shifts
shift_x = center_x - x_max
shift_y = center_y - y_max
# ; make the shift if nonzero
if (shift_x != 0) or (shift_y != 0):
# Debugging
log.debug("Shifting the kernel center by (" + str(shift_x) + ", " + str(shift_y) + " pixels ...")
self._data = shift(self._data, [shift_x,shift_y])
# Y
self._data[:abs(shift_y),:] = 0.0
self._data[self.ysize-1-abs(shift_y):self.ysize,:] = 0.0
# X
self._data[:,:abs(shift_x)] = 0.0
self._data[:,self.xsize-1-abs(shift_x):] = 0.0
# CHECK
# Calculate shift again
x_max, y_max = self.get_maximum()
new_shift_x = center_x - x_max
new_shift_y = center_y - y_max
# Raise exception if there is still a shift
if (new_shift_x != 0) or (new_shift_y != 0): raise RuntimeError("Something went wrong during the kernel centering: "
"new shift x = " + str(new_shift_x) + ", new shift y = "
+ str(new_shift_y) + " (previous shift x = " + str(shift_x)
+ ", previous shift y = " + str(shift_y))
# -----------------------------------------------------------------
def augment(images):
pixels = images[0].shape[1]
center = pixels/2.-0.5
random_flip_x = P.AUGMENTATION_PARAMS['flip'] and np.random.randint(2) == 1
random_flip_y = P.AUGMENTATION_PARAMS['flip'] and np.random.randint(2) == 1
# Translation shift
shift_x = np.random.uniform(*P.AUGMENTATION_PARAMS['translation_range'])
shift_y = np.random.uniform(*P.AUGMENTATION_PARAMS['translation_range'])
rotation_degrees = np.random.uniform(*P.AUGMENTATION_PARAMS['rotation_range'])
zoom_factor = np.random.uniform(*P.AUGMENTATION_PARAMS['zoom_range'])
#zoom_factor = 1 + (zoom_f/2-zoom_f*np.random.random())
if CV2_AVAILABLE:
M = cv2.getRotationMatrix2D((center, center), rotation_degrees, zoom_factor)
M[0, 2] += shift_x
M[1, 2] += shift_y
for i in range(len(images)):
image = images[i]
if CV2_AVAILABLE:
#image = image.transpose(1,2,0)
image = cv2.warpAffine(image, M, (pixels, pixels))
if random_flip_x:
image = cv2.flip(image, 0)
if random_flip_y:
image = cv2.flip(image, 1)
#image = image.transpose(2,0,1)
images[i] = image
else:
if random_flip_x:
#image = image.transpose(1,0)
image[:,:] = image[::-1,:]
#image = image.transpose(1,0)
if random_flip_y:
image = image.transpose(1,0)
image[:,:] = image[::-1,:]
image = image.transpose(1,0)
rotate(image, rotation_degrees, reshape=False, output=image)
#image2 = zoom(image, [zoom_factor,zoom_factor])
image2 = crop_or_pad(image, pixels, -3000)
shift(image2, [shift_x,shift_y], output=image)
#affine_transform(image, np.array([[zoom_x,0], [0,zoom_x]]), output=image)
#z = AffineTransform(scale=(2,2))
#image = warp(image, z.params)
images[i] = image
return images
