The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can also save this page to your account.
Example 1
def inner_extract(self,B,signature):
w,h =B.shape[:2]
LL,(HL,LH,HH) = pywt.dwt2(B[:32*(w//32),:32*(h//32)],'haar')
LL_1,(HL_1,LH_1,HH_1) = pywt.dwt2(LL,'haar')
LL_2,(HL_2,LH_2,HH_2) = pywt.dwt2(LL_1,'haar')
LL_3,(HL_3,LH_3,HH_3) = pywt.dwt2(LL_2,'haar')
LL_4,(HL_4,LH_4,HH_4) = pywt.dwt2(LL_3,'haar')
_,_,_,ori_sig = self._gene_embed_space(HH_3)
ext_sigs=[]
ext_sigs.extend(self._extract_sig(ori_sig,len(signature)))
ext_sigs.extend(self._extract_sig(np.rot90(ori_sig,1),len(signature)))
ext_sigs.extend(self._extract_sig(np.rot90(ori_sig,2),len(signature)))
ext_sigs.extend(self._extract_sig(np.rot90(ori_sig,3),len(signature)))
return ext_sigs Example 2
def mk_rotations(img):
#
# DESCRIPTION
# This function create 8 roatation image fro an input image 4 rotation from the raw image and 4 rotation form the transposed
#
# INPUTS
# img np.array
#
# OUTPUTS
# rotated_image_img, img90, img180, img270, imgT, imgT90, imgT180,imgT270
#
#
img90 = np.rot90(img)
img180 = np.rot90(img,k=2)
img270 = np.rot90(img,k=3)
imgT = np.zeros(img.shape)
if np.size(img.shape)>2:
for i in range(3):
imgT[:,:,i] =img[:,:,i].T
else:
imgT = img.T
imgT90 = np.rot90(imgT)
imgT180 = np.rot90(imgT, k=2)
imgT270 = np.rot90(imgT, k=3)
return img, img90, img180, img270, imgT, imgT90, imgT180,imgT270 Example 3
def unrotate(rot0, rot1, rot2, rot3, rot4, rot5, rot6, rot7):
#
# DESCRIPTION
# Functions that merges the 8 mapped images as described in the beginning of the file back to the original format
# Uses element wise product
#
#
unrot = np.copy(rot0)
unrot*=np.rot90((rot1),k=3)
unrot*=np.rot90((rot2),k=2)
unrot*=np.rot90((rot3),k=1)
unrot*=(rot4.T)
unrot*=np.rot90((rot5),k=3).T
unrot*=np.rot90((rot6),k=2).T
unrot*=np.rot90((rot7),k=1).T
return unrot
## ##
## ##
## EXECUTION ##
## ##
## ## Example 4
def mk_rotations(img):
##INPUT:
## img: a 3D RGB array
##OUTPUT
## 8 rotated and transposed versions of img
img90 = np.rot90(img)
img180 = np.rot90(img,k=2)
img270 = np.rot90(img,k=3)
imgT = np.zeros(img.shape)
if np.size(img.shape)>2:
for i in range(3):
imgT[:,:,i] =img[:,:,i].T
else:
imgT = img.T
imgT90 = np.rot90(imgT)
imgT180 = np.rot90(imgT, k=2)
imgT270 = np.rot90(imgT, k=3)
return img, img90, img180, img270, imgT, imgT90, imgT180,imgT270
## Formats an image to save format Example 5
def saveImage(inputImage, name):
# red = inputImage[:1024]
# green = inputImage[1024:2048]
# blue = inputImage[2048:]
# formatted = np.zeros([3,32,32])
# formatted[0] = np.reshape(red,[32,32])
# formatted[1] = np.reshape(green,[32,32])
# formatted[2] = np.reshape(blue,[32,32])
# final = np.swapaxes(formatted,0,2)/255
final = inputImage
final = np.rot90(np.rot90(np.rot90(final)))
imsave(name, final) Example 6
def getMagSpec(sig, rate, winlen, winstep, NFFT):
#get frames
winfunc = lambda x:np.ones((x,))
frames = psf.sigproc.framesig(sig, winlen*rate, winstep*rate, winfunc)
#Magnitude Spectrogram
magspec = np.rot90(psf.sigproc.magspec(frames, NFFT))
return magspec
#Split signal into five-second chunks with overlap of 4 and minimum length of 3 seconds
#Use these settings for other chunk lengths:
#winlen, winstep, seconds
#0.05, 0.0097, 5s
#0.05, 0.0195, 10s
#0.05, 0.0585, 30s Example 7
def getMagSpec(sig, rate, winlen, winstep, NFFT):
#get frames
winfunc = lambda x:np.ones((x,))
frames = psf.sigproc.framesig(sig, winlen*rate, winstep*rate, winfunc)
#Magnitude Spectrogram
magspec = np.rot90(psf.sigproc.magspec(frames, NFFT))
return magspec
#Split signal into five-second chunks with overlap of 4 and minimum length of 1 second
#Use these settings for other chunk lengths:
#winlen, winstep, seconds
#0.05, 0.0097, 5s
#0.05, 0.0195, 10s
#0.05, 0.0585, 30s Example 8
def test_discrete_phantom_uniform():
"""The uniform discrete phantom is the same after rotating 90 degrees."""
d0 = discrete_phantom(p, 100, ratio=10, prop='mass_atten')
p.rotate(theta=np.pi/2, point=Point([0.5, 0.5]))
d1 = np.rot90(discrete_phantom(p, 100, ratio=10, prop='mass_atten'))
# plot rotated phantom
plot_phantom(p)
# plot the error
plt.figure()
plt.imshow(d1-d0, interpolation=None)
plt.colorbar()
# plt.show(block=True)
# assert_allclose(d0, d1) Example 9
def load_dotted_image(self, train_id, scale=1, border=0, circled=False):
img = self._load_image('dotted', train_id, scale, border)
if train_id in self.extra_masks:
for row, col, radius in self.extra_masks[train_id]:
rr, cc = skimage.draw.circle(row, col, radius, shape = img.shape)
img = np.copy(img)
img[rr, cc] = (0, 0, 0)
# When dotted image is rotated relative to train, apply hot patch. (kudos: @authman)
if train_id in self.dotted_rotate:
rot = self.dotted_rotate[train_id]
img = np.rot90(img, rot)
if circled:
assert scale == 1
assert border == 0
img = np.copy(img)
img = self.draw_circles(np.copy(img), self.tid_coords[train_id])
return img Example 10
def get_lateral(self, resolution=0.5):
if hasattr(self, "lateral") and resolution == resolution:
return self.lateral
max_dist = self.get_max_dist()
dim = np.ceil(np.absolute(max_dist / resolution))
max_dist = dim * resolution
self.resolution = resolution
a = np.meshgrid(np.linspace(0, max_dist, dim), np.linspace(0, max_dist, dim))
r = (a[0]**2 + a[1]**2)**0.5
sigma = self.sigma / ((8 * log(2))**0.5)
lateral = 1 / ((2 * pi * sigma**2)**0.5) * np.exp(-(r**2) / (2 * sigma**2))
tot_lat = np.zeros((2 * dim - 1, 2 * dim - 1))
tot_lat[dim - 1:2 * dim - 1, dim - 1:2 * dim - 1] = lateral
tot_lat[dim - 1:2 * dim - 1, 0:dim - 1] = np.rot90(lateral, 3)[:, 0:dim - 1]
tot_lat[0:dim - 1, 0:dim - 1] = np.rot90(lateral, 2)[0:dim - 1, 0:dim - 1]
tot_lat[0:dim - 1, dim - 1:2 * dim - 1] = np.rot90(lateral)[0:dim - 1, :]
self.lateral = tot_lat
return self.lateral Example 11
def _apply_transformations(plot_config, data_slice):
"""Rotate, flip and zoom the data slice.
Depending on the plot configuration, this will apply some transformations to the given data slice.
Args:
plot_config (mdt.visualization.maps.base.MapPlotConfig): the plot configuration
data_slice (ndarray): the 2d slice of data to transform
Returns:
ndarray: the transformed 2d slice of data
"""
if plot_config.rotate:
data_slice = np.rot90(data_slice, plot_config.rotate // 90)
if not plot_config.flipud:
# by default we flipud to correct for matplotlib lower origin. If the user
# sets flipud, we do not need to to it
data_slice = np.flipud(data_slice)
data_slice = plot_config.zoom.apply(data_slice)
return data_slice Example 12
def _augment_chunks(self, chunks):
if self.choices_augmentation is None:
return chunks
chunks_new = []
choice = np.random.choice(self.choices_augmentation)
for chunk in chunks:
chunk_new = chunk
if choice in [1, 3, 5, 7]:
chunk_new = np.flip(chunk_new, axis=1)
if choice in [2, 3]:
chunk_new = np.rot90(chunk_new, 1, axes=(1, 2))
elif choice in [4, 5]:
chunk_new = np.rot90(chunk_new, 2, axes=(1, 2))
elif choice in [6, 7]:
chunk_new = np.rot90(chunk_new, 3, axes=(1, 2))
chunks_new.append(chunk_new)
return chunks_new Example 13
def random_augment_image(image, row):
# start0_max, end0_max, start1_max, end1_max = get_bounding_boxes_positions(image, row)
# image = cv2.rectangle(image, (int(start1_max), int(start0_max)), (int(end1_max), int(end0_max)), (0, 0, 255), thickness=5)
if random.randint(0, 1) == 0:
image = return_random_crop(image, row)
else:
image = return_random_perspective(image, row)
image = random_rotate(image)
# all possible mirroring and flips (in total there are only 8 possible configurations)
mirror = random.randint(0, 1)
if mirror != 0:
image = image[::-1, :, :]
angle = random.randint(0, 3)
if angle != 0:
image = np.rot90(image, k=angle)
image = lightning_change(image)
image = blur_image(image)
return image Example 14
def rot(self): for i in range(len(self.Q)): Q = self.Q[i] ans = self.ans[i] refArea = self.area[i] refMask = self.mask[i] for rotate in range(3): self.Q.append(Q) self.ans.append(ans) refArea = np.rot90(refArea) refMask = np.rot90(refMask) self.area.append(refArea) self.mask.append(refMask) return self
Example 15
def rot90(img):
'''
rotate one or multiple grayscale or color images 90 degrees
'''
s = img.shape
if len(s) == 3:
if s[2] in (3, 4): # color image
out = np.empty((s[1], s[0], s[2]), dtype=img.dtype)
for i in range(s[2]):
out[:, :, i] = np.rot90(img[:, :, i])
else: # mutliple grayscale
out = np.empty((s[0], s[2], s[1]), dtype=img.dtype)
for i in range(s[0]):
out[i] = np.rot90(img[i])
elif len(s) == 2: # one grayscale
out = np.rot90(img)
elif len(s) == 4 and s[3] in (3, 4): # multiple color
out = np.empty((s[0], s[2], s[1], s[3]), dtype=img.dtype)
for i in range(s[0]): # for each img
for j in range(s[3]): # for each channel
out[i, :, :, j] = np.rot90(img[i, :, :, j])
else:
NotImplemented
return out Example 16
def shot_heatmap(df,sigma = 1,log=False,player_pic=True,ax=None,cmap='jet'):
'''
This function plots a heatmap based on the shot chart.
input - dataframe with x and y coordinates.
optional - log (default false) plots heatmap in log scale.
player (default true) adds player's picture and name if true
sigma - the sigma of the Gaussian kernel. In feet (default=1)
'''
n,_,_ = np.histogram2d( 0.1*df['LOC_X'].values, 0.1*df['LOC_Y'].values,bins = [500, 500],range = [[-25,25],[-5.25,44.75]])
KDE = ndimage.filters.gaussian_filter(n,10.0*sigma)
N = 1.0*KDE/np.sum(KDE)
if ax is None:
ax = plt.gca(xlim = [30,-30],ylim = [-7,43],xticks=[],yticks=[],aspect=1.0)
court(ax,outer_lines=True,color='black',lw=2.0,direction='down')
ax.axis('off')
if log:
ax.imshow(np.rot90(np.log10(N+1)),cmap=cmap,extent=[25.0, -25.0, -5.25, 44.75])
else:
ax.imshow(np.rot90(N),cmap=cmap,extent=[25.0, -25.0, -5.25, 44.75])
if player_pic:
player_id = df.PLAYER_ID.values[0]
pic = players_picture(player_id)
ax.imshow(pic,extent=[15,25,30,37.8261])
ax.text(0,-7,'By: Doingthedishes',color='white',horizontalalignment='center',fontsize=20,fontweight='bold') Example 17
def rot90(self, turns=1):
"""
Rotates the blocks in the counter-clockwise direction. (As numpy
does it.)
"""
# Rotate the individual Y-layer matrices
new_blocks = np.array([np.rot90(by, turns) for by in self.blocks])
new_data = np.array([np.rot90(dy, turns) for dy in self.data])
new_mask = np.array([np.rot90(my, turns) for my in self.mask])
# Rotate the data (if applicable)
for y in xrange(new_data.shape[0]):
for z in xrange(new_data.shape[1]):
for x in xrange(new_data.shape[2]):
b = new_blocks[y, z, x]
d = new_data[y, z, x]
new_data[y, z, x] = self.data_rot90(b, d, turns)
return MaskedSubChunk(new_blocks, new_data, new_mask) Example 18
def data_rot90(self, block, data, turns):
"""
Specially rotate this block, which has an orientation that depends on
the data value.
"""
blockname = blocks.block_names[block]
# Torches (redstone and normal)
torches = ["redstone_torch", "unlit_redstone_torch", "torch"]
if blockname in torches:
return blocks.Torch.rot90(data, turns)
# Repeaters
repeaters = ["unpowered_repeater", "powered_repeater"]
if blockname in repeaters:
return blocks.Repeater.rot90(data, turns)
# Comparators
comparators = ["unpowered_comparator", "powered_comparator"]
if blockname in comparators:
return blocks.Comparator.rot90(data, turns)
return data Example 19
def _display_pixels(x, y, counts, pixelsize):
"""
Display pixels at coordinates (x, y) coloured with "counts".
This routine is fast but not fully general as it assumes the spaxels
are on a regular grid. This needs not be the case for Voronoi binning.
"""
xmin, xmax = np.min(x), np.max(x)
ymin, ymax = np.min(y), np.max(y)
nx = int(round((xmax - xmin)/pixelsize) + 1)
ny = int(round((ymax - ymin)/pixelsize) + 1)
img = np.full((nx, ny), np.nan) # use nan for missing data
j = np.round((x - xmin)/pixelsize).astype(int)
k = np.round((y - ymin)/pixelsize).astype(int)
img[j, k] = counts
plt.imshow(np.rot90(img), interpolation='nearest', cmap='prism',
extent=[xmin - pixelsize/2, xmax + pixelsize/2,
ymin - pixelsize/2, ymax + pixelsize/2])
#---------------------------------------------------------------------- Example 20
def visualize2D(fig, ax, xs, ys, bins=200,
xlabel='x', ylabel='y',
xlim=None, ylim=None):
H, xedges, yedges = numpy.histogram2d(xs, ys, bins)
H = numpy.rot90(H)
H = numpy.flipud(H)
Hmasked = numpy.ma.masked_where(H == 0, H)
ax.pcolormesh(xedges, yedges, Hmasked)
ax.set_xlabel(xlabel)
ax.set_ylabel(ylabel)
if xlim is None:
xlim = (min(xs), max(xs))
if ylim is None:
ylim = (min(ys), max(ys))
ax.set_xlim(*xlim)
ax.set_ylim(*ylim)
fig.colorbar(pyplot.contourf(Hmasked)) Example 21
def rot180(images):
"""
????180??
??HW/CHW/NCHW?????images?
"""
out = np.empty(shape=images.shape, dtype=images.dtype)
if images.ndim == 2:
out = np.rot90(images, k=2)
elif images.ndim == 3:
for c in xrange(images.shape[0]):
out[c] = np.rot90(images[c], k=2)
elif images.ndim == 4:
for n in xrange(images.shape[0]):
for c in xrange(images.shape[1]):
out[n][c] = np.rot90(images[n][c], k=2)
else:
raise Exception('Invalid ndim: ' + str(images.ndim) +
', only support ndim between 2 and 4.')
return out
# ????f????x???f???df???x??? Example 22
def grad_magnitude(img):
"""Calculate the gradient magnitude of an image.
Args:
img The image
Returns:
gradient image"""
img = img / 255.0
sobel_y = np.array([
[-1, -2, -1],
[0, 0, 0],
[1, 2, 1]
])
sobel_x = np.rot90(sobel_y) # rotates counter-clockwise
# apply x/y sobel filter to get x/y gradients
imgx = signal.correlate(img, sobel_x, mode="same")
imgy = signal.correlate(img, sobel_y, mode="same")
imgmag = np.sqrt(imgx**2 + imgy**2)
return imgmag Example 23
def main():
"""Load image, apply filter, plot."""
img = data.camera()
# just like sobel, but no -2/+2 in the middle
prewitt_y = np.array([
[-1, -1, -1],
[0, 0, 0],
[1, 1, 1]
])
prewitt_x = np.rot90(prewitt_y) # rotates counter-clockwise
img_sx = signal.correlate(img, prewitt_x, mode="same")
img_sy = signal.correlate(img, prewitt_y, mode="same")
g_magnitude = np.sqrt(img_sx**2 + img_sy**2)
ground_truth = skifilters.prewitt(data.camera())
util.plot_images_grayscale(
[img, img_sx, img_sy, g_magnitude, ground_truth],
["Image", "Prewitt (x)", "Prewitt (y)", "Prewitt (both/magnitude)",
"Prewitt (Ground Truth)"]
) Example 24
def augment_image(self, image, i):
if i == 0:
return np.rot90(image)
elif i == 1:
return np.rot90(image,2)
elif i == 2:
return np.rot90(image,3)
elif i == 3:
return image
elif i == 4:
return np.fliplr(image)
elif i == 5:
return np.flipud(image)
elif i == 6:
return image.transpose(1,0,2)
elif i == 7:
return np.fliplr(np.rot90(image)) Example 25
def augment_image(self, image, i):
if i == 0:
return np.rot90(image)
elif i == 1:
return np.rot90(image,2)
elif i == 2:
return np.rot90(image,3)
elif i == 3:
return image
elif i == 4:
return np.fliplr(image)
elif i == 5:
return np.flipud(image)
elif i == 6:
return image.transpose(1,0,2)
elif i == 7:
return np.fliplr(np.rot90(image)) Example 26
def test_get_geo_fact():
res = np.array([0.017051023225738, 0.020779123804907, -0.11077204227395,
-0.081155809427821, -0.098900024313067, 0.527229048585517,
-0.124497144079623, -0.151717673241039, 0.808796206796408])
res2 = np.rot90(np.fliplr(res.reshape(3, -1))).ravel()
# EE, MM
ab = [11, 12, 13, 21, 22, 23, 31, 32, 33]
i = 0
for i in range(9):
out = utils.get_geo_fact(ab[i], 13.45, 23.8, 124.3, 5.3, False, False)
assert_allclose(out[0], res[i])
out = utils.get_geo_fact(ab[i], 13.45, 23.8, 124.3, 5.3, True, True)
assert_allclose(out[0], res[i])
i += 1
# ME, EM
ab = [14, 15, 16, 24, 25, 26, 34, 35, 36]
i = 0
for i in range(9):
out = utils.get_geo_fact(ab[i], 13.45, 23.8, 124.3, 5.3, False, True)
assert_allclose(out[0], res2[i])
out = utils.get_geo_fact(ab[i], 13.45, 23.8, 124.3, 5.3, True, False)
assert_allclose(out[0], res[i])
i += 1 Example 27
def rotate_examples(X, y, files, extent, k=3):
m,n = np.shape(X)
augmentedX = np.ones(((k+1)*m,n))
augmentedy = np.squeeze(np.ones(((k+1)*m,)))
augmented_files = []
for i in range(m):
#print y[i]
print((k+1)*i)
augmentedX[(k+1)*i,:] *= X[i,:]
augmentedy[(k+1)*i] *= y[i]
#print augmentedy[(k+1)*i]
augmented_files.append(files[i])
for j in range(1,k+1):
print(((k+1)*i)+j)
rotatedX = np.rot90(np.reshape(X[i,:], (2*extent,2*extent), order="F"), j)
augmentedX[((k+1)*i)+j,:] *= np.ravel(rotatedX, order="F")
augmentedy[((k+1)*i)+j] *= y[i]
augmented_files.append(files[i])
#print augmentedX[:16,:2]
#print np.shape(augmentedX)
#print len(augmented_files)
return augmentedX, augmentedy, augmented_files Example 28
def rotate_examples(X, y, files, extent, k=3):
m,n = np.shape(X)
augmentedX = np.ones(((k+1)*m,n))
augmentedy = np.squeeze(np.ones(((k+1)*m,)))
augmented_files = []
for i in range(m):
#print y[i]
print (k+1)*i
augmentedX[(k+1)*i,:] *= X[i,:]
augmentedy[(k+1)*i] *= y[i]
#print augmentedy[(k+1)*i]
augmented_files.append(files[i])
for j in range(1,k+1):
print ((k+1)*i)+j
rotatedX = np.rot90(np.reshape(X[i,:], (2*extent,2*extent), order="F"), j)
augmentedX[((k+1)*i)+j,:] *= np.ravel(rotatedX, order="F")
augmentedy[((k+1)*i)+j] *= y[i]
augmented_files.append(files[i])
#print augmentedX[:16,:2]
#print np.shape(augmentedX)
#print len(augmented_files)
return augmentedX, augmentedy, augmented_files Example 29
def transform_to_2d(data, max_axis):
"""
Projects 3d data cube along one axis using maximum intensity with
preservation of the signs. Adapted from nilearn.
"""
import numpy as np
# get the shape of the array we are projecting to
new_shape = list(data.shape)
del new_shape[max_axis]
# generate a 3D indexing array that points to max abs value in the
# current projection
a1, a2 = np.indices(new_shape)
inds = [a1, a2]
inds.insert(max_axis, np.abs(data).argmax(axis=max_axis))
# take the values where the absolute value of the projection
# is the highest
maximum_intensity_data = data[inds]
return np.rot90(maximum_intensity_data) Example 30
def bp_sensitivity_map(self, sensitivity_array, activator):
expanded_array = self.expand_sensitivity_map(sensitivity_array)
expanded_width = expanded_array.shape[2]
zp = (self.input_width + self.filter_width - 1 - expanded_width) / 2
padded_array = padding(expanded_array, zp)
self.delta_array = self.create_delta_array()
for f in range(self.filter_number):
filter = self.filters[f]
flipped_weights = np.array(map(lambda i: np.rot90(i, 2), filter.get_weights()))
delta_array = self.create_delta_array()
for d in range(delta_array.shape[0]):
conv(padded_array[f], flipped_weights[d], delta_array[d], 1, 0)
self.delta_array += delta_array
derivative_array = np.array(self.input_array)
element_wise_op(derivative_array, activator.backward)
self.delta_array *= derivative_array Example 31
def makeImgPatchPrototype(D, compID):
''' Create image patch prototype for specific component
Returns
--------
Xprototype : sqrt(D) x sqrt(D) matrix
'''
# Create a "prototype" image patch of PxP pixels
P = np.sqrt(D)
Xprototype = np.zeros((P, P))
if compID % 4 == 0:
Xprototype[:P / 2] = 1.0
Xprototype = np.rot90(Xprototype, compID / 4)
if compID % 4 == 1:
Xprototype[np.tril_indices(P)] = 1
Xprototype = np.rot90(Xprototype, (compID - 1) / 4)
if compID % 4 == 2:
Xprototype[np.tril_indices(P, 2)] = 1
Xprototype = np.rot90(Xprototype, (compID - 2) / 4)
if compID % 4 == 3:
Xprototype[np.tril_indices(P, -2)] = 1
Xprototype = np.rot90(Xprototype, (compID - 3) / 4)
return Xprototype Example 32
def take_photo_at(self, camera_centre):
with picamera.PiCamera() as camera:
camera.resolution = config.CAMERA_RESOLUTION
camera.framerate = 24
with picamera.array.PiRGBArray(camera) as output:
camera.capture(output, 'bgr', use_video_port=True)
outputarray = output.array
# Rotate image to oriented it with paper.
outputarray = np.rot90(outputarray, 3)
# Save photo.
filename = datetime.datetime.now().strftime("%M%S.%f_") + \
str(camera_centre[0]) \
+ '_' \
+ str(camera_centre[1]) + '_Photo_' + str(self._photo_index) + '.jpg'
cv2.imwrite(os.path.join(config.debug_output_folder, filename), outputarray)
self._photo_index += 1
return outputarray Example 33
def sum48(newFile,extent):
currentSum=loadtxt(os.path.join(getCurrentDirectory(),'Sum48','sum48.txt'),dtype='float',delimiter=',')
historicFiles=sorted(glob.glob(os.path.join(getCurrentDirectory(),'Sum48','Files','*txt')))
lastFile=loadtxt(os.path.join(getCurrentDirectory(),'Sum48','Files',historicFiles[0]),dtype='float',delimiter=',')
currentSum=currentSum-lastFile
currentSum=currentSum+newFile
np.savetxt(os.path.join(getCurrentDirectory(),'Sum48','sum48.txt'),currentSum,delimiter=',')
rotatedSum = np.rot90(currentSum)
tiffFiles=glob.glob(os.path.join(getCurrentDirectory(),'Sum48','Tiffs','*.TIF'))
if not tiffFiles:
lastTifNum='1'
else:
tiffFiles=natsorted(tiffFiles,alg=ns.IC)
lastTif=tiffFiles[-1]
lastTifNum=str(int(lastTif[lastTif.rfind('_')+1:lastTif.rfind('.')])+1)
array2raster(os.path.join(getCurrentDirectory(),'Sum48','Tiffs',timeStr[-11:-7]) + '_48HourSum_' + lastTifNum + '.TIF',[extent[0],extent[3]],extent[4],extent[5],rotatedSum,gdalconst.GDT_Float32)
while len(tiffFiles)>48:
os.remove(tiffFiles[0])
tiffFiles=natsorted(glob.glob(os.path.join(getCurrentDirectory(),'Sum48','Tiffs','*.TIF')),alg=ns.IC)
os.remove(historicFiles[0])
#sums the past 72 hours of rainfall, sends an email if exceeds threshold Example 34
def sum72(newFile,extent):
currentSum=loadtxt(os.path.join(getCurrentDirectory(),'Sum72','sum72.txt'),dtype='float',delimiter=',')
historicFiles=sorted(glob.glob(os.path.join(getCurrentDirectory(),'Sum72','Files','*txt')))
lastFile=loadtxt(os.path.join(getCurrentDirectory(),'Sum72','Files',historicFiles[0]),dtype='float',delimiter=',')
currentSum=currentSum-lastFile
currentSum=currentSum+newFile
np.savetxt(os.path.join(getCurrentDirectory(),'Sum72','sum72.txt'),currentSum,delimiter=',')
rotatedSum = np.rot90(currentSum)
tiffFiles=glob.glob(os.path.join(getCurrentDirectory(),'Sum72','Tiffs','*.TIF'))
if not tiffFiles:
lastTifNum='1'
else:
tiffFiles=natsorted(tiffFiles,alg=ns.IC)
lastTif=tiffFiles[-1]
lastTifNum=str(int(lastTif[lastTif.rfind('_')+1:lastTif.rfind('.')])+1)
array2raster(os.path.join(getCurrentDirectory(),'Sum72','Tiffs',timeStr[-11:-7]) + '_72HourSum_' + lastTifNum + '.TIF',[extent[0],extent[3]],extent[4],extent[5],rotatedSum,gdalconst.GDT_Float32)
while len(tiffFiles)>48:
os.remove(tiffFiles[0])
tiffFiles=natsorted(glob.glob(os.path.join(getCurrentDirectory(),'Sum72','Tiffs','*.TIF')),alg=ns.IC)
os.remove(historicFiles[0])
#sends an e-mail containing "attachment", currently to the authors Example 35
def symmetries(self): """returns a list of 8 GameState objects: all reflections and rotations of the current board does not check for duplicates """ copies = [self.copy() for i in range(8)] # copies[0] is the original. # rotate CCW 90 copies[1].board = np.rot90(self.board,1) # rotate 180 copies[2].board = np.rot90(self.board,2) # rotate CCW 270 copies[3].board = np.rot90(self.board,3) # mirror left-right copies[4].board = np.fliplr(self.board) # mirror up-down copies[5].board = np.flipud(self.board) # mirror \ diagonal copies[6].board = np.transpose(self.board) # mirror / diagonal (equivalently: rotate 90 CCW then flip LR) copies[7].board = np.fliplr(copies[1].board) return copies
Example 36
def pick_move(self, color):
if not self.opponent_passed and self.last_opponent_play:
mirror_x = self.board.N - self.last_opponent_play[0] - 1
mirror_y = self.board.N - self.last_opponent_play[1] - 1
if self.board.play_is_legal(mirror_x, mirror_y, color):
return (mirror_x, mirror_y)
enemy_stones = (self.board.vertices == flipped_color[color])
our_stones = (self.board.vertices == color)
rot_enemy_stones = np.rot90(enemy_stones, 2)
play_vertices = np.logical_and(rot_enemy_stones, np.logical_not(our_stones))
play_vertices = np.logical_and(play_vertices, np.logical_not(enemy_stones))
for x in xrange(self.board.N):
for y in xrange(self.board.N):
if play_vertices[x,y] and self.board.play_is_legal(x, y, color):
return (x,y)
center = (self.board.N/2, self.board.N/2)
if self.board[center] == Color.Empty and self.board.play_is_legal(center[0], center[1], color):
return center
return None Example 37
def extract_digits(self, image):
"""
Extract digits from a binary image representing a sudoku
:param image: binary image/sudoku
:return: array of digits and their probabilities
"""
prob = np.zeros(4, dtype=np.float32)
digits = np.zeros((4, 9, 9), dtype=object)
for i in range(4):
labeled, features = label(image, structure=CROSS)
objs = find_objects(labeled)
for obj in objs:
roi = image[obj]
# center of bounding box
cy = (obj[0].stop + obj[0].start) / 2
cx = (obj[1].stop + obj[1].start) / 2
dists = cdist([[cy, cx]], CENTROIDS, 'euclidean')
pos = np.argmin(dists)
cy, cx = pos % 9, pos / 9
# 28x28 image, center relative to sudoku
prediction = self.classifier.classify(morph(roi))
if digits[i, cy, cx] is 0:
# Newly found digit
digits[i, cy, cx] = prediction
prob[i] += prediction[0, 0]
elif prediction[0, 0] > digits[i, cy, cx][0, 0]:
# Overlapping! (noise), choose the most probable prediction
prob[i] -= digits[i, cy, cx][0, 0]
digits[i, cy, cx] = prediction
prob[i] += prediction[0, 0]
image = np.rot90(image)
logging.info(prob)
return digits[np.argmax(prob)] Example 38
def extract_digits(self, image):
"""
Extract digits from a binary image representing a sudoku
:param image: binary image/sudoku
:return: array of digits and their probabilities
"""
prob = np.zeros(4, dtype=np.float32)
digits = np.zeros((4, 9, 9), dtype=object)
for i in range(4):
labeled, features = label(image, structure=CROSS)
objs = find_objects(labeled)
for obj in objs:
roi = image[obj]
# center of bounding box
cy = (obj[0].stop + obj[0].start) / 2
cx = (obj[1].stop + obj[1].start) / 2
dists = cdist([[cy, cx]], CENTROIDS, 'euclidean')
pos = np.argmin(dists)
cy, cx = pos % 9, pos / 9
# 28x28 image, center relative to sudoku
prediction = self.classifier.classify(morph(roi))
if digits[i, cy, cx] is 0:
# Newly found digit
digits[i, cy, cx] = prediction
prob[i] += prediction[0, 0]
elif prediction[0, 0] > digits[i, cy, cx][0, 0]:
# Overlapping! (noise), choose the most probable prediction
prob[i] -= digits[i, cy, cx][0, 0]
digits[i, cy, cx] = prediction
prob[i] += prediction[0, 0]
image = np.rot90(image)
logging.info(prob)
return digits[np.argmax(prob)] Example 39
def apply_latitude_adjustments(pixels):
data, (bounds, crs), _ = pixels
(_, height, width) = data.shape
ys = np.interp(np.arange(height), [0, height - 1], [bounds[3], bounds[1]])
xs = np.empty_like(ys)
xs.fill(bounds[0])
longitudes, latitudes = warp.transform(crs, WGS84_CRS, xs, ys)
factors = 1 / np.cos(np.radians(latitudes))
# convert to 2d array, rotate 270º, scale data
return PixelCollection(data * np.rot90(np.atleast_2d(factors), 3),
pixels.bounds) Example 40
def extract(self,ori_wmimage,wm, key=None):
'''
??LSB??
'''
#???rgb?????????
if len(ori_wmimage.shape)==3:
wmimage = ori_wmimage[:,:,0]
else:
wmimage = ori_wmimage
#???????
signature = self._gene_signature(wm,key).reshape((16,16))
#???????
ext_sigs = self.ext_sig(wmimage,size=16)
#ext_sigs.extend(self.ext_sig(np.rot90(wmimage,1)))
#ext_sigs.extend(self.ext_sig(np.rot90(wmimage,2)))
#ext_sigs.extend(self.ext_sig(np.rot90(wmimage,3)))
#?????
similarity = 0
for sig in ext_sigs:
print(sig)
print(signature)
one_similarity = list(np.array(sig.flatten()) - signature.flatten()).count(0) / len(signature.flatten())
#logging.info('????? : {}'.format(one_similarity))
similarity = max(similarity,one_similarity )
break
logging.debug('???????????????%f (1???0?????????0.7)' % (similarity))
return similarity Example 41
def inner_extract(self,B,signature):
sig_size=np.int(np.sqrt(len(signature)))
size = self.size
ext_sigs =[]
#???????????????
#???????????????????????
# (0,0) (0,w-32)
# (h-32,0) (h-32,w-32)
w ,h = B.shape
embed_pos =[(0,0)]
embed_pos.append((w-sig_size*size,0))
embed_pos.append((0,h-sig_size*size))
embed_pos.append((w-sig_size*size,h-sig_size*size))
for x,y in embed_pos:
ext_sig = np.zeros(len(signature),dtype=np.int)
for i in range(x,x+sig_size*size,size):
for j in range(y,y+sig_size * size,size):
v = cv2.dct(np.float32(B[i:i+size,j:j+size]))
if v[size-1,size-1] > self.Q/2:
ext_sig[((i-x)//size)*sig_size+(j-y)//size] = 1
ext_sigs.append(ext_sig)
ext_sig_arr = np.array(ext_sig).reshape((sig_size,sig_size))
ext_sigs.append(np.rot90(ext_sig_arr,1).flatten())
ext_sigs.append(np.rot90(ext_sig_arr,2).flatten())
ext_sigs.append(np.rot90(ext_sig_arr,3).flatten())
return ext_sigs Example 42
def convert_segmentation_mat2numpy(mat_file): np_segm = load_mat(mat_file) return np.rot90(np.fliplr(np.argmax(np_segm, axis=2)))
Example 43
def load_binary_segmentation(bin_file, dtype='int16'):
with open(bin_file, 'rb') as bf:
rows = struct.unpack('i', bf.read(4))[0]
cols = struct.unpack('i', bf.read(4))[0]
channels = struct.unpack('i', bf.read(4))[0]
num_values = rows * cols # expect only one channel in segmentation output
out = np.zeros(num_values, dtype=np.uint8) # expect only values between 0 and 255
for i in range(num_values):
out[i] = np.uint8(struct.unpack('h', bf.read(2))[0])
return np.rot90(np.fliplr(out.reshape((cols, rows)))) Example 44
def rot90(W):
for i in range(W.shape[0]):
for j in range(W.shape[1]):
W[i, j] = np.rot90(W[i, j], 2)
return W Example 45
def rot90_mat(mat, k):
n_mat = np.zeros(mat.shape, dtype=np.float32)
for i in range(mat.shape[2]):
n_mat[:, :, i] = np.rot90(mat[:, :, i], k)
return n_mat Example 46
def rotate_90(k=1):
def call(x):
x = np.rot90(x, k).copy()
return x
return call Example 47
def visualize_document_topics_heatmap(self, outfile, set_topics=False):
self.sort_doctopics_groups()
doctopics_raw_hm = numpy.rot90(self.document_topics_raw)
rows, columns = doctopics_raw_hm.shape
rownames = self.topic_labels
columnnames = self.document_names
pyplot.pcolor(doctopics_raw_hm, norm=None, cmap='Blues')
pyplot.gca().invert_yaxis()
if self.group_names:
ticks_groups = []
bounds = []
current_group = False
start = 0
for i,doc in enumerate(self.document_names):
group = self.document_group_dict[doc]
if group != current_group:
if i != 0:
bounds.append(i-1)
ticks_groups[start+int((i-start)/2)] = current_group
current_group = group
start=i
ticks_groups.append('')
ticks_groups[start+int((i-start)/2)] = current_group
pyplot.xticks(numpy.arange(columns)+0.5,ticks_groups, fontsize=11)
if set_topics:
for index in set_topics:
pyplot.axhline(y=index)
topic_names = self.return_topic_names(set_topics)
pyplot.yticks(set_topics,topic_names,fontsize=8)
else:
pyplot.yticks(numpy.arange(rows)+0.5, rownames, fontsize=8)
for bound in bounds:
pyplot.axvline(x=bound)
pyplot.colorbar(cmap='Blues')
pyplot.savefig(outfile)
pyplot.clf() Example 48
def _rotate(self, im, meta):
""" Use Orientation information from EXIF meta data to
orient the image correctly. Freeimage is also supposed to
support that, and I am pretty sure it once did, but now it
does not, so let's just do it in Python.
Edit: and now it works again, just leave in place as a fallback.
"""
if self.request.kwargs.get('exifrotate', None) == 2:
try:
ori = meta['EXIF_MAIN']['Orientation']
except KeyError: # pragma: no cover
pass # Orientation not available
else: # pragma: no cover - we cannot touch all cases
# www.impulseadventure.com/photo/exif-orientation.html
if ori in [1, 2]:
pass
if ori in [3, 4]:
im = np.rot90(im, 2)
if ori in [5, 6]:
im = np.rot90(im, 3)
if ori in [7, 8]:
im = np.rot90(im)
if ori in [2, 4, 5, 7]: # Flipped cases (rare)
im = np.fliplr(im)
return im
# -- Example 49
def image_function(self, image):
return np.rot90(image, k=self.get_random_variable('k')) Example 50
def noise_amp(self, size):
"""
DESCRIPTION:
Creates a size x size matrix of randomly generated noise with
amplitude values with 1/f slope
ARGS:
:size: size of matrix
RETURNS:
:returns the amplitudes with noise added
"""
slope = 1
x = y = np.linspace(1, size, size)
xgrid, ygrid = np.meshgrid(x, y) # coordinates for a square grid
xgrid = np.subtract(xgrid, size // 2)
ygrid = np.subtract(ygrid, size // 2)
amp = self.fft.fftshift(np.divide(np.sqrt(np.square(xgrid) +
np.square(ygrid)),
size * np.sqrt(2)))
amp = np.rot90(amp, 2)
amp[0, 0] = 1
amp = 1 / amp**slope
amp[0, 0] = 0
return amp 