我们从Python开源项目中，提取了以下47个代码示例，用于说明如何使用numpy.flipud()。
def plot_spectra(results): plt.figure(figsize=(10, 4)) plt.imshow( np.concatenate( [np.flipud(results['x'].T), np.flipud(results['xh'].T), np.flipud(results['x_conv'].T)], 0), aspect='auto', cmap='jet', ) plt.colorbar() plt.title('Upper: Real input; Mid: Reconstrution; Lower: Conversion to target.') plt.savefig( os.path.join( args.logdir, '{}.png'.format( os.path.split(str(results['f'], 'utf-8'))[-1] ) ) )
def cochleagram_extractor(xx, sr, win_len, shift_len, channel_number, win_type): fcoefs, f = make_erb_filters(sr, channel_number, 50) fcoefs = np.flipud(fcoefs) xf = erb_frilter_bank(xx, fcoefs) if win_type == 'hanning': window = np.hanning(channel_number) elif win_type == 'hamming': window = np.hamming(channel_number) elif win_type == 'triangle': window = (1 - (np.abs(channel_number - 1 - 2 * np.arange(1, channel_number + 1, 1)) / (channel_number + 1))) else: window = np.ones(channel_number) window = window.reshape((channel_number, 1)) xe = np.power(xf, 2.0) frames = 1 + ((np.size(xe, 1)-win_len) // shift_len) cochleagram = np.zeros((channel_number, frames)) for i in range(frames): one_frame = np.multiply(xe[:, i*shift_len:i*shift_len+win_len], np.repeat(window, win_len, 1)) cochleagram[:, i] = np.sqrt(np.mean(one_frame, 1)) cochleagram = np.where(cochleagram == 0.0, np.finfo(float).eps, cochleagram) return cochleagram
def ssh(): from random import randint, seed import pandas as pd import matplotlib.pyplot as plt seed(1) df = pd.DataFrame(pd.read_csv('ssh.csv', sep=';'))[:20000] y = df.value.as_matrix() y_raw = numpy.flipud(y) y = numpy.append(y_raw, y_raw) y = numpy.append(y, y_raw) for i in range(len(y)): y[i] += randint(-10, 10) for i in range(46100, 46120): y[i] += 100 y[i] *= 10 x = [i for i in range(0, len(y) * 2, 2)] series = list(zip(x, y)) result = StddevAnomaly().search_anomaly({}, len(series), series) print(result) plt.plot(*zip(*series)) plt.plot(*zip(*result), 'x') plt.show()
def _process(self, img, key=None): if self.p.fast: return self._fast_process(img, key) proj = self.p.projection if proj == img.crs: return img x0, x1 = img.range(0) y0, y1 = img.range(1) xn, yn = img.interface.shape(img, gridded=True)[:2] px0, py0, px1, py1 = project_extents((x0, y0, x1, y1), img.crs, proj) src_ext, trgt_ext = (x0, x1, y0, y1), (px0, px1, py0, py1) arrays = [] for vd in img.vdims: arr = img.dimension_values(vd, flat=False) projected, extents = warp_array(arr, proj, img.crs, (xn, yn), src_ext, trgt_ext) arrays.append(projected) projected = np.dstack(arrays) if len(arrays) > 1 else arrays[0] data = np.flipud(projected) bounds = (extents[0], extents[2], extents[1], extents[3]) return img.clone(data, bounds=bounds, kdims=img.kdims, vdims=img.vdims, crs=proj)
def n_even_fcn(f, o, w, l): """Even case.""" # Variables : k = np.array(range(0, int(l) + 1, 1)) + 0.5 b = np.zeros(k.shape) # # Run Loop : for s in range(0, len(f), 2): m = (o[s + 1] - o[s]) / (f[s + 1] - f[s]) b1 = o[s] - m * f[s] b = b + (m / (4 * np.pi * np.pi) * (np.cos(2 * np.pi * k * f[ s + 1]) - np.cos(2 * np.pi * k * f[s])) / ( k * k)) * abs(np.square(w[round((s + 1) / 2)])) b = b + (f[s + 1] * (m * f[s + 1] + b1) * np.sinc(2 * k * f[ s + 1]) - f[s] * (m * f[s] + b1) * np.sinc(2 * k * f[s])) * abs( np.square(w[round((s + 1) / 2)])) a = (np.square(w[0])) * 4 * b h = 0.5 * np.concatenate((np.flipud(a), a)) return h
def NevenFcn(F, M, W, L): # N is even # Variables : k = np.array(range(0, int(L) + 1, 1)) + 0.5 b = np.zeros(k.shape) # # Run Loop : for s in range(0, len(F), 2): m = (M[s + 1] - M[s]) / (F[s + 1] - F[s]) b1 = M[s] - m * F[s] b = b + (m / (4 * np.pi * np.pi) * (np.cos(2 * np.pi * k * F[ s + 1]) - np.cos(2 * np.pi * k * F[s])) / ( k * k)) * abs(np.square(W[round((s + 1) / 2)])) b = b + (F[s + 1] * (m * F[s + 1] + b1) * np.sinc(2 * k * F[ s + 1]) - F[s] * (m * F[s] + b1) * np.sinc(2 * k * F[s])) * abs( np.square(W[round((s + 1) / 2)])) a = (np.square(W[0])) * 4 * b h = 0.5 * np.concatenate((np.flipud(a), a)) return h #################################################################### # - Filt the signal : ####################################################################
def plot_feature_importances(feature_importances, title, feature_names): # Normalize the importance values feature_importances = 100.0 * (feature_importances / max(feature_importances)) # Sort the values and flip them index_sorted = np.flipud(np.argsort(feature_importances)) # Arrange the X ticks pos = np.arange(index_sorted.shape[0]) + 0.5 # Plot the bar graph plt.figure() plt.bar(pos, feature_importances[index_sorted], align='center') plt.xticks(pos, feature_names[index_sorted]) plt.ylabel('Relative Importance') plt.title(title) plt.show()
def generate_plot(self, filename, title='', xlabel='', ylabel=''): data_keys = list(self.data.keys()) key_num = len(data_keys) self.plot = plt.figure() if key_num == 1: splt = self.plot.add_subplot(1, 1, 1) im_data = splt.imshow(numpy.flipud(self.data[data_keys[0]][0]), origin='lower') splt.set_xlabel(xlabel) splt.set_ylabel(ylabel) splt.set_title(title) else: ## still plotting multiple image in one figure still has problem. the visualization is not good logger.error('no supported yet') self.plot.colorbar(im_data) self.plot.savefig(filename) #, bbox_inches='tight' #class MultipleLinesPlot(PlotWithData): # def generate_plot(self, filename, title='', xlabel='', ylabel=''):
def update(self): self._display_init() x1, x2 = self.update_x1, self.update_x2 y1, y2 = self.update_y1, self.update_y2 region = self.buffer[y1:y2, x1:x2] if self.v_flip: region = numpy.fliplr(region) if self.h_flip: region = numpy.flipud(region) buf_red = numpy.packbits(numpy.where(region == RED, 1, 0)).tolist() if self.inky_version == 1: buf_black = numpy.packbits(numpy.where(region == 0, 0, 1)).tolist() else: buf_black = numpy.packbits(numpy.where(region == BLACK, 0, 1)).tolist() self._display_update(buf_black, buf_red) self._display_fini()
def plot_dZ_contours(x, y, dZ, axes=None, dZ_interval=0.5, verbose=False, fig_kwargs={}): r"""For plotting seafloor deformation dZ""" import matplotlib.pyplot as plt dZ_max = max(dZ.max(), -dZ.min()) + dZ_interval clines1 = numpy.arange(dZ_interval, dZ_max, dZ_interval) clines = list(-numpy.flipud(clines1)) + list(clines1) # Create axes if needed if axes is None: fig = plt.figure(**fig_kwargs) axes = fig.add_subplot(111) if len(clines) > 0: if verbose: print "Plotting contour lines at: ",clines axes.contour(x, y, dZ, clines, colors='k') else: print "No contours to plot" return axes
def from_catmaid_stack(stack_info, tile_source_parameters): # See https://catmaid.readthedocs.io/en/stable/tile_sources.html format_url = { 1: '{source_base_url}{{z}}/{{row}}_{{col}}_{{zoom_level}}.{file_extension}', 4: '{source_base_url}{{z}}/{{zoom_level}}/{{row}}_{{col}}.{file_extension}', 5: '{source_base_url}{{zoom_level}}/{{z}}/{{row}}/{{col}}.{file_extension}', 7: '{source_base_url}largeDataTileSource/{tile_width}/{tile_height}/' '{{zoom_level}}/{{z}}/{{row}}/{{col}}.{file_extension}', 9: '{source_base_url}{{z}}/{{row}}_{{col}}_{{zoom_level}}.{file_extension}', }[tile_source_parameters['tile_source_type']].format(**tile_source_parameters) bounds = np.flipud(np.array(stack_info['bounds'], dtype=np.int64)) resolution = np.flipud(np.array(stack_info['resolution'])) tile_width = int(tile_source_parameters['tile_width']) tile_height = int(tile_source_parameters['tile_height']) return ImageStackVolume(bounds, resolution, tile_width, tile_height, format_url, missing_z=stack_info['broken_slices'])
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
def __model_form(self, tri_array): w = np.nan_to_num(self.weights/tri_array[:,:,:-1]**(2-self.alpha)) x = np.nan_to_num(tri_array[:,:,:-1]*(tri_array[:,:,1:]*0+1)) y = np.nan_to_num(tri_array[:,:,1:]) LDF = np.sum(w*x*y,axis=1)/np.sum(w*x*x,axis=1) #Chainladder (alpha=1/delta=1) #LDF = np.sum(np.nan_to_num(tri_array[:,:,1:]),axis=1) / np.sum(np.nan_to_num((tri_array[:,:,1:]*0+1)*tri_array[:,:,:-1]),axis=1) #print(LDF.shape) # assumes no tail CDF = np.append(np.cumprod(LDF[:,::-1],axis=1)[:,::-1],np.array([1]*tri_array.shape[0]).reshape(tri_array.shape[0],1),axis=1) latest = np.flip(tri_array,axis=1).diagonal(axis1=1,axis2=2) ults = latest*CDF lu = list(ults) lc = list(CDF) exp_cum_triangle = np.array([np.flipud(lu[num].reshape(tri_array.shape[2],1).dot(1/lc[num].reshape(1,tri_array.shape[2]))) for num in range(tri_array.shape[0])]) exp_incr_triangle = np.append(exp_cum_triangle[:,:,0,np.newaxis],np.diff(exp_cum_triangle),axis=2) return LDF, CDF, ults, exp_incr_triangle
def ensurebuf(self, invalidate=True): if self.dbuf is None: if self.dpil is not None: self.dbuf = self.dpil.tostring("raw", "RGBX", 0, 1) elif self.darr is not None: data = self.scaledpixelarray(0,255.999) self.dbuf = np.dstack(( np.flipud(np.rollaxis(data,1)).astype(np.uint8), np.zeros(self.shape[::-1],np.uint8) )).tostring() else: raise ValueError("No source data for conversion to buffer") if invalidate: self.dpil = None self.darr = None self.rangearr = None ## This private function ensures that there is a valid numpy array representation, converting from # one of the other representations if necessary, and invalidating the other representations if requested.
def ensurearr(self, invalidate=True): if self.darr is None: if self.dpil is not None: self.darr = np.fromstring(self.dpil.tostring("raw", "RGB", 0, -1), np.uint8).astype(np.float64) self.darr = np.rollaxis(np.reshape(self.darr, (self.shape[1], self.shape[0], 3) ), 1) elif self.dbuf is not None: self.darr = np.fromstring(self.dbuf, np.uint8).astype(np.float64) self.darr = np.delete(np.reshape(self.darr, (self.shape[1], self.shape[0], 4) ), 3, 2) self.darr = np.rollaxis(np.flipud(self.darr), 1) else: raise ValueError("No source data for conversion to array") self.rangearr = ( 0, 255.999 ) if invalidate: self.dpil = None self.dbuf = None # ----------------------------------------------------------------- ## This private helper function returns a 2-tuple containing the least and most significant 16-bit portion # of the specified unsigned 32-bit integer value.
def get_historical_data(self, num_periods=200): gdax_client = gdax.PublicClient() end = datetime.datetime.utcnow() end_iso = end.isoformat() start = end - datetime.timedelta(seconds=(self.period_size * num_periods)) start_iso = start.isoformat() ret = gdax_client.get_product_historic_rates(self.product, granularity=self.period_size, start=start_iso, end=end_iso) # Check if we got rate limited, which will return a JSON message while not isinstance(ret, list): time.sleep(3) ret = gdax_client.get_product_historic_rates(self.product, granularity=self.period_size, start=start_iso, end=end_iso) hist_data = np.array(ret, dtype='object') for row in hist_data: row[0] = datetime.datetime.fromtimestamp(row[0], pytz.utc) return np.flipud(hist_data)
def sliceImages(inputImage, targetImage): inputSlices = [] targetSlices = [] sliceSize = 32 for y in range(0,inputImage.shape[1]//sliceSize): for x in range(0,inputImage.shape[0]//sliceSize): inputSlice = inputImage[x*sliceSize:(x+1)*sliceSize,y*sliceSize:(y+1)*sliceSize] targetSlice = targetImage[x*sliceSize//2:(x+1)*sliceSize//2,y*sliceSize//2:(y+1)*sliceSize//2] # only add slices if they're not just empty space # if (np.any(targetSlice)): # Reweight smaller sizes # for i in range(0,max(1,128//inputImage.shape[1])**2): inputSlices.append(inputSlice) targetSlices.append(targetSlice) # inputSlices.append(np.fliplr(inputSlice)) # targetSlices.append(np.fliplr(targetSlice)) # inputSlices.append(np.flipud(inputSlice)) # targetSlices.append(np.flipud(targetSlice)) # naiveSlice = imresize(inputSlice, 0.5) # deltaSlice = targetSlice - naiveSlice # targetSlices.append(deltaSlice) # return two arrays of images in a tuple return (inputSlices, targetSlices)
def transform(patch, flip=False, mirror=False, rotations=[]): """Perform data augmentation on a patch. Args: patch (numpy array): The patch to be processed. flip (bool, optional): Up/down symetry. mirror (bool, optional): left/right symetry. rotations (int list, optional) : rotations to perform (angles in deg). Returns: array list: list of augmented patches """ transformed_patches = [patch] for angle in rotations: transformed_patches.append(skimage.img_as_ubyte(skimage.transform.rotate(patch, angle))) if flip: transformed_patches.append(np.flipud(patch)) if mirror: transformed_patches.append(np.fliplr(patch)) return transformed_patches # In[4]:
def transformData(self, data): if(self.opts.has_key('newdims')): (H, W) = self.opts['newdims'] data = misc.imresize(data, (H, W), interp='bilinear') if(self.opts.has_key('zeromean') and self.opts['zeromean']): mean = self.opts['dataset_mean'] # provided by bmanager data = data - mean if(self.opts.has_key('rangescale') and self.opts['rangescale']): min_ = self.opts['dataset_min'] # provided by bmanager min_ = np.abs(min_.min()) max_ = self.opts['dataset_max'] # provided by bmanager max_ = np.abs(max_.max()) data = 127 * data / max(min_, max_) else: data = data - 127.0 if(self.opts.has_key('randomflip') and self.opts['randomflip']): if(np.random.rand() <= self.opts['randomflip_prob']): data = np.flipud(data) self.dataflip_state = True return data
def write_pfm(data, fpath, scale=1, file_identifier="Pf", dtype="float32"): # PFM format definition: http://netpbm.sourceforge.net/doc/pfm.html data = np.flipud(data) height, width = np.shape(data)[:2] values = np.ndarray.flatten(np.asarray(data, dtype=dtype)) endianess = data.dtype.byteorder if endianess == '<' or (endianess == '=' and sys.byteorder == 'little'): scale *= -1 with open(fpath, 'wb') as ff: ff.write(file_identifier + '\n') ff.write('%d %d\n' % (width, height)) ff.write('%d\n' % scale) ff.write(values)
def Gaussian2D(image, sigma, padding=0): n, m = image.shape[0], image.shape[1] tmp = np.zeros((n + padding, m + padding)) if tmp.shape[0] < 4: raise ValueError('Image and padding too small') if tmp.shape[1] < 4: raise ValueError('Image and padding too small') B, A = __gausscoeff(sigma) tmp[:n, :m] = image tmp = lfilter(B, A, tmp, axis=0) tmp = np.flipud(tmp) tmp = lfilter(B, A, tmp, axis=0) tmp = np.flipud(tmp) tmp = lfilter(B, A, tmp, axis=1) tmp = np.fliplr(tmp) tmp = lfilter(B, A, tmp, axis=1) tmp = np.fliplr(tmp) return tmp[:n, :m] #-----------------------------------------------------------------------------
def generate_plot(self, filename, title='', xlabel='', ylabel=''): data_keys = self.data.keys() key_num = len(data_keys) self.plot = plt.figure() if key_num == 1: splt = self.plot.add_subplot(1, 1, 1) im_data = splt.imshow(numpy.flipud(self.data[data_keys[0]][0]), origin='lower') splt.set_xlabel(xlabel) splt.set_ylabel(ylabel) splt.set_title(title) else: ## still plotting multiple image in one figure still has problem. the visualization is not good logger.error('no supported yet') self.plot.colorbar(im_data) self.plot.savefig(filename) #, bbox_inches='tight' #class MultipleLinesPlot(PlotWithData): # def generate_plot(self, filename, title='', xlabel='', ylabel=''):
def make_G_matrix(T,g): ''' create matrix of autoregression to enforce indicator dynamics Inputs: T: positive integer number of time-bins g: nd.array, vector p x 1 Discrete time constants Output: G: sparse diagonal matrix Matrix of autoregression ''' if type(g) is np.ndarray: if len(g) == 1 and g < 0: g=0 # gs=np.matrix(np.hstack((-np.flipud(g[:]).T,1))) gs=np.matrix(np.hstack((1,-(g[:]).T))) ones_=np.matrix(np.ones((T,1))) G = spdiags((ones_*gs).T,range(0,-len(g)-1,-1),T,T) return G else: raise Exception('g must be an array') #%%
def fits2jpg(fname): hdu_list = fits.open(fname) image = hdu_list[0].data image = np.squeeze(image) img = np.copy(image) idx = np.isnan(img) img[idx] = 0 img_clip = np.flipud(img) sigma = 3.0 # Estimate stats mean, median, std = sigma_clipped_stats(img_clip, sigma=sigma, iters=10) # Clip off n sigma points img_clip = clip(img_clip,std*sigma) if img_clip.shape[0] !=150 or img_clip.shape[1] !=150: img_clip = resize(img_clip, (150,150)) #img_clip = rgb2gray(img_clip) outfile = fname[0:-5] +'.png' imsave(outfile, img_clip) return img_clip,outfile # Do the fusion classification
def photonsToFrame(photonposframe,imagesize,background): pixels = imagesize edges = range(0, pixels+1) # HANDLE CASE FOR NO PHOTONS DETECTED AT ALL IN FRAME if photonposframe.size == 0: simframe = _np.zeros((pixels, pixels)) else: xx = photonposframe[:, 0] yy = photonposframe[:, 1] simframe, xedges, yedges = _np.histogram2d(yy, xx, bins=(edges, edges)) simframe = _np.flipud(simframe) # to be consistent with render #simframenoise = noisy(simframe,background,noise) simframenoise = noisy_p(simframe, background) simframenoise[simframenoise > 2**16-1] = 2**16-1 simframeout = _np.round(simframenoise).astype('<u2') return simframeout
def compute_tbl_properties(y, uMean, nu, flip): """Compute various parameters of a TBL.""" y = y[np.nonzero(y)] uMean = uMean[np.nonzero(uMean)] if flip: y = np.flipud(y) uMean = np.flipud(uMean) theta = momentum_thickness(y, uMean) delta = delta_99(y, uMean) deltaStar = delta_star(y, uMean) uTau = np.sqrt(nu*uMean[1]/y[1]) u0 = uMean[-1] yPlus1 = y[1]*uTau/nu return theta, deltaStar, delta, uTau, u0, yPlus1
def DST4(samples): """ Method to create DST4 transformation using DST3 Arguments : samples : (1D Array) Input samples to be transformed Returns : y : (1D Array) Transformed output samples """ # Initialize samplesup=np.zeros(2*N, dtype = np.float32) # Upsample signal # Reverse order to obtain DST4 out of DCT4: #samplesup[1::2]=np.flipud(samples) samplesup[0::2] = samples y = spfft.dst(samplesup,type=3,norm='ortho')*np.sqrt(2)#/2 # Flip sign of every 2nd subband to obtain DST4 out of DCT4 #y=(y[0:N])*(((-1)*np.ones(N, dtype = np.float32))**range(N)) return y[0: N]
def _get_wordcloud(img, patch, words, word_to_frequency=None, **wordcloud_kwargs): # get the boolean mask corresponding to each patch path = patch.get_path() mask = path.contains_points(img.pixel_coordinates).reshape((img.y_resolution, img.x_resolution)) # make mask matplotlib-venn compatible mask = (~mask * 255).astype(np.uint8) # black indicates mask position mask = np.flipud(mask) # origin is in upper left # create wordcloud wc = WordCloud(mask=mask, background_color=None, mode="RGBA", **wordcloud_kwargs) if not word_to_frequency: text = " ".join(words) wc.generate(text) else: wc.generate_from_frequencies({word: word_to_frequency[word] for word in words}) return wc
def autocorrelation(self): "Autocorrelation as a function of time" if self.__autocorrelation is not None: return self.__autocorrelationTimeSeries, self.__autocorrelation negT = -np.flipud(self.timeSeries[1:]) autocorrelationTime = np.hstack((negT, self.timeSeries)) self.__autocorrelationTimeSeries = autocorrelationTime initialWF = self[0] ACF = [] for WF in self: ACF.append(WF.overlap(initialWF)) ACF = np.array(ACF) negACF = np.conj(np.flipud(ACF[1:])) totalACF = np.hstack((negACF, ACF)) self.__autocorrelation = totalACF return self.__autocorrelationTimeSeries, self.__autocorrelation
def _applyImageFlips(image, flips): ''' Apply left-right and up-down flips to an image Args: image (numpy array 2D/3D): image to be flipped flips (tuple): [0]: Boolean to flip horizontally [1]: Boolean to flip vertically Returns: Flipped image ''' image = np.fliplr(image) if flips[0] else image image = np.flipud(image) if flips[1] else image return image
def convolve1d_2D_numpy(a, b, mode='full'): nwords, ndim = a.shape filter_width, ndim = b.shape b = np.flipud(b) # flip the kernel if mode == 'full': pad = np.zeros((filter_width-1, ndim)) a = np.vstack([pad, a, pad]) shape = (nwords+filter_width-1, filter_width, ndim) elif mode == 'valid': shape = (nwords-filter_width+1, filter_width, ndim) strides = (a.strides[0],) + a.strides view = np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides) conv_out = np.einsum('kij,ij->kj', view, b) return conv_out
def captureLabelImage(self, filename): view = self.view self.disableLighting() im = sgp.saveScreenshot(view, filename, shouldRender=False, shouldWrite=False) if filename is not None: img = vnp.getNumpyFromVtk(im, 'ImageScalars') assert img.dtype == np.uint8 img.shape = (im.GetDimensions()[1], im.GetDimensions()[0], 3) img = np.flipud(img) img = img[:,:,0] print 'writing:', filename scipy.misc.imsave(filename, img) return im
def _plot_displacement(ms): if not plot: ms.down return import matplotlib.pyplot as plt from matplotlib.patches import Polygon fig = plt.figure() ax = fig.gca() ms.processSources() ax.imshow(num.flipud(ms.down), aspect='equal', extent=[0, ms.frame.E.max(), 0, ms.frame.N.max()]) for src in ms.sources: for seg in src.segments: p = Polygon(seg.outline(), alpha=.8, fill=False) ax.add_artist(p) if isinstance(src, OkadaPath): nodes = num.array(src.nodes) ax.scatter(nodes[:, 0], nodes[:, 1], color='r') plt.show() fig.clear()
def _plot_displacement(ms): if not plot: ms.down return import matplotlib.pyplot as plt from matplotlib.patches import Polygon # noqa fig = plt.figure() ax = fig.gca() ms.processSources() ax.imshow(num.flipud(ms.north), aspect='equal', extent=[0, ms.frame.E.max(), 0, ms.frame.N.max()]) # for src in ms.sources: # for seg in src.segments: # p = Polygon(seg.outline(), alpha=.8, fill=False) # ax.add_artist(p) plt.show() fig.clear()
def img_reshape(input_img): """ (3, 64, 64) --> (64, 64, 3) """ _img = np.transpose(input_img, (1, 2, 0)) _img = np.flipud(_img) _img = np.reshape(_img, (1, img_dim[0], img_dim[1], img_dim[2])) return _img
def flip_plane(array,plane=0): # Flip axial plane LR, i.e. change left/right hemispheres. 3D tensors-only, batch_size=1. # n_slices = array.shape[2] # for i in range(n_slices): # array[:,:,i] = np.flipud(array[:,:,i]) # return array n_x = array.shape[plane] for i in range(n_x): if plane == 0: array[i,:,:] = np.flipud(array[i,:,:]) if plane == 1: array[:,i,:] = np.flipud(array[:,i,:]) if plane == 2: array[:,:,i] = np.flipud(array[:,:,i]) return array
def _trim_silence(self, audio: ndarray) -> ndarray: def trim_start(sound: ndarray) -> ndarray: return numpy.array(list(dropwhile(lambda x: x < self.silence_threshold_for_not_normalized_sound, sound))) def trim_end(sound: ndarray) -> ndarray: return flipud(trim_start(flipud(sound))) return trim_start(trim_end(audio))
def write_SSR_IRs(filename, time_data_l, time_data_r, wavformat="float"): """Takes two time signals and writes out the horizontal plane as HRIRs for the SoundScapeRenderer. Ideally, both hold 360 IRs but smaller sets are tried to be scaled up using repeat. Parameters ---------- filename : string filename to write to time_data_l, time_data_l : io.ArraySignal ArraySignals for left/right ear wavformat : string wav file format to write. Either "float" or "int16" """ equator_IDX_left = utils.nearest_to_value_logical_IDX(time_data_l.grid.colatitude, _np.pi / 2) equator_IDX_right = utils.nearest_to_value_logical_IDX(time_data_r.grid.colatitude, _np.pi / 2) IRs_left = time_data_l.signal.signal[equator_IDX_left] IRs_right = time_data_r.signal.signal[equator_IDX_right] if _np.mod(360 / IRs_left.shape[0], 1) == 0: IRs_left = _np.repeat(IRs_left, 360 / IRs_left.shape[0], axis=0) else: raise ValueError('Number of channels for left ear cannot be fit into 360.') if _np.mod(360 / IRs_right.shape[0], 1) == 0: IRs_right = _np.repeat(IRs_right, 360 / IRs_right.shape[0], axis=0) else: raise ValueError('Number of channels for left ear cannot be fit into 360.') IRs_to_write = utils.interleave_channels(IRs_left, IRs_right, style="SSR") data_to_write = utils.simple_resample(IRs_to_write, original_fs=time_data_l.signal.fs, target_fs=44100) # Fix SSR IR alignment stuff: left<>right flipped and 90 degree rotation data_to_write = _np.flipud(data_to_write) data_to_write = _np.roll(data_to_write, -90, axis=0) if wavformat == "float": sio.wavfile.write(filename, 44100, data_to_write.astype(_np.float32).T) elif wavformat == "int16": sio.wavfile.write(filename, 44100, (data_to_write * 32767).astype(_np.int16).T) else: raise TypeError("Format " + wavformat + "not known. Should be either 'float' or 'int16'.")
def parsedata(self, package): """ This function parses the Data Package sent by MuLES to obtain all the data available in MuLES as matrix of the size [n_samples, n_columns], therefore the total of elements in the matrix is n_samples * n_columns. Each column represents one channel Argument: package: Data package sent by MuLES. """ size_element = 4 # Size of each one of the elements is 4 bytes n_columns = len(self.params['data format']) n_bytes = len(package) n_samples = (n_bytes/size_element) / n_columns ####mesData = np.uint8(mesData) # Convert from binary to integers (not necessary pyton) bytes_per_element = np.flipud(np.reshape(list(bytearray(package)), [size_element,-1],order='F')) # Changes "package" to a list with size (n_bytes,1) # Reshapes the list into a matrix bytes_per_element which has the size: (4,n_bytes/4) # Flips Up-Down the matrix of size (4,n_bytes/4) to correct the swap in bytes package_correct_order = np.uint8(np.reshape(bytes_per_element,[n_bytes,-1],order='F' )) # Unrolls the matrix bytes_per_element, in "package_correct_order" # that has a size (n_bytes,1) data_format_tags = self.params['data format']*n_samples # Tags used to map the elements into their corresponding representation package_correct_order_char = "".join(map(chr,package_correct_order)) elements = struct.unpack(data_format_tags,package_correct_order_char) # Elements are cast in their corresponding representation data = np.reshape(np.array(elements),[n_samples,n_columns],order='C') # Elements are reshap into data [n_samples, n_columns] return data
def display_current_results(self, visuals, epoch): if self.display_id > 0: # show images in the browser idx = 1 for label, image_numpy in visuals.items(): #image_numpy = np.flipud(image_numpy) self.vis.image(image_numpy.transpose([2,0,1]), opts=dict(title=label), win=self.display_id + idx) idx += 1 if self.use_html: # save images to a html file for label, image_numpy in visuals.items(): img_path = os.path.join(self.img_dir, 'epoch%.3d_%s.png' % (epoch, label)) util.save_image(image_numpy, img_path) # update website webpage = html.HTML(self.web_dir, 'Experiment name = %s' % self.name, reflesh=1) for n in range(epoch, 0, -1): webpage.add_header('epoch [%d]' % n) ims = [] txts = [] links = [] for label, image_numpy in visuals.items(): img_path = 'epoch%.3d_%s.png' % (n, label) ims.append(img_path) txts.append(label) links.append(img_path) webpage.add_images(ims, txts, links, width=self.win_size) webpage.save() # errors: dictionary of error labels and values
def mirrorArray(self, x, direction="x"): X = x.reshape((self.nx_core, self.ny_core), order="F") if direction == "x" or direction == "y" : X2 = np.vstack((-np.flipud(X), X)) else: X2 = np.vstack((np.flipud(X), X)) return X2
