def filtfilt(b, a, x): #For now only accepting 1d arrays ntaps = max(len(a), len(b)) edge = ntaps * 3 if x.ndim != 1: raise ValueError, "Filiflit is only accepting 1 dimension arrays." #x must be bigger than edge if x.size < edge: raise ValueError, "Input vector needs to be bigger than 3 * max(len(a),len(b)." if len(a) < ntaps: a = pylab.r_[a, zeros(len(b) - len(a))] if len(b) < ntaps: b = pylab.r_[b, zeros(len(a) - len(b))] zi = lfilter_zi(b, a) #Grow the signal to have edges for stabilizing #the filter with inverted replicas of the signal s = pylab.r_[2 * x[0] - x[edge:1:-1], x, 2 * x[-1] - x[-1:-edge:-1]] #in the case of one go we only need one of the extrems # both are needed for filtfilt (y, zf) = ss.lfilter(b, a, s, -1, zi * s[0]) (y, zf) = ss.lfilter(b, a, pylab.flipud(y), -1, zi * y[-1]) return pylab.flipud(y[edge - 1:-edge + 1])
def pcolor(self, mode="mean", vmin=None, vmax=None): """ If you loaded the pickle data sets with only mean and sigma, the D and pvalue mode cannot be used. """ from pylab import clf, xticks, yticks, pcolor, colorbar, flipud, log10 if mode == "mean": data = self.get_mean() elif mode == "sigma": data = self.get_sigma() elif mode == "D": data = self.get_ks()[0] elif mode == "pvalue": data = self.get_ks()[1] clf(); if mode == "pvalue": pcolor(log10(flipud(data)), vmin=vmin, vmax=vmax); else: pcolor(flipud(data), vmin=vmin,vmax=vmax); colorbar() xticks([x+0.5 for x in range(0,8)], self.ligands, rotation=90) cellLines = self.cellLines[:] cellLines.reverse() yticks([x+0.5 for x in range(0,4)], cellLines, rotation=0)
def showVectorDisplacements(): global testImage, croppedRefImage, u, v, valid, q1, umean, vmean, x, y, sxyVar, wxyVar, goodvectorsVar from scipy import where, compress, logical_and, median, logical_or, nan from pylab import resize, transpose, quiver, title, show, find, imshow, hist, figure, clf, draw, save, load, xlabel, ylabel, flipud mxy = 3 wxy = int(wxyVar.get()) sxy = int(sxyVar.get()) goodvectors = float(goodvectorsVar.get()) #process to find PIV-style displacements x, y, u, v, q1, valid = simplepiv(croppedRefImage, testImage, wxy, mxy, sxy) good = where(logical_and(q1 > goodvectors, valid > 0), True, False) umean = median(compress(good.flat, u.flat)) vmean = median(compress(good.flat, v.flat)) u = where(logical_or(q1 < goodvectors, valid < 0), 0, u) v = where(logical_or(q1 < goodvectors, valid < 0), 0, v) u = u - umean v = v - vmean save('vecx.out', x) save('vecy.out', y) save('vecu.out', u) save('vecv.out', v) save('vecq1.out', q1) save('vecvalid.out', valid) u = flipud(u) v = -flipud(v) quiver(x, y, u, v) title('Vector displacements') xlabel('Pixels') ylabel('Pixels') show() return
def filtfilt(b,a,x): #For now only accepting 1d arrays ntaps=max(len(a),len(b)) edge=ntaps*3 if x.ndim != 1: raise ValueError, "Filiflit is only accepting 1 dimension arrays." #x must be bigger than edge if x.size < edge: raise ValueError, "Input vector needs to be bigger than 3 * max(len(a),len(b)." if len(a) < ntaps: a=pylab.r_[a,zeros(len(b)-len(a))] if len(b) < ntaps: b=pylab.r_[b,zeros(len(a)-len(b))] zi=lfilter_zi(b,a) #Grow the signal to have edges for stabilizing #the filter with inverted replicas of the signal s=pylab.r_[2*x[0]-x[edge:1:-1],x,2*x[-1]-x[-1:-edge:-1]] #in the case of one go we only need one of the extrems # both are needed for filtfilt (y,zf)=ss.lfilter(b,a,s,-1,zi*s[0]) (y,zf)=ss.lfilter(b,a,pylab.flipud(y),-1,zi*y[-1]) return pylab.flipud(y[edge-1:-edge+1])
def fft_based(input_signal, filter_coefficients, boundary=0): """applied fft if the signal is too short to be splitted in windows Params : input_signal : the audio signal filter_coefficients : coefficients of the chirplet bank boundary : manage the bounds of the signal Returns : audio signal with application of fast Fourier transform """ num_coeffs = filter_coefficients.size half_size = num_coeffs//2 if boundary == 0:#ZERO PADDING input_signal = np.lib.pad(input_signal, (half_size, half_size), 'constant', constant_values=0) filter_coefficients = np.lib.pad(filter_coefficients, (0, input_signal.size-num_coeffs), 'constant', constant_values=0) newx = ifft(fft(input_signal)*fft(filter_coefficients)) return newx[num_coeffs-1:-1] elif boundary == 1:#symmetric input_signal = concatenate([flipud(input_signal[:half_size]), input_signal, flipud(input_signal[half_size:])]) filter_coefficients = np.lib.pad(filter_coefficients, (0, input_signal.size-num_coeffs), 'constant', constant_values=0) newx = ifft(fft(input_signal)*fft(filter_coefficients)) return newx[num_coeffs-1:-1] else:#periodic return roll(ifft(fft(input_signal)*fft(filter_coefficients, input_signal.size)), -half_size).real
def postprocessCpData(data,geo,newxcount): x = data[:,0] y = geo[:,1] Cp = data[:,1] n = data.shape[0] # compute finite difference of x to classify points as upper and lower airfoil surface dx = pl.diff(x) dy = pl.diff(y) L = pl.sqrt(dx**2+dy**2) Tx = dx/L Ty = dy/L Nx = -Ty Ny = +Tx T = pl.array((Tx,Ty)) T = T.transpose() N = pl.array((Nx,Ny)) N = N.transpose() midx = (x[0:n-1]+x[1:n])/2.0 midy = (y[0:n-1]+y[1:n])/2.0 midcp = (Cp[0:n-1]+Cp[1:n])/2.0 Tnode = pl.zeros( (n,2), pl.float64) Nnode = pl.zeros( (n,2), pl.float64) for i in range(1,n-1): Tnode[i,:] = bisector( T[i-1,:], T[i,:] ) Nnode[i,:] = bisector( N[i-1,:], N[i,:] ) Tnode[0,:] = bisector( T[0,:], T[-1,:] ) Tnode[-1,:] = bisector( T[0,:], T[-1,:] ) Nnode[0,:] = bisector( N[i-1,:], N[i,:] ) Nnode[-1,:] = bisector( N[i-1,:], N[i,:] ) # determine (safe) limits of x for interpolation xmin = min( min(x[dx<0]),min(x[dx>=0]) ) xmax = max( max(x[dx<0]),max(x[dx>=0]) ) # re-compute lower and upper Cp at new abscissae if ChebyshevSpacing: xnew = pl.linspace(pl.pi, 0, newxcount) xnew = (pl.cos(xnew)+1)/2.0 else: xnew = pl.linspace(xmin, xmax, newxcount) newCpUpper = pl.interp(xnew, pl.flipud(x[dx<0]), pl.flipud(Cp[dx<0])) newCpLower = pl.interp(xnew, x[dx>=0], Cp[dx>=0]) return (x,y,Cp,L,T,N,midx,midy,midcp,Tnode,Nnode,xnew,newCpUpper,newCpLower)
def plot(self): """ .. plot:: :include-source: :width: 80% from cellnopt.simulate import * from cellnopt.core import * pkn = cnodata("PKN-ToyPB.sif") midas = cnodata("MD-ToyPB.csv") s = boolean.BooleanSimulator(CNOGraph(pkn, midas)) s.simulate(30) s.plot() """ pylab.clf() data = numpy.array([self.data[x] for x in self.species if x in self.species]) data = data.transpose() data = 1 - pylab.flipud(data) pylab.pcolor(data, vmin=0, vmax=1, edgecolors="k") pylab.xlabel("species"); pylab.ylabel("Time (tick)"); pylab.gray() pylab.xticks([0.5+x for x in range(0,30)], self.species, rotation=90) pylab.ylim([0, self.tick]) pylab.xlim([0, len(self.species)])
def __init_chirplet_filter_bank(self): """generate all the chirplets based on the attributes Returns : The bank of chirplets """ num_chirps = self._num_octaves * self._num_chirps_by_octave #create a list of coefficients based on attributes lambdas = 2.0**(1 + arange(num_chirps) / float(self._num_chirps_by_octave)) #Low frequencies for a signal start_frequencies = (self._samplerate / lambdas) / 2.0 #high frequencies for a signal end_frequencies = self._samplerate / lambdas durations = 2.0 * self._duration_longest_chirplet / flipud(lambdas) chirplets = list() for low_frequency, high_frequency, duration in zip( start_frequencies, end_frequencies, durations): chirplets.append( Chirplet(self._samplerate, low_frequency, high_frequency, duration, self._polynome_degree)) return chirplets
def getImages(filename,vname): file=NetCDF.NetCDFFile(filename,'r') vdata=file.variables[vname] vsize=vdata.shape[0] # create empty files subdirectory for output images try: shutil.rmtree('colorbarImages') except: pass os.makedirs('colorbarImages') # go through the whole dataset and generate a color bar image for each step for i in range(vsize): varray = vdata[i,:,:,] data=pylab.flipud(varray) pylab.imshow(data, norm=LogNorm()) imgNum = 'TimeStep_'+ str(i) if len(data[data>0])>0: #make a new figure that contains the colorbar fig=pylab.figure(figsize=(2,5)) ax1 = fig.add_axes([0.35, 0.03, 0.1, 0.9]) vmin=data[data>0].min() vmax=data.max() norm = LogNorm(vmin,vmax) #make the colorbar in log scale logFormatter=LogFormatter(10, labelOnlyBase=False) cb1 = ColorbarBase(ax1,norm=norm,format=logFormatter,spacing='proportional', orientation='vertical') imgName='colorbarImages/%s.png' %imgNum fig.savefig(imgName, bbox_inches='tight')
def fft_smoothing(input_signal, sigma): """smooth the fast transform Fourier Params : input_signal : audio signal sigma : relative to the length of the output signal Returns : a shorter and smoother signal """ size_signal = input_signal.size #shorten the signal new_size = int(floor(10.0 * size_signal * sigma)) half_new_size = new_size // 2 fftx = fft(input_signal) short_fftx = [] for ele in fftx[:half_new_size]: short_fftx.append(ele) for ele in fftx[-half_new_size:]: short_fftx.append(ele) apodization_coefficients = generate_apodization_coeffs( half_new_size, sigma, size_signal) #apply the apodization coefficients short_fftx[:half_new_size] *= apodization_coefficients short_fftx[half_new_size:] *= flipud(apodization_coefficients) realifftxw = ifft(short_fftx).real return realifftxw
def horizFlipCheckBoxChanged(self, event): self.horizFlip = self.ui.horizFlipCheckBox.isChecked() if hasattr(self, 'meas'): self.plotImage(pl.flipud(self.meas), autoLevels=self.autolevels, eqHist=self.equalizeHist, scale=self.scale)
def showContours_v(): global umean, vmean, modelgreylevelvar, goodvectorsVar, lowerLevelVar, upperLevelVar, tickvar, numcontourVar from scipy import zeros, where, logical_or, r_, argmin, shape, ravel, nan, compress, flipud from pylab import imshow, clf, title, save, load, figure, contourf, cm, hold, contour, xlabel, ylabel x = load('vecx.out.npy') y = load('vecy.out.npy') u = load('vecu.out.npy') v = load('vecv.out.npy') q1 = load('vecq1.out.npy') valid = load('vecvalid.out.npy') modelgreylevel = float(modelgreylevelVar.get()) goodvectors = float(goodvectorsVar.get()) v = where(logical_or(q1 < goodvectors, valid < 0), modelgreylevel, v) v = -flipud(v) lowerLevel = float(lowerLevelVar.get()) upperLevel = float(upperLevelVar.get()) numcontour = int(numcontourVar.get()) tick = float(upperLevel - lowerLevel) / numcontour vv = r_[lowerLevel:upperLevel:tick] figure() contourf(x, y, v, vv, cmap=cm.gray) contourf(x, y, v, vv, cmap=cm.gray) xlabel('Pixels') ylabel('Pixels') return
def solve(f1, f2, f3, f4, a, b, h, tol, max_steps): """ uxx(x,yt) + uyy(x,y) = 0 on R = {(x,y): 0 <= x <= a, 0 <= y <= b}, u(x,0) = f1(x), u(x,b) = f2(x) for 0 <= x <= a, u(0,y) = f3(y), u(a,y) = f4(y) for 0 <= y <= b, :param f1: u(x,0) :param f2: u(x,b) :param f3: u(0,y) :param f4: u(a,y) :param a: right boundary for x :param b: right boundary for y :param h: step :param tol: maximum delta :param max_steps: max count of steps :return: x - vector of x coordinates, y - vector of y coordinates, u - result (matrix of z coordinates) """ # initialize parameters in u n = int(a / h) + 1 m = int(b / h) + 1 ave = (a * (f1(0) + f2(0)) + b * (f3(0) + f4(0))) / (2 * a + 2 * b) u = ave * pylab.ones((n, m)) # boundary conditions u[0, :] = [f3(i * h) for i in range(0, m)] u[n - 1, :] = [f4(i * h) for i in range(0, m)] u[:, 0] = [f1(i * h) for i in range(0, n)] u[:, m - 1] = [f2(i * h) for i in range(0, n)] u[0, 0] = (u[0, 1] + u[1, 0]) / 2 u[0, m - 1] = (u[0, m - 2] + u[1, m - 1]) / 2 u[n - 1, 0] = (u[n - 2, 0] + u[n - 1, 1]) / 2 u[n - 1, m - 1] = (u[n - 2, m - 1] + u[n - 1, m - 2]) / 2 # The parameter of consistent method of relax w = 4 / (2 + math.sqrt(4 - (math.cos(math.pi / (n - 1)) + math.cos(math.pi / (m - 1)))**2)) # Improved approximation operator purification throughout the lattice error = 1 count = 0 while error > tol and count <= max_steps: error = 0 for j in range(1, m - 1): for i in range(1, n - 1): relax = w * (u[i][j + 1] + u[i][j - 1] + u[i + 1][j] + u[i - 1, j] - 4 * u[i][j]) / 4 u[i, j] += relax if error <= math.fabs(relax): error = math.fabs(relax) count += 1 x = [i * h for i in range(n)] y = [i * h for i in range(m)] u = pylab.flipud(pylab.transpose(u)) return x, y, u
def MFarray_to_plotarray(mfarray, maskvalue, orientation, rcl): '''Create a 2d plotting array from a 3d modflow array. mfarray: a 3d modflow array maskvalue: the value to mask (e.g. hdry) orientation: 'layer' 'row' or 'column' rcl: the layer row or column ''' rcl = rcl - 1 nlay, nrow, ncol = shape(mfarray) if (orientation == 'layer'): Z = flipud(mfarray[rcl, :, :]).copy() elif (orientation == 'row'): Z = flipud(mfarray[:, rcl, :]).copy() elif (orientation == 'column'): Z = flipud(mfarray[:, :, rcl]).copy() Z = ma.masked_where(Z == maskvalue, Z) return Z
def MFarray_to_plotarray(mfarray,maskvalue,orientation,rcl): '''Create a 2d plotting array from a 3d modflow array. mfarray: a 3d modflow array maskvalue: the value to mask (e.g. hdry) orientation: 'layer' 'row' or 'column' rcl: the layer row or column ''' rcl=rcl-1 nlay,nrow,ncol=shape(mfarray) if(orientation=='layer'): Z=flipud(mfarray[rcl,:,:]).copy() elif(orientation=='row'): Z=flipud(mfarray[:,rcl,:]).copy() elif(orientation=='column'): Z=flipud(mfarray[:,:,rcl]).copy() Z=ma.masked_where(Z == maskvalue,Z) return Z
def importfile(self,fname,params): # if even more sophisticated things are needed, just inherit THzTdData class #and override the importfile method #try to load the file with name fname #it should be possible to write this shorter try: #if no Y_col is specified if params.has_key('Y_col'): #import it right away if params['dec_sep']=='.': data=py.loadtxt(fname, usecols=(params['time_col'], params['X_col'], params['Y_col']), skiprows=params['skiprows']) elif params['dec_sep']==',': #if the decimal separator is , do a replacement str2float=lambda val: float(val.replace(',','.')) data=py.loadtxt(fname, converters={params['time_col']:str2float, params['X_col']:str2float, params['Y_col']:str2float}, usecols=(params['time_col'], params['X_col'], params['Y_col']), skiprows=params['skiprows']) else: #import it right away if params['dec_sep']=='.': data=py.loadtxt(fname, usecols=(params['time_col'], params['X_col']), skiprows=params['skiprows']) elif params['dec_sep']==',': #if the decimal separator is , do a replacement str2float=lambda val: float(val.replace(',','.')) data=py.loadtxt(fname, converters={params['time_col']:str2float, params['X_col']:str2float}, usecols=(params['time_col'], params['X_col']), skiprows=params['skiprows']) dummy_Y=py.zeros((data.shape[0],1)) data=py.column_stack((data,dummy_Y)) except IOError: print "File " + fname + " could not be loaded" sys.exit() #scale the timaaxis data[:,0]*=params['time_factor'] #if the measurement was taken in negative time direction, flip the data if data[1,0]-data[0,0]<0: data=py.flipud(data) return data
def dependency_matrix(self, fontsize=12): r"""Return dependency matrix * :math:`D_{i,j}` = green ; species i is an activator of species j (only positive path) * :math:`D_{i,j}` = red ; species i is an inhibitor of species j (only negative path) * :math:`D_{i,j}` = yellow; ambivalent (positive and negative paths connecting i and j) * :math:`D_{i,j}` = red ; species i has no influence on j .. plot:: :include-source: :width: 80% from cno import XCNOGraph, cnodata c = XCNOGraph(cnodata("PKN-ToyPB.sif"), cnodata("MD-ToyPB.csv")) c.dependency_matrix() """ nodes = sorted(self.nodes()) N = len(nodes) data = np.zeros((len(nodes), len(nodes))) for i,node1 in enumerate(nodes): paths = nx.shortest_path(self, node1) for j,node2 in enumerate(nodes): if node1 == node2: data[i][j] = 0 elif node2 not in paths.keys(): data[i][j] = 0 else: path = paths[node2] links = [self.edge[path[ii]][path[ii+1]]["link"] for ii in range(0,len(path)-1)] if len(np.unique(links)) == 2: data[i][j] = 1 # yellow elif "+" in links: data[i][j] = 2 #green elif "-" in links: if links.count("-") % 2 ==0: data[i][j] = 2 else: data[i][j] = 3 #red nodeNames = [node.replace("_", "\_") for node in nodes] nodeNamesY = [node.replace("_", "\_") for node in nodes] norm = colors.Normalize(vmin=0, vmax=3) cmap = colors.ListedColormap([[0., 0, 0], [1,1,0],[.5, 1, 0.], [1., 0, 0.]]) indices = [i for i, node in enumerate(nodes) if "and" not in node or "+" in nodes] pylab.clf() pylab.pcolor(pylab.flipud(data[indices][:,indices]), edgecolors="w", cmap=cmap, norm=norm); N = len(indices) nodeNames = np.array(nodeNames)[indices] nodeNamesY = np.array(nodeNamesY)[indices[::-1]]
def create_raster(lon, lat, variable, split, lon_split=None, left=None): if split: if left: lon = lon[:, 0:lon_split] lat = lat[:, 0:lon_split] variable = flipud(variable[:, 0:lon_split]) tif_suffix = "_left.tif" else: lon_split += 1 lon = lon[:, lon_split:-1] lat = lat[:, lon_split:-1] variable = flipud(variable[:, lon_split:-1]) tif_suffix = "_right.tif" else: variable = flipud(variable) tif_suffix = ".tif" not_in_germany = ((lon > globals.min_lon) & (lon < globals.max_lon) & (lat > globals.min_lat) & (lat < globals.max_lat)).sum() == 0 if not_in_germany: return # For each pixel I know it's latitude and longitude. # As you'll see below you only really need the coordinates of # one corner, and the resolution of the file. # That's (top left x, w-e pixel resolution, rotation (0 if North is up), # top left y, rotation (0 if North is up), n-s pixel resolution) xmin, ymin, xmax, ymax = [lon.min(), lat.min(), lon.max(), lat.max()] nrows, ncols = np.shape(variable) xres = (xmax - xmin) / float(ncols) yres = (ymax - ymin) / float(nrows) geotransform = (xmin, xres, 0, ymax, 0, -yres) output_raster = gdal.GetDriverByName('GTiff').Create( os.path.join(root, file.replace(".nc", tif_suffix)), ncols, nrows, 1, gdal.GDT_Float32) # Open the file output_raster.SetGeoTransform(geotransform) # Specify its coordinates srs = osr.SpatialReference() # Establish its coordinate encoding srs.ImportFromEPSG(4326) # This one specifies WGS84 lat long. output_raster.SetProjection( srs.ExportToWkt()) # Exports the coordinate system to the file output_raster.GetRasterBand(1).WriteArray( variable) # Writes my array to the raster
def solve(f1, f2, f3, f4, a, b, h, tol, max_steps): """ uxx(x,yt) + uyy(x,y) = 0 on R = {(x,y): 0 <= x <= a, 0 <= y <= b}, u(x,0) = f1(x), u(x,b) = f2(x) for 0 <= x <= a, u(0,y) = f3(y), u(a,y) = f4(y) for 0 <= y <= b, :param f1: u(x,0) :param f2: u(x,b) :param f3: u(0,y) :param f4: u(a,y) :param a: right boundary for x :param b: right boundary for y :param h: step :param tol: maximum delta :param max_steps: max count of steps :return: x - vector of x coordinates, y - vector of y coordinates, u - result (matrix of z coordinates) """ # initialize parameters in u n = int(a / h) + 1 m = int(b / h) + 1 ave = (a * (f1(0) + f2(0)) + b * (f3(0) + f4(0))) / (2 * a + 2 * b) u = ave * pylab.ones((n, m)) # boundary conditions u[0, :] = [f3(i * h) for i in range(0, m)] u[n - 1, :] = [f4(i * h) for i in range(0, m)] u[:, 0] = [f1(i * h) for i in range(0, n)] u[:, m - 1] = [f2(i * h) for i in range(0, n)] u[0, 0] = (u[0, 1] + u[1, 0]) / 2 u[0, m - 1] = (u[0, m - 2] + u[1, m - 1]) / 2 u[n - 1, 0] = (u[n - 2, 0] + u[n - 1, 1]) / 2 u[n - 1, m - 1] = (u[n - 2, m - 1] + u[n - 1, m - 2]) / 2 # The parameter of consistent method of relax w = 4 / (2 + math.sqrt(4 - (math.cos(math.pi / (n - 1)) + math.cos(math.pi / (m - 1))) ** 2)) # Improved approximation operator purification throughout the lattice error = 1 count = 0 while error > tol and count <= max_steps: error = 0 for j in range(1, m - 1): for i in range(1, n - 1): relax = w * (u[i][j + 1] + u[i][j - 1] + u[i + 1][j] + u[i - 1, j] - 4 * u[i][j]) / 4 u[i, j] += relax if error <= math.fabs(relax): error = math.fabs(relax) count += 1 x = [i * h for i in range(n)] y = [i * h for i in range(m)] u = pylab.flipud(pylab.transpose(u)) return x, y, u
def montage(I): xdim, ydim, zdim = shape(I) nimages_x = int(ceil(sqrt(xdim))) nimages_y = int(ceil(sqrt(ydim))) nimages_z = int(ceil(sqrt(zdim))) Mx = zeros((nimages_x * zdim, nimages_x * ydim)) My = zeros((nimages_y * zdim, nimages_y * xdim)) Mz = zeros((nimages_z * ydim, nimages_z * xdim)) # Sagittal (x) # switch i2 and i1 for loops to have the slice sequence # progress vertically rather than horizontally. xcount = 0 for i1 in range(nimages_x): for i2 in range(nimages_x): xcount += 1 if xcount < xdim: Mx[ i1*zdim : (i1+1)*zdim, i2*ydim : (i2+1)*ydim ] = rot90(I[xdim-xcount,::-1,:],1) else: break # Coronal (y) ycount = 0 for i1 in range(nimages_y): for i2 in range(nimages_y): ycount += 1 if ycount < ydim: My[ i1*zdim : (i1+1)*zdim, i2*xdim : (i2+1)*xdim ] = flipud(I[::-1,ydim-ycount,:].transpose()) else: break # Horizontal (z) zcount = 0 for i1 in range(nimages_z): for i2 in range(nimages_z): zcount += 1 if zcount < zdim: Mz[ i1*ydim : (i1+1)*ydim, i2*xdim : (i2+1)*xdim ] = flipud(I[:,:,zdim-zcount].transpose()) else: break return Mx, My, Mz, xdim, ydim, zdim, nimages_x, nimages_y, nimages_z
def histogram_u_v(): from pylab import figure, hist, title, load, xlabel, ylabel from scipy import where, logical_or, flipud u = load('vecu.out.npy') v = load('vecv.out.npy') u = flipud(u) v = -flipud(v) figure() hist(u, 100) title('Frequency Distribution of horizontal displacements data') xlabel('Horizontal Displacement in Pixels') ylabel('Frequency') figure() hist(v, 100) title('Frequency Distribution of vertical displacements data') xlabel('Vertical Displacement in Pixels') ylabel('Frequency')
def test_colorbar(): # Builtin colourmap "seismic" has the blue-white-red # scale you want a = np.zeros((16, 16), dtype=np.float32) a[0, 0] = 1.0 b = np.ones((16, 16), dtype=np.float32) * 0.5 b[0, 0] = 1.0 fig = plt.figure() plt.subplot(121, aspect='equal') # plt.pcolor(data, cmap=plt.cm.seismic, vmin=0, vmax=2) plt.pcolor(flipud(a), cmap='hot', vmin=0, vmax=1) plt.colorbar() plt.subplot(122, aspect='equal') plt.pcolor(flipud(b), cmap='hot', vmin=0, vmax=1) plt.colorbar() pp = PdfPages("test_colorbar.pdf") pp.savefig(fig) pp.close()
def save_sonogram( self, replace=False, n_fft=settings.N_FFT, min_freq=settings.MIN_FREQ, max_freq=settings.MAX_FREQ, dpi=100, width=1000, height=350, max_framerate=settings.MAX_FRAMERATE, ): filename = self.get_sonogram_name() name = os.path.join(settings.SONOGRAM_DIR, filename) path = os.path.join(settings.MEDIA_ROOT, name) try: if not os.path.exists(path): replace = True except (ValueError, SuspiciousOperation, AttributeError): replace = True if replace: audio, framerate = self.get_audio(max_framerate=max_framerate) Pxx, freqs, bins, im = specgram(audio, NFFT=n_fft, Fs=framerate) f = where(logical_and(freqs > min_freq, freqs <= max_freq))[0] Pxx[where(Pxx > percentile(Pxx[f].flatten(), 99.99))] = percentile(Pxx[f].flatten(), 99.99) Pxx[where(Pxx < percentile(Pxx[f].flatten(), 0.01))] = percentile(Pxx[f].flatten(), 0.01) clf() fig = figure(figsize=(float(width) / dpi, float(height) / dpi), dpi=dpi) imshow( flipud(10 * log10(Pxx[f,])), extent=(bins[0], bins[-1], freqs[f][0], freqs[f][-1]), aspect="auto", cmap=cm.gray, ) gca().set_ylabel("Frequency (Hz)") gca().set_xlabel("Time (s)") axis_pixels = gca().transData.transform(np.array((gca().get_xlim(), gca().get_ylim())).T) st, created = SonogramTransform.objects.get_or_create( n_fft=n_fft, framerate=framerate, min_freq=min_freq, max_freq=max_freq, duration=self.duration, width=width, height=height, dpi=dpi, top_px=max(axis_pixels[:, 1]), bottom_px=min(axis_pixels[:, 1]), left_px=min(axis_pixels[:, 0]), right_px=max(axis_pixels[:, 0]), ) savefig(open(path, "wb"), format="jpg", dpi=dpi) sonogram, created = Sonogram.objects.get_or_create(snippet=self, transform=st, path=name) close()
def save_sonogram(self, replace=False, n_fft=settings.N_FFT, \ min_freq=settings.MIN_FREQ, \ max_freq=settings.MAX_FREQ, \ dpi=100, width=1000, height=350, max_framerate=settings.MAX_FRAMERATE): filename = self.get_sonogram_name() name = os.path.join(settings.SONOGRAM_DIR, filename) path = os.path.join(settings.MEDIA_ROOT, name) try: if not os.path.exists(path): replace = True except (ValueError, SuspiciousOperation, AttributeError): replace = True if replace: audio, framerate = self.get_audio(max_framerate=max_framerate) Pxx, freqs, bins, im = specgram(audio, NFFT=n_fft, Fs=framerate) f = where(logical_and(freqs > min_freq, freqs <= max_freq))[0] Pxx[where(Pxx > percentile(Pxx[f].flatten(), 99.99))] = percentile( Pxx[f].flatten(), 99.99) Pxx[where(Pxx < percentile(Pxx[f].flatten(), 0.01))] = percentile( Pxx[f].flatten(), 0.01) clf() fig = figure(figsize=(float(width) / dpi, float(height) / dpi), dpi=dpi) imshow(flipud(10 * log10(Pxx[f, ])), extent=(bins[0], bins[-1], freqs[f][0], freqs[f][-1]), aspect='auto', cmap=cm.gray) gca().set_ylabel('Frequency (Hz)') gca().set_xlabel('Time (s)') axis_pixels = gca().transData.transform( np.array((gca().get_xlim(), gca().get_ylim())).T) st, created = SonogramTransform.objects.get_or_create( n_fft=n_fft, framerate=framerate, min_freq=min_freq, max_freq=max_freq, duration=self.duration, width=width, height=height, dpi=dpi, top_px=max(axis_pixels[:, 1]), bottom_px=min(axis_pixels[:, 1]), left_px=min(axis_pixels[:, 0]), right_px=max(axis_pixels[:, 0]), ) savefig(open(path, 'wb'), format='jpg', dpi=dpi) sonogram, created = Sonogram.objects.get_or_create(snippet=self, transform=st, path=name) close()
def mhd_four_pane_2d(P, extent=[0,1,0,1], do_quiver=True, cmap=None, **kwargs): from pylab import flipud, subplot, title, colorbar, cm, imshow, quiver, matplotlib from numpy import sqrt, linspace, meshgrid rho, pre = P[:,:,0], P[:,:,1] vx, vy, vz = P[:,:,2], P[:,:,3], P[:,:,4] Bx, By, Bz = P[:,:,5], P[:,:,6], P[:,:,7] B2 = Bx**2 + By**2 + Bz**2 v2 = vx**2 + vy**2 + vz**2 W = 1.0 / sqrt(1.0 - v2) if type(cmap) is str: from pickle import load cmap = load(open('rmhd/data/cmaps.pk'))[cmap] elif isinstance(cmap, matplotlib.colors.Colormap): pass else: cmap = cm.hot imargs = {'extent':extent, 'cmap':cmap, 'interpolation':'bilinear'} imargs.update(kwargs) tr = lambda x: flipud(x.T) subplot(2,2,1) imshow(tr(rho), **imargs) colorbar() title("Density") subplot(2,2,2) imshow(tr(pre), **imargs) colorbar() title("Pressure") subplot(2,2,3) imshow(tr(B2), **imargs) colorbar() title("Magnetic Pressure") subplot(2,2,4) imshow(tr(W), **imargs) colorbar() title("Lorentz Factor") if do_quiver: N = 10 X,Y = meshgrid(linspace(extent[0],extent[1],W.shape[0]), linspace(extent[2],extent[3],W.shape[1])) quiver(X[::N,::N], Y[::N,::N], Bx[::N,::N].T, By[::N,::N].T, color='y') """
def jetWoGn(reverse=False): """ jetWoGn(reverse=False) - returning a colormap similar to cm.jet, but without green. if reverse=True, the map starts with red instead of blue. """ m=18 # magic number, which works fine m0=pl.floor(m*0.0) m1=pl.floor(m*0.2) m2=pl.floor(m*0.2) m3=pl.floor(m/2)-m2-m1 b_ = np.hstack( (0.4*np.arange(m1)/(m1-1.)+0.6, np.ones((m2+m3,)) ) ) g_ = np.hstack( (np.zeros((m1,)),np.arange(m2)/(m2-1.),np.ones((m3,))) ) r_ = np.hstack( (np.zeros((m1,)),np.zeros((m2,)),np.arange(m3)/(m3-1.))) r = np.hstack((r_,pl.flipud(b_))) g = np.hstack((g_,pl.flipud(g_))) b = np.hstack((b_,pl.flipud(r_))) if reverse: r = pl.flipud(r) g = pl.flipud(g) b = pl.flipud(b) ra = pl.linspace(0.0,1.0,m) cdict = {'red': zip(ra,r,r), 'green': zip(ra,g,g), 'blue': zip(ra,b,b)} return pl.matplotlib.colors.LinearSegmentedColormap('new_RdBl',cdict,256)
def __call__(self,**params): p=ParamOverrides(self,params) for template in p.plot_template: for sheet in topo.sim.objects(Sheet).values(): name=template.keys().pop(0) plot=make_template_plot(template,sheet.sheet_views,sheet.xdensity,sheet.bounds,p.normalize,name=template[name]) if plot: bitmap=plot.bitmap pylab.figure(figsize=(5,5)) isint=pylab.isinteractive() # Temporarily make non-interactive for plotting pylab.ioff() # Turn interactive mode off pylab.imshow(bitmap.image,origin='lower',interpolation='nearest') pylab.axis('off') for (t,pref,sel,c) in p.overlay: v = pylab.flipud(sheet.sheet_views[pref].view()[0]) if (t=='contours'): pylab.contour(v,[sel,sel],colors=c,linewidths=2) if (t=='arrows'): s = pylab.flipud(sheet.sheet_views[sel].view()[0]) scale=int(pylab.ceil(log10(len(v)))) X=pylab.array([x for x in xrange(len(v)/scale)]) v_sc=pylab.zeros((len(v)/scale,len(v)/scale)) s_sc=pylab.zeros((len(v)/scale,len(v)/scale)) for i in X: for j in X: v_sc[i][j]=v[scale*i][scale*j] s_sc[i][j]=s[scale*i][scale*j] pylab.quiver(scale*X,scale*X,-cos(2*pi*v_sc)*s_sc,-sin(2*pi*v_sc)*s_sc,color=c,edgecolors=c,minshaft=3,linewidths=1) p.title='%s overlaid with %s at time %s' %(plot.name,pref,topo.sim.timestr()) if isint: pylab.ion() p.filename_suffix="_"+sheet.name self._generate_figure(p)
def plot_adjacency_matrix(self, fontsize=12, **kargs): """Plots adjacency matrix :param kargs: optional arguments accepted by pylab.pcolor From the following graph, .. plot:: :width: 70% from cno import XCNOGraph, cnodata c = XCNOGraph(cnodata("PKN-ToyMMB.sif"), cnodata("MD-ToyMMB.csv")) c.plot() The adjacency matrix can be created as follows: .. plot:: :width: 70% :include-source: from cno import XCNOGraph, cnodata c = XCNOGraph(cnodata("PKN-ToyMMB.sif"), cnodata("MD-ToyMMB.csv")) c.plot_adjacency_matrix() """ nodeNames = sorted(self.nodes()) nodeNamesY = sorted(self.nodes()) nodeNamesY.reverse() N = len(nodeNames) data = self.adjacency_matrix(nodelist=nodeNames) # This is now a sparse matrix (networkx 1.9). try: data = data.todense() except: pass pylab.pcolor(pylab.flipud(pylab.array(data)), edgecolors="k", **kargs) pylab.axis([0, N, 0, N]) pylab.xticks([0.5+x for x in pylab.arange(N)], nodeNames, rotation=90, fontsize=fontsize) pylab.yticks([0.5+x for x in pylab.arange(N)], nodeNamesY, rotation=0, fontsize=fontsize) try:pylab.tight_layout() except:pass
def retrieve_shakemap(event, shake_map_type): import pylab if shake_map_type not in SHAKEMAPS: raise ShakemapNotFound("Use one of %s shakemap types" % SHAKEMAPS.keys()) eqid = event["Eqid"] rfile = httputil.RemoteFile(SHAKEMAPS[shake_map_type] % eqid) rfile.update() fhandle = open(rfile.filename, "r") head = fhandle.read(300) fhandle.close() if head.find("File Not Found (404)") >= 0: raise ShakemapNotAvailable("Shakemap not available for this event !") img = pylab.imread(rfile.filename) pylab.imshow(pylab.flipud(img)) pylab.show()
def loadImage(self, file): if file in self.dictFileImage: return self.dictFileImage[file]; else: id = self.totalImages; pixels = pylab.flipud(pylab.imread(file)); # SIFT features partName, partDot, partExt = file.rpartition('.'); keyFile = ''.join(partName + partDot + "key"); pgmFile = ''.join(partName + partDot + "pgm"); if os.path.exists(pgmFile) == False: #pylab.imsave(pgmFile, pixels); if len(pixels.shape) == 2: pilImage = Image.fromarray(pixels, 'L'); else: h = pixels.shape[0]; w = pixels.shape[1]; pixelsGray = np.matrix(np.zeros((h, w)), dtype=np.uint8); for i in range(h): for j in range(w): pixelsGray[i, j] = (np.mean(pixels[i, j])).astype(np.uint8); pilImage = Image.fromarray(pixelsGray, 'L'); pilImage.save(pgmFile); if os.path.exists(keyFile) == False: sift.process_image(pgmFile, keyFile); loc, des = sift.read_features_from_file(keyFile); #im.features = [Feature(im.id, des[i], loc[i]) for i in range(len(des))]; #print "Total features: ", len(im.features) im = ImageObject(id, pixels, loc, des); # add to dictionary self.dictFileImage[file] = im; self.dictIdImage[im.id] = im; # increase total images self.totalImages += 1; #print "Total images: ", self.totalImages; return im;
def hyd_four_pane_2d(P, extent=[0,1,0,1], do_quiver=True, cmap=None, **kwargs): from pylab import flipud, subplot, title, colorbar, cm, imshow, quiver, matplotlib from numpy import sqrt, linspace, meshgrid rho, pre = P[:,:,0], P[:,:,1] vx, vy, vz = P[:,:,2], P[:,:,3], P[:,:,4] if type(cmap) is str: from pickle import load cmap = load(open('rmhd/data/cmaps.pk'))[cmap] elif isinstance(cmap, matplotlib.colors.Colormap): pass else: cmap = cm.hot imargs = {'extent':extent, 'cmap':cmap, 'interpolation':'bilinear'} imargs.update(kwargs) tr = lambda x: flipud(x.T) subplot(2,2,1) imshow(tr(rho), **imargs) colorbar() title("Density") subplot(2,2,2) imshow(tr(pre), **imargs) colorbar() title("Pressure") subplot(2,2,3) imshow(tr(vx), **imargs) colorbar() title("X-Velocity") subplot(2,2,4) imshow(tr(vy), **imargs) colorbar() title("Y-Velocity")
def qimplot(image=None, rmin=-2, rmax=2, cmap='gray'): """ qimplot: Quick Image Plot Plots image in grayscale. Colorscale is from rmin*RMS to rmax*RMS. Defaults: rmin = -2 rmax = +2 cmap = 'gray' Can be any of the usual cmap values, e.g. 'YlOrRd' or 'jet' """ logger = logging.getLogger('QIMPLOT') logger.info("Quick Image Plot") if image is None: logger.critical("Please provide input image!") pl.figure(figsize=(10, 10)) fits = miriad('fits') if not os.path.exists(image): logger.critical(image + " not found!") sys.exit(0) fits.in_ = image fits.out = image + '.fits' fits.op = 'xyout' fits.go(rmfiles=True) imheader = pyfits.open(image + '.fits') imdata = imheader[0].data rms = pl.rms_flat(imdata[0, 0, :, :]) logger.info('RMS = ' + "{:2.2}".format(rms)) logger.info("Plotting from " + str(rmin) + "*RMS to " + str(rmax) + str("*RMS")) pl.imshow(pl.flipud(imdata[0, 0, :, :]), cmap=cmap, vmin=rmin * rms, vmax=rmax * rms) pl.colorbar() pl.xticks(()) pl.yticks(())
def jetWoGn(reverse=False): """ jetWoGn(reverse=False) - returning a colormap similar to cm.jet, but without green. if reverse=True, the map starts with red instead of blue. """ m = 18 # magic number, which works fine m0 = pylab.floor(m * 0.0) m1 = pylab.floor(m * 0.2) m2 = pylab.floor(m * 0.2) m3 = pylab.floor(m / 2) - m2 - m1 b_ = pylab.hstack( (0.4 * pylab.arange(m1) / (m1 - 1.) + 0.6, pylab.ones((m2 + m3, )))) g_ = pylab.hstack((pylab.zeros( (m1, )), pylab.arange(m2) / (m2 - 1.), pylab.ones((m3, )))) r_ = pylab.hstack((pylab.zeros((m1, )), pylab.zeros( (m2, )), pylab.arange(m3) / (m3 - 1.))) r = pylab.hstack((r_, pylab.flipud(b_))) g = pylab.hstack((g_, pylab.flipud(g_))) b = pylab.hstack((b_, pylab.flipud(r_))) if reverse: r = pylab.flipud(r) g = pylab.flipud(g) b = pylab.flipud(b) ra = pylab.linspace(0.0, 1.0, m) cdict = { 'red': zip(ra, r, r), 'green': zip(ra, g, g), 'blue': zip(ra, b, b) } return LinearSegmentedColormap('new_RdBl', cdict, 256)
def plot_topo_file(topoplotdata): """ Read in a topo or bathy file and produce a pcolor map. """ deprecation_msg = "This function is being deprecated in favor of the " + \ "Topography class in clawpack.geoclaw.topotools and " + \ "plotting tools associated with it." warnings.filterwarnings('default', category=DeprecationWarning) warnings.warn(deprecation_msg, DeprecationWarning, stacklevel=2) warnings.resetwarnings() import os import pylab from clawpack.clawutil.data import ClawData fname = topoplotdata.fname topotype = topoplotdata.topotype if topoplotdata.climits: # deprecated option cmin = topoplotdata.climits[0] cmax = topoplotdata.climits[1] else: cmin = topoplotdata.cmin cmax = topoplotdata.cmax figno = topoplotdata.figno addcolorbar = topoplotdata.addcolorbar addcontour = topoplotdata.addcontour contour_levels = topoplotdata.contour_levels xlimits = topoplotdata.xlimits ylimits = topoplotdata.ylimits coarsen = topoplotdata.coarsen imshow = topoplotdata.imshow gridedges_show = topoplotdata.gridedges_show neg_cmap = topoplotdata.neg_cmap pos_cmap = topoplotdata.pos_cmap cmap = topoplotdata.cmap print_fname = topoplotdata.print_fname if neg_cmap is None: neg_cmap = colormaps.make_colormap({ cmin: [0.3, 0.2, 0.1], 0: [0.95, 0.9, 0.7] }) if pos_cmap is None: pos_cmap = colormaps.make_colormap({ 0: [.5, .7, 0], cmax: [.2, .5, .2] }) if cmap is None: cmap = colormaps.make_colormap({ -1: [0.3, 0.2, 0.1], -0.00001: [0.95, 0.9, 0.7], 0.00001: [.5, .7, 0], 1: [.2, .5, .2] }) #cmap = colormaps.make_colormap({-1:[0,0,1],0:[1,1,1],1:[1,0,0]}) if abs(topotype) == 1: X, Y, topo = topotools.topofile2griddata(fname, topotype) topo = pylab.flipud(topo) Y = pylab.flipud(Y) x = X[0, :] y = Y[:, 0] xllcorner = x[0] yllcorner = y[0] cellsize = x[1] - x[0] elif abs(topotype) == 3: file = open(fname, 'r') lines = file.readlines() ncols = int(lines[0].split()[0]) nrows = int(lines[1].split()[0]) xllcorner = float(lines[2].split()[0]) yllcorner = float(lines[3].split()[0]) cellsize = float(lines[4].split()[0]) NODATA_value = int(lines[5].split()[0]) print("Loading file ", fname) print(" nrows = %i, ncols = %i" % (nrows, ncols)) topo = pylab.loadtxt(fname, skiprows=6, dtype=float) print(" Done loading") if 0: topo = [] for i in range(nrows): topo.append(pylab.array(lines[6 + i], )) print('+++ topo = ', topo) topo = pylab.array(topo) topo = pylab.flipud(topo) x = pylab.linspace(xllcorner, xllcorner + ncols * cellsize, ncols) y = pylab.linspace(yllcorner, yllcorner + nrows * cellsize, nrows) print("Shape of x, y, topo: ", x.shape, y.shape, topo.shape) else: raise Exception("*** Only topotypes 1 and 3 supported so far") if coarsen > 1: topo = topo[slice(0, nrows, coarsen), slice(0, ncols, coarsen)] x = x[slice(0, ncols, coarsen)] y = y[slice(0, nrows, coarsen)] print("Shapes after coarsening: ", x.shape, y.shape, topo.shape) if topotype < 0: topo = -topo if figno: pylab.figure(figno) if topoplotdata.imshow: color_norm = Normalize(cmin, cmax, clip=True) xylimits = (x[0], x[-1], y[0], y[-1]) #pylab.imshow(pylab.flipud(topo.T), extent=xylimits, \ pylab.imshow(pylab.flipud(topo), extent=xylimits, \ cmap=cmap, interpolation='nearest', \ norm=color_norm) #pylab.clim([cmin,cmax]) if addcolorbar: pylab.colorbar() else: neg_topo = ma.masked_where(topo > 0., topo) all_masked = (ma.count(neg_topo) == 0) if not all_masked: pylab.pcolormesh(x, y, neg_topo, cmap=neg_cmap) pylab.clim([cmin, 0]) if addcolorbar: pylab.colorbar() pos_topo = ma.masked_where(topo < 0., topo) all_masked = (ma.count(pos_topo) == 0) if not all_masked: pylab.pcolormesh(x, y, pos_topo, cmap=pos_cmap) pylab.clim([0, cmax]) if addcolorbar: pylab.colorbar() pylab.axis('scaled') if addcontour: pylab.contour(x, y, topo, levels=contour_levels, colors='k') patchedges_show = True if patchedges_show: pylab.plot([x[0], x[-1]], [y[0], y[0]], 'k') pylab.plot([x[0], x[-1]], [y[-1], y[-1]], 'k') pylab.plot([x[0], x[0]], [y[0], y[-1]], 'k') pylab.plot([x[-1], x[-1]], [y[0], y[-1]], 'k') if print_fname: fname2 = os.path.splitext(fname)[0] pylab.text(xllcorner + cellsize, yllcorner + cellsize, fname2, color='m') topodata = ClawData() topodata.x = x topodata.y = y topodata.topo = topo return topodata
import sys, os import pylab sys.path.append('../../datatools') import dart # from the directory above gaugeno = 43412 fname = '43412_5day-03132011.txt' t1fit = 16500. t2fit = 18000. t1out = 16800 t2out = 17500. degree = 15 fname_notide = os.path.splitext(fname)[0] + '_notide.txt' t,eta = dart.plotdart(fname) t = pylab.flipud(t) eta = pylab.flipud(eta) c,t_notide,eta_notide = dart.fit_tide_poly(t,eta,degree,t1fit,t2fit, t1out,t2out) # Time of quake: 05:48:15 UTC on March 12, 2011 # Convert to minutes after start of March: t_quake = 11*24*60 + 5*60 + 48 + 15/60. #print "Time of quake = %7.2f minutes after start of March" % t_quake t_sec = (t_notide-t_quake)*60. d = pylab.vstack([t_sec,eta_notide]).T pylab.savetxt(fname_notide,d) print "Created file ",fname_notide #dart.plot_postquake(t_notide,eta_notide,t_quake,gaugeno)
from PIL import Image import pylab as p # This should work for any photo, but greyscale is probably better F=Image.open('MDP.jpg').convert('L') arr=p.flipud(p.array(F)) NY,NX=arr.shape x=p.arange(NX) y=p.arange(NY) p.gray() X,Y=p.meshgrid(x,y) def plot(sx,sy,n,**kwargs): print range(*sx.indices(NX)) arr_n=p.array([[p.mean(arr[x:x+n,y:y+n]) for x in range(*sx.indices(NY))] for y in range(*sy.indices(NX))]) print arr_n p.pcolormesh(X[sx,sy],Y[sx,sy],arr_n.T,vmin=0,vmax=255,**kwargs) # offsets to make specifying the "refined" areas easier
def makePalindrome(num, even): dec = decomp(num) if even: return fuse(r_[dec, flipud(dec)]) else: return fuse(r_[dec, flipud(dec[:-1])])
def startAcq(self): """ Function called when pressing the Start button. Will launch the integration loop and stay going as long as no stopping action has happened (pressing Stop button, closing the window, changed integration time). """ self.ui.stopBut.setEnabled(True) self.ui.startBut.setEnabled(False) camId = self.ui.cameraID.value() try: with StarlightCCD(camId) as self.ccd: self.meas = pl.zeros((self.ccd.ccdParams['height'], self.ccd.ccdParams['width'])) i = 0 # flags for the event loop startThread = True # needs to start a new acquisition self.plotMeas = False # needs to plot the acquisition (acq finished) self.acquire = True # CCD should be acquiring # wait for a loop to finish while self.acquiring: pass self.acquiring = True # the event loop below is active # acquisition event loop while self.acquire: if startThread: ccdThread = ExposureThread( self.ccd, self.exposureTime, ilAcq=self.ilAcq, ilCorrDoubleExpo=self.ilDoubleExpo) ccdThread.start() startThread = False if self.capture and self.exposureTime > 1: self.captureStartSound.play() #print 'start sound' if not ccdThread.is_alive(): # acquisition finished self.plotMeas = True startThread = True if self.plotMeas: self.meas = ccdThread.ccd.pixels.transpose() if self.ccd.ccdParams[ 'isInterlaced'] and not self.ilAcq: ##not self.ilAcq and self.scale = (1, 2) else: self.scale = (1, 1) # flip image according to user specification # note that due to pyqtgraph behaviour, the array # columns are the rows in the displayed image if self.horizFlip: self.meas = pl.flipud(self.meas) if self.vertFlip: self.meas = pl.fliplr(self.meas) # plot image preview self.plotImage(self.meas, autoLevels=self.autolevels, eqHist=self.equalizeHist, scale=self.scale) if self.capture: self.captureStopSound.play() #print 'stop sound' break # will stop and record file in self.stop() else: self.plotMeas = False # go for another acquisition if ccdThread.ccd.completionPercentage == 100 or i % 100 == 0: self.ui.progressBar.setValue( ccdThread.ccd.completionPercentage) self.displayStats() # process events to catch a stop push and refresh image preview self.app.processEvents() i = i + 1 #self.ui.progressBar.setValue(0) ccdThread.stop() while ccdThread.is_alive(): # wait before closing device pass self.acquiring = False except IndexError: self.ui.modelName.setText('No device') self.ccd = None finally: self.stop(userStop=False)
import warnings warnings.filterwarnings('ignore') import numpy import pylab data = numpy.loadtxt('/tmp/input.txt') pylab.figure(figsize=(6, 6)) pylab.xlabel('Destination Node') pylab.ylabel('Source Node') pylab.title('Adjacency Matrix') pylab.pcolor(pylab.flipud(data), cmap=pylab.get_cmap('binary')) pylab.xlim(0, len(data)) pylab.ylim(0, len(data)) pylab.savefig('/tmp/output.png')
from PIL import Image import cv2 import time import pylab as pl from scipy.misc import imresize, imfilter import turtle counter = 1 img = pl.flipud(pl.imread("inputImages/%05d.jpg" % counter)) levels = 8 size = 2**levels img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) turtle.setup(img.shape[1], img.shape[0]) img = imfilter(imresize(img, (size, size)), 'blur') turtle.setworldcoordinates(0, 0, size, -size) turtle.tracer(1000, 0) time.sleep(.5) # hilbert curve turtle code stolen from # falko's python example on stackoverflow # https://codegolf.stackexchange.com/questions/36374/redraw-an-image-with-just-one-closed-curve # define recursive hilbert curve def hilbert(level, angle=90): global img
def plot_topo(topoplotdata): """ Plot topo data as specified by topoplotdata. """ import os import pylab if topoplotdata.Z is None: topoplodata = read_topo(topoplotdata) x = topoplotdata.x y = topoplotdata.y topo = topoplotdata.Z X = topoplotdata.X Y = topoplotdata.Y xllcorner = x[0] yllcorner = y[0] cellsize = x[1]-x[0] fname = topoplotdata.fname topotype = topoplotdata.topotype if topoplotdata.climits: # deprecated option cmin = topoplotdata.climits[0] cmax = topoplotdata.climits[1] else: cmin = topoplotdata.cmin cmax = topoplotdata.cmax figno = topoplotdata.figno addcolorbar = topoplotdata.addcolorbar addcontour = topoplotdata.addcontour contour_levels = topoplotdata.contour_levels xlimits = topoplotdata.xlimits ylimits = topoplotdata.ylimits coarsen = topoplotdata.coarsen imshow = topoplotdata.imshow gridedges_show = topoplotdata.gridedges_show neg_cmap = topoplotdata.neg_cmap pos_cmap = topoplotdata.pos_cmap cmap = topoplotdata.cmap clf = topoplotdata.clf print_fname = topoplotdata.print_fname if neg_cmap is None: neg_cmap = colormaps.make_colormap({cmin:[0.3,0.2,0.1], -0.00001:[0.95,0.9,0.7], 0.00001:[.5,.7,0]}) if pos_cmap is None: pos_cmap = colormaps.make_colormap({ -0.00001:[0.95,0.9,0.7], 0.00001:[.5,.7,0], cmax:[.2,.5,.2]}) if cmap is None: cmap = colormaps.make_colormap({cmin:[0.3,0.2,0.1], -0.00001:[0.95,0.9,0.7], 0.00001:[.5,.7,0], cmax:[.2,.5,.2]}) #cmap = colormaps.make_colormap({-1:[0,0,1],0:[1,1,1],1:[1,0,0]}) #------------- if 0: if abs(topotype) == 1: X,Y,topo = topotools.topofile2griddata(fname, topotype) topo = pylab.flipud(topo) Y = pylab.flipud(Y) x = X[0,:] y = Y[:,0] xllcorner = x[0] yllcorner = y[0] cellsize = x[1]-x[0] elif abs(topotype) == 3: file = open(fname, 'r') lines = file.readlines() ncols = int(lines[0].split()[0]) nrows = int(lines[1].split()[0]) xllcorner = float(lines[2].split()[0]) yllcorner = float(lines[3].split()[0]) cellsize = float(lines[4].split()[0]) NODATA_value = int(lines[5].split()[0]) print "Loading file ",fname print " nrows = %i, ncols = %i" % (nrows,ncols) topo = pylab.loadtxt(fname,skiprows=6,dtype=float) print " Done loading" if 0: topo = [] for i in range(nrows): topo.append(pylab.array(lines[6+i],)) print '+++ topo = ',topo topo = pylab.array(topo) topo = pylab.flipud(topo) x = pylab.linspace(xllcorner, xllcorner+ncols*cellsize, ncols) y = pylab.linspace(yllcorner, yllcorner+nrows*cellsize, nrows) print "Shape of x, y, topo: ", x.shape, y.shape, topo.shape else: raise Exception("*** Only topotypes 1 and 3 supported so far") if topotype < 0: topo = -topo #------------------ ncols,nrows = topo.shape #import pdb; pdb.set_trace() if coarsen > 1: topo = topo[slice(0,nrows,coarsen), slice(0,ncols,coarsen)] X = X[slice(0,nrows,coarsen), slice(0,ncols,coarsen)] Y = Y[slice(0,nrows,coarsen), slice(0,ncols,coarsen)] x = x[slice(0,ncols,coarsen)] y = y[slice(0,nrows,coarsen)] print "Shapes after coarsening: ", x.shape, y.shape, topo.shape if figno: pylab.figure(figno) if clf: pylab.clf() if topoplotdata.imshow: color_norm = Normalize(cmin,cmax,clip=True) xylimits = (x[0],x[-1],y[0],y[-1]) #pylab.imshow(pylab.flipud(topo.T), extent=xylimits, \ pylab.imshow(topo, extent=xylimits, \ cmap=cmap, interpolation='nearest', \ norm=color_norm) #pylab.clim([cmin,cmax]) if addcolorbar: pylab.colorbar(shrink=0.5) else: neg_topo = ma.masked_where(topo>0., topo) all_masked = (ma.count(neg_topo) == 0) if not all_masked: pylab.pcolormesh(X,Y,neg_topo,cmap=neg_cmap) pylab.clim([cmin,0]) if addcolorbar: pylab.colorbar(shrink=0.5) pos_topo = ma.masked_where(topo<0., topo) all_masked = (ma.count(pos_topo) == 0) if not all_masked: pylab.pcolormesh(X,Y,pos_topo,cmap=pos_cmap) pylab.clim([0,cmax]) if addcolorbar: pylab.colorbar(shrink=0.5) pylab.axis('scaled') if addcontour: pylab.contour(X,Y,topo,levels=contour_levels,colors='k') patchedges_show = True if patchedges_show: pylab.plot([x[0],x[-1]],[y[0],y[0]],'k') pylab.plot([x[0],x[-1]],[y[-1],y[-1]],'k') pylab.plot([x[0],x[0]],[y[0],y[-1]],'k') pylab.plot([x[-1],x[-1]],[y[0],y[-1]],'k') if print_fname: fname2 = os.path.splitext(fname)[0] pylab.text(xllcorner+cellsize, yllcorner+cellsize, fname2, color='m') topodata = object() topodata.x = x topodata.y = y topodata.topo = topo return topodata
import pylab as pl from scipy.misc import imresize, imfilter import turtle # load image img = pl.flipud(pl.imread("face.png")) # setup turtle levels = 8 size = 2**levels turtle.setup(img.shape[1] * 4.2, img.shape[0] * 4.2) turtle.setworldcoordinates(0, 0, size, -size) turtle.tracer(1000, 0) # resize and blur image img = imfilter(imresize(img, (size, size)), 'blur') # define recursive hilbert curve def hilbert(level, angle=90): if level == 0: return if level == 1 and img[-turtle.pos()[1], turtle.pos()[0]] > 128: turtle.forward(2**level - 1) else: turtle.right(angle) hilbert(level - 1, -angle) turtle.forward(1) turtle.left(angle) hilbert(level - 1, angle) turtle.forward(1)
def plot_topo_file(topoplotdata): """ Read in a topo or bathy file and produce a pcolor map. """ import os import pylab from pyclaw.data import Data fname = topoplotdata.fname topotype = getattr(topoplotdata, 'topotype', 3) cmap = getattr(topoplotdata, 'cmap', bathy3_colormap) climits = getattr(topoplotdata, 'climits', [-50, 50]) figno = getattr(topoplotdata, 'figno', 200) addcolorbar = getattr(topoplotdata, 'addcolorbar', True) addcontour = getattr(topoplotdata, 'addcontour', False) contour_levels = getattr(topoplotdata, 'contour_levels', [0, 0]) xlimits = getattr(topoplotdata, 'xlimits', None) ylimits = getattr(topoplotdata, 'ylimits', None) coarsen = getattr(topoplotdata, 'coarsen', 1) if abs(topotype) != 3: print "*** Only topotype = 3, -3 implemented so far." return file = open(fname, 'r') lines = file.readlines() ncols = int(lines[0].split()[0]) nrows = int(lines[1].split()[0]) xllcorner = float(lines[2].split()[0]) yllcorner = float(lines[3].split()[0]) cellsize = float(lines[4].split()[0]) NODATA_value = int(lines[5].split()[0]) print "Loading file ", fname print " nrows = %i, ncols = %i" % (nrows, ncols) topo = pylab.loadtxt(fname, skiprows=6, dtype=float) print " Done loading" if 0: topo = [] for i in range(nrows): topo.append(pylab.array(lines[6 + i], )) print '+++ topo = ', topo topo = pylab.array(topo) topo = pylab.flipud(topo) if topotype < 0: topo = -topo x = pylab.linspace(xllcorner, xllcorner + ncols * cellsize, ncols) y = pylab.linspace(yllcorner, yllcorner + nrows * cellsize, nrows) print "Shape of x, y, topo: ", x.shape, y.shape, topo.shape if coarsen > 1: topo = topo[slice(0, nrows, coarsen), slice(0, ncols, coarsen)] x = x[slice(0, ncols, coarsen)] y = y[slice(0, nrows, coarsen)] print "Shapes after coarsening: ", x.shape, y.shape, topo.shape #import pdb; pdb.set_trace() if figno: pylab.figure(figno) pylab.pcolor(x, y, topo, cmap=cmap) pylab.clim(climits) pylab.axis('scaled') if addcolorbar: pylab.colorbar() if addcontour: pylab.contour(x, y, topo, levels=contour_levels, colors='k') gridedges_show = True if gridedges_show: pylab.plot([x[0], x[-1]], [y[0], y[0]], 'k') pylab.plot([x[0], x[-1]], [y[-1], y[-1]], 'k') pylab.plot([x[0], x[0]], [y[0], y[-1]], 'k') pylab.plot([x[-1], x[-1]], [y[0], y[-1]], 'k') fname2 = os.path.splitext(fname)[0] pylab.text(xllcorner + cellsize, yllcorner + cellsize, fname2, color='m') topodata = Data() topodata.x = x topodata.y = y topodata.topo = topo return topodata
def plot_topo_file(topoplotdata): """ Read in a topo or bathy file and produce a pcolor map. """ import os import pylab from pyclaw.data import Data fname = topoplotdata.fname topotype = topoplotdata.topotype if topoplotdata.climits: # deprecated option cmin = topoplotdata.climits[0] cmax = topoplotdata.climits[1] else: cmin = topoplotdata.cmin cmax = topoplotdata.cmax figno = topoplotdata.figno addcolorbar = topoplotdata.addcolorbar addcontour = topoplotdata.addcontour contour_levels = topoplotdata.contour_levels xlimits = topoplotdata.xlimits ylimits = topoplotdata.ylimits coarsen = topoplotdata.coarsen imshow = topoplotdata.imshow gridedges_show = topoplotdata.gridedges_show cmap = topoplotdata.cmap print_fname = topoplotdata.print_fname if cmap is None: cmap = colormaps.make_colormap({ cmin: [0.3, 0.2, 0.1], 0: [0.95, 0.9, 0.7], .01: [.5, .7, 0], cmax: [.2, .5, .2] }) if abs(topotype) == 1: X, Y, topo = topotools.topofile2griddata(fname, topotype) topo = pylab.flipud(topo) Y = pylab.flipud(Y) x = X[0, :] y = Y[:, 0] xllcorner = x[0] yllcorner = y[0] cellsize = x[1] - x[0] elif abs(topotype) == 3: file = open(fname, 'r') lines = file.readlines() ncols = int(lines[0].split()[0]) nrows = int(lines[1].split()[0]) xllcorner = float(lines[2].split()[0]) yllcorner = float(lines[3].split()[0]) cellsize = float(lines[4].split()[0]) NODATA_value = int(lines[5].split()[0]) print "Loading file ", fname print " nrows = %i, ncols = %i" % (nrows, ncols) topo = pylab.loadtxt(fname, skiprows=6, dtype=float) print " Done loading" if 0: topo = [] for i in range(nrows): topo.append(pylab.array(lines[6 + i], )) print '+++ topo = ', topo topo = pylab.array(topo) topo = pylab.flipud(topo) x = pylab.linspace(xllcorner, xllcorner + ncols * cellsize, ncols) y = pylab.linspace(yllcorner, yllcorner + nrows * cellsize, nrows) print "Shape of x, y, topo: ", x.shape, y.shape, topo.shape else: raise Exception("*** Only topotypes 1 and 3 supported so far") if coarsen > 1: topo = topo[slice(0, nrows, coarsen), slice(0, ncols, coarsen)] x = x[slice(0, ncols, coarsen)] y = y[slice(0, nrows, coarsen)] print "Shapes after coarsening: ", x.shape, y.shape, topo.shape if topotype < 0: topo = -topo if figno: pylab.figure(figno) if topoplotdata.imshow: color_norm = Normalize(cmin, cmax, clip=True) xylimits = (x[0], x[-1], y[0], y[-1]) #pylab.imshow(pylab.flipud(topo.T), extent=xylimits, \ pylab.imshow(pylab.flipud(topo), extent=xylimits, \ cmap=cmap, interpolation='nearest', \ norm=color_norm) else: pylab.pcolor(x, y, topo, cmap=cmap) pylab.clim([cmin, cmax]) pylab.axis('scaled') if addcolorbar: pylab.colorbar() if addcontour: pylab.contour(x, y, topo, levels=contour_levels, colors='k') if gridedges_show: pylab.plot([x[0], x[-1]], [y[0], y[0]], 'k') pylab.plot([x[0], x[-1]], [y[-1], y[-1]], 'k') pylab.plot([x[0], x[0]], [y[0], y[-1]], 'k') pylab.plot([x[-1], x[-1]], [y[0], y[-1]], 'k') if print_fname: fname2 = os.path.splitext(fname)[0] pylab.text(xllcorner + cellsize, yllcorner + cellsize, fname2, color='m') topodata = Data() topodata.x = x topodata.y = y topodata.topo = topo return topodata
def plot_topo_file(topoplotdata): """ Read in a topo or bathy file and produce a pcolor map. """ import os import pylab from pyclaw.data import Data fname = topoplotdata.fname topotype = topoplotdata.topotype if topoplotdata.climits: # deprecated option cmin = topoplotdata.climits[0] cmax = topoplotdata.climits[1] else: cmin = topoplotdata.cmin cmax = topoplotdata.cmax figno = topoplotdata.figno addcolorbar = topoplotdata.addcolorbar addcontour = topoplotdata.addcontour contour_levels = topoplotdata.contour_levels xlimits = topoplotdata.xlimits ylimits = topoplotdata.ylimits coarsen = topoplotdata.coarsen imshow = topoplotdata.imshow gridedges_show = topoplotdata.gridedges_show neg_cmap = topoplotdata.neg_cmap pos_cmap = topoplotdata.pos_cmap print_fname = topoplotdata.print_fname if neg_cmap is None: neg_cmap = colormaps.make_colormap({cmin:[0.3,0.2,0.1], 0:[0.95,0.9,0.7]}) if pos_cmap is None: pos_cmap = colormaps.make_colormap({ 0:[.5,.7,0], cmax:[.2,.5,.2]}) if abs(topotype) == 1: X,Y,topo = topotools.topofile2griddata(fname, topotype) topo = pylab.flipud(topo) Y = pylab.flipud(Y) x = X[0,:] y = Y[:,0] xllcorner = x[0] yllcorner = y[0] cellsize = x[1]-x[0] elif abs(topotype) == 3: file = open(fname, 'r') lines = file.readlines() ncols = int(lines[0].split()[0]) nrows = int(lines[1].split()[0]) xllcorner = float(lines[2].split()[0]) yllcorner = float(lines[3].split()[0]) cellsize = float(lines[4].split()[0]) NODATA_value = int(lines[5].split()[0]) print "Loading file ",fname print " nrows = %i, ncols = %i" % (nrows,ncols) topo = pylab.loadtxt(fname,skiprows=6,dtype=float) print " Done loading" if 0: topo = [] for i in range(nrows): topo.append(pylab.array(lines[6+i],)) print '+++ topo = ',topo topo = pylab.array(topo) topo = pylab.flipud(topo) x = pylab.linspace(xllcorner, xllcorner+ncols*cellsize, ncols) y = pylab.linspace(yllcorner, yllcorner+nrows*cellsize, nrows) print "Shape of x, y, topo: ", x.shape, y.shape, topo.shape else: raise Exception("*** Only topotypes 1 and 3 supported so far") if coarsen > 1: topo = topo[slice(0,nrows,coarsen), slice(0,ncols,coarsen)] x = x[slice(0,ncols,coarsen)] y = y[slice(0,nrows,coarsen)] print "Shapes after coarsening: ", x.shape, y.shape, topo.shape if topotype < 0: topo = -topo if figno: pylab.figure(figno) if topoplotdata.imshow: color_norm = Normalize(cmin,cmax,clip=True) xylimits = (x[0],x[-1],y[0],y[-1]) #pylab.imshow(pylab.flipud(topo.T), extent=xylimits, \ pylab.imshow(pylab.flipud(topo), extent=xylimits, \ cmap=cmap, interpolation='nearest', \ norm=color_norm) else: neg_topo = ma.masked_where(topo>0., topo) all_masked = (ma.count(neg_topo) == 0) if not all_masked: pylab.pcolormesh(x,y,neg_topo,cmap=neg_cmap) pylab.clim([cmin,0]) if addcolorbar: pylab.colorbar() pos_topo = ma.masked_where(topo<0., topo) all_masked = (ma.count(pos_topo) == 0) if not all_masked: pylab.pcolormesh(x,y,pos_topo,cmap=pos_cmap) pylab.clim([0,cmax]) if addcolorbar: pylab.colorbar() pylab.axis('scaled') if addcontour: pylab.contour(x,y,topo,levels=contour_levels,colors='k') if gridedges_show: pylab.plot([x[0],x[-1]],[y[0],y[0]],'k') pylab.plot([x[0],x[-1]],[y[-1],y[-1]],'k') pylab.plot([x[0],x[0]],[y[0],y[-1]],'k') pylab.plot([x[-1],x[-1]],[y[0],y[-1]],'k') if print_fname: fname2 = os.path.splitext(fname)[0] pylab.text(xllcorner+cellsize, yllcorner+cellsize, fname2, color='m') topodata = Data() topodata.x = x topodata.y = y topodata.topo = topo return topodata
import pylab as pl from scipy.misc import imresize, imfilter import turtle # load image img = pl.flipud(pl.imread(".ily.png")) a=turtle.Turtle() s=turtle.Screen() s.setup(400,400) s.delay(5000) # setup turtle levels = 8 size = 2**levels turtle.setup(img.shape[1] * 4.2, img.shape[0] * 4.2) turtle.setworldcoordinates(0, 0, size, -size) turtle.tracer(1000, 0) # resize and blur image img = imfilter(imresize(img, (size, size)), 'blur') # define recursive hilbert curve def hilbert(level, angle = 90): if level == 0: return if level == 1 and img[-turtle.pos()[1], turtle.pos()[0]] > 128: turtle.forward(2**level - 1) else: turtle.right(angle) hilbert(level - 1, -angle) turtle.forward(1) turtle.left(angle)
if doBGcorrect: for l in xrange(data.shape[1]): indf = data[:,l] < (pl.median(data[:,l])) poly = rt.PolynomialFit(channels, data[:,l], indf=indf) data[:,l] -= poly data /= mon if "3d" in colname and not saveonly: if "-log" in colname: imdata = pl.log(data) ind = pl.isfinite(imdata) else: imdata = data ind = slice(None) vmin[j] = 0#min(vmin[j], imdata[ind].min()) vmax[j] = max(vmax[j], imdata[ind].max()) thisax.imshow(pl.flipud(imdata), aspect="auto", vmin=vmin[j], vmax=vmax[j], extent=(x[0], x[-1], 0, data.shape[0]-1)) thisax.set_title("#%i: %s"%(i, scan.command())) thisax.grid(False) elif "2d" in colname: if "roi" in colname: imax = data.sum(1).argmax() ind = slice(imax - nint, imax + nint) print("Channels in roi: %i...%i"%(imax - nint, imax + nint)) elif "sum" in colname: ind = slice(None) if not saveonly: thisax.plot(x, data[ind].sum(0), style, label="#%i: %s"%(i, scan.command())) lblax = thisax
def build_fft(input_signal, filter_coefficients, threshold_windows=6, boundary=0): """generate fast transform fourier by windows Params : input_signal : the audio signal filter_coefficients : coefficients of the chirplet bank threshold_windows : calcul the size of the windows boundary : manage the bounds of the signal Returns : fast Fourier transform applied by windows to the audio signal """ num_coeffs = filter_coefficients.size #print(n,boundary,M) half_size = num_coeffs // 2 signal_size = input_signal.size #power of 2 to apply fast fourier transform windows_size = 2**ceil(log2(num_coeffs * (threshold_windows + 1))) number_of_windows = floor(signal_size // windows_size) if number_of_windows == 0: return fft_based(input_signal, filter_coefficients, boundary) windowed_fft = empty_like(input_signal) #pad with 0 to have a size in a power of 2 windows_size = int(windows_size) zeropadding = np.lib.pad(filter_coefficients, (0, windows_size - num_coeffs), 'constant', constant_values=0) h_fft = fft(zeropadding) #to browse the whole signal current_pos = 0 #apply fft to a part of the signal. This part has a size which is a power #of 2 if boundary == 0: #ZERO PADDING #window is half padded with since it's focused on the first half window = input_signal[current_pos:current_pos + windows_size - half_size] zeropaddedwindow = np.lib.pad(window, (len(h_fft) - len(window), 0), 'constant', constant_values=0) x_fft = fft(zeropaddedwindow) elif boundary == 1: #SYMMETRIC window = concatenate([ flipud(input_signal[:half_size]), input_signal[current_pos:current_pos + windows_size - half_size] ]) x_fft = fft(window) else: x_fft = fft(input_signal[:windows_size]) windowed_fft[:windows_size - num_coeffs] = (ifft( x_fft * h_fft)[num_coeffs - 1:-1]).real current_pos += windows_size - num_coeffs - half_size #apply fast fourier transofm to each windows while current_pos + windows_size - half_size <= signal_size: x_fft = fft(input_signal[current_pos - half_size:current_pos + windows_size - half_size]) #Suppress the warning, work on the real/imagina windowed_fft[current_pos:current_pos + windows_size - num_coeffs] = (ifft(x_fft * h_fft)[num_coeffs - 1:-1]).real current_pos += windows_size - num_coeffs # print(countloop) #apply fast fourier transform to the rest of the signal if windows_size - (signal_size - current_pos + half_size) < half_size: window = input_signal[current_pos - half_size:] zeropaddedwindow = np.lib.pad( window, (0, int(windows_size - (signal_size - current_pos + half_size))), 'constant', constant_values=0) x_fft = fft(zeropaddedwindow) windowed_fft[current_pos:] = roll(ifft( x_fft * h_fft), half_size)[half_size:half_size + windowed_fft.size - current_pos].real windowed_fft[-half_size:] = convolve(input_signal[-num_coeffs:], filter_coefficients, 'same')[-half_size:] else: window = input_signal[current_pos - half_size:] zeropaddedwindow = np.lib.pad( window, (0, int(windows_size - (signal_size - current_pos + half_size))), 'constant', constant_values=0) x_fft = fft(zeropaddedwindow) windowed_fft[current_pos:] = ifft( x_fft * h_fft)[num_coeffs - 1:num_coeffs + windowed_fft.size - current_pos - 1].real return windowed_fft