def ddwt(x, num_scales): """ Дискретное вейвлет-преобразование без прореживания :param x: входной сигнал :param num_scales: число уровней разложения :return: """ h = np.array([1, 3, 3, 1], float) / 8 g = np.array([2, -2], float) signal_len = len(x) detail = [] approx = [] ap = x.copy() detail.append(ap.copy()) # на нулевом уровне храним исходный сигнал approx.append([]) for s in range(num_scales): dly = 2**s hif = convolve(ap, g, mode="full")[dly:dly+signal_len] detail.append(hif) approx.append(ap) if s < num_scales-1: ap = convolve(ap, h, mode="full")[dly:dly+signal_len] dly_lo = len(h)-1 ap[:dly_lo] = ap[dly_lo] # хак # вместо прореживания сигналов (Маллат) расширяем характеристики # фильтров h = fexpand(h) g = fexpand(g) return approx, detail
def makePriorGrid(zs,rs,dr,outfile,rmin=15,rmax=30): rMids = np.arange(16.,28.,0.1) drs = 0.5*np.ones(len(rMids)) drs[rMids<23]=0.5 drs[rMids<20]=1.0 drs[rMids<19]=2.0 zEdges=np.arange(-0.075,5.075,0.1) zMids = (zEdges[1:]+zEdges[:-1])/2. allH = [] for i in range(len(rMids)): #print(rMids[i]) rMsk = np.ma.masked_outside(rs,rMids[i]-dr,rMids[i]+dr) zMsk = np.ma.masked_array(zs,mask=np.ma.getmask(rMsk)).compressed() h = np.histogram(zMsk,bins=zEdges)[0] kernel=np.ones(5)*(1./5.) h2=sig.convolve(h,kernel,mode='same') h3=sig.convolve(h2,kernel,mode='same') g = interp1d(zMids,h3,bounds_error=False, fill_value=0.0) tot = integrate.quad(g,0.,7.) h3 = h3/tot[0] if i%5==0: plt.plot(zMids,h3,lw=3,alpha=0.75,color=cm.jet(i/len(rMids)),label='r='+str(rMids[i])) else: plt.plot(zMids,h3,lw=3,alpha=0.5,color=cm.jet(i/len(rMids))) allH.append(h3) return([rMids,zMids,np.array(allH)])
def compute_harris_response(image): """ compute the Harris corner detector response function for each pixel in the image""" #derivatives imx, imy = filtertools.gauss_derivatives(image, 3) #kernel for blurring gauss = filtertools.gauss_kernel(3) #compute components of the structure tensor Wxx = signal.convolve(imx*imx, gauss, mode='same') Wxy = signal.convolve(imx*imy, gauss, mode='same') Wyy = signal.convolve(imy*imy, gauss, mode='same') #determinant and trace Wdet = Wxx*Wyy - Wxy**2 Wtr = Wxx + Wyy if numpy.count_nonzero(Wtr) == 0: return print Wtr.shape print numpy.count_nonzero(Wtr) return Wdet / Wtr
def test3DConvolution(): kernel = array([[[-1, 1], [1, 0]], [[1, 0], [0, 0]]]) kernel_cube = array([ zeros((3,3)), [[0, 0, 0], [0, -1, 1], [0, 1, 0]], [[0, 0, 0], [0, 1, 0], [0, 0, 0]]]) A = reshape(linspace(1,9,9), (3,3), order = 'C') B = array((A, A, A)) C = operators.convolve(kernel, (3, 3, 3), order = 'F') adjointTest(C) np.testing.assert_allclose( reshape(C._forward(ravel(B, order = 'F')), (3, 3, 3), order = 'F'), signal.convolve(B, kernel, 'same')) np.testing.assert_allclose( reshape(C._forward(ravel(B, order = 'F')), (3, 3, 3), order = 'F'), signal.convolve(B, kernel_cube, 'same')) np.testing.assert_allclose( reshape(C._adjoint(ravel(B, order = 'F')), (3, 3, 3), order = 'F'), signal.convolve(B, np.flipud(np.fliplr(kernel_cube[:,:,::-1])), 'same'))
def computeTensor(im, sigmaG=1, factorSigma=4): # returns 3d array of the size of the image # yx stores xx, yx, and yy components of the tensor # get the luminance of the image, use [0.3, 0.6, 0.1] # use numpy's dot # blur the image imLum = lum(im) imLumBlurred = zeros( ( height(im), width(im) ) ) ndimage.filters.gaussian_filter( imLum, sigmaG, 0, imLumBlurred ) gradX = signal.convolve(imLumBlurred, Sobel, mode='same') gradY = signal.convolve(imLumBlurred, transpose(Sobel), mode='same') # construct 3 2d arrays of the elements of the tensor gradXX = gradX*gradX gradYY = gradY*gradY gradXY = gradX*gradY ndimage.filters.gaussian_filter( gradXX, sigmaG * factorSigma, 0, gradXX ) ndimage.filters.gaussian_filter( gradXY, sigmaG * factorSigma, 0, gradXY ) ndimage.filters.gaussian_filter( gradYY, sigmaG * factorSigma, 0, gradYY ) # construct RGB image based on these vals out = constantIm(height(im), width(im), 0.0) out[:,:,0] = gradXX out[:,:,1] = gradXY out[:,:,2] = gradYY return out
def basefreq(audiofile): """ This function reads in the audio file and does the hann windowed fft of the right input. It then smooths the output using a gaussian filter and then finds the peaks. It returns the peaks in the right audio channel since testing showed there was no significant difference in the two. """ #read the data into an ndarray using scikits-audiolab data, rate, enc = al.aiffread(audiofile) #split the left and right channel datar = data[:,1] datal = data[:,0] #take the fft of both of the channels with the hann window applied #the hann window reduces spectral leakage in the FFT dftr = abs(fft.fft(datar*signal.hann(len(datar)))) dftl = abs(fft.fft(datal*signal.hann(len(datal)))) #compute the frequencies in the FFT freq = float(rate)/float(len(datar)) freqs = np.arange(len(dftr)/2+99)*freq dftr = dftr[0:np.size(dftr)/2] dftl = dftl[0:np.size(dftr)/2] #smooth the fft with a gaussian c = signal.gaussian(100,20) dftr = signal.convolve(dftr,c) dftl = signal.convolve(dftl,c) #find the significant peaks in each channel peaksr = findpeaks(dftr,freqs) peaksl = findpeaks(dftl,freqs) #plot the output fft for testing #plt.plot(freqs,dftr) #plt.show() #print peaksr return peaksr
def filtervertical(H, minleafDomain): """ This function applies the matched filter on the horizontal 2D histogram. Returns filter response for both directions, as stairs can face both ways. https://www.youtube.com/watch?v=S7qbelm_4Y8 --> explains matched filter good, couldn't make spectralpython matched filter work """ # from skimage.feature import canny # edges = canny(H) # plt.imshow(edges,cmap=plt.cm.gray) # plt.show() filt = create_matched_filter(minleafDomain) # Note that the convolution of the time-reversed wavelet is identical to cross-correlation of the wavelet with the wavelet (autocorrelation) in the input signal --> http://crewes.org/ForOurSponsors/ResearchReports/2002/2002-46.pdf filty=np.transpose(filt) # transpose to also get stairs in other direction fr1=signal.convolve(H,filt, mode='same') # plt.subplot(1,3,1) # plt.imshow(fr1,cmap='spectral',interpolation='none') # plt.title('vert matched filter') # plt.colorbar() fr2=signal.convolve(H,filty, mode='same') # fr3=signal.convolve2d(H,filty, mode='same') # should givve the same result as fr2 # fr3 = fr3**2 # doesn't really work as there are very high 'outliers' that just take everything away # plt.subplot(1,3,2) # plt.imshow(fr2,cmap='spectral',interpolation='none') # plt.title('vert matched filter transpose') # plt.colorbar() return fr1, fr2
def test_input_swapping(self): small = arange(8).reshape(2, 2, 2) big = 1j * arange(27).reshape(3, 3, 3) big += arange(27)[::-1].reshape(3, 3, 3) out_array = array( [[[0 + 0j, 26 + 0j, 25 + 1j, 24 + 2j], [52 + 0j, 151 + 5j, 145 + 11j, 93 + 11j], [46 + 6j, 133 + 23j, 127 + 29j, 81 + 23j], [40 + 12j, 98 + 32j, 93 + 37j, 54 + 24j]], [[104 + 0j, 247 + 13j, 237 + 23j, 135 + 21j], [282 + 30j, 632 + 96j, 604 + 124j, 330 + 86j], [246 + 66j, 548 + 180j, 520 + 208j, 282 + 134j], [142 + 66j, 307 + 161j, 289 + 179j, 153 + 107j]], [[68 + 36j, 157 + 103j, 147 + 113j, 81 + 75j], [174 + 138j, 380 + 348j, 352 + 376j, 186 + 230j], [138 + 174j, 296 + 432j, 268 + 460j, 138 + 278j], [70 + 138j, 145 + 323j, 127 + 341j, 63 + 197j]], [[32 + 72j, 68 + 166j, 59 + 175j, 30 + 100j], [68 + 192j, 139 + 433j, 117 + 455j, 57 + 255j], [38 + 222j, 73 + 499j, 51 + 521j, 21 + 291j], [12 + 144j, 20 + 318j, 7 + 331j, 0 + 182j]]]) assert_array_equal(convolve(small, big, 'full'), out_array) assert_array_equal(convolve(big, small, 'full'), out_array) assert_array_equal(convolve(small, big, 'same'), out_array[1:3, 1:3, 1:3]) assert_array_equal(convolve(big, small, 'same'), out_array[0:3, 0:3, 0:3]) assert_raises(ValueError, convolve, small, big, 'valid') assert_array_equal(convolve(big, small, 'valid'), out_array[1:3, 1:3, 1:3])
def __init__(self, shapein, kernel, mode="full", fft=False, **kwargs): if fft: from scipy.signal import fftconvolve as convolve # check kernel shape parity if np.any(np.asarray(kernel.shape) % 2 != 1): raise ValueError("Kernels with non-even shapes are not handled for now.") else: from scipy.signal import convolve self.kernel = kernel self.mode = mode # reverse kernel s = (slice(None, None, -1), ) * kernel.ndim self.rkernel = kernel[s] # reverse mode if mode == 'full': self.rmode = 'valid' elif mode == 'valid': self.rmode = 'full' elif mode == 'same': self.rmode = 'same' # shapeout if mode == 'full': shapeout = [s + ks - 1 for s, ks in zip(shapein, kernel.shape)] if mode == 'valid': shapeout = [s - ks + 1 for s, ks in zip(shapein, kernel.shape)] if mode == 'same': shapeout = shapein matvec = lambda x: convolve(x, self.kernel, mode=self.mode) rmatvec = lambda x: convolve(x, self.rkernel, mode=self.rmode) NDOperator.__init__(self, shapein, shapeout, matvec, rmatvec, **kwargs)
def __init__(self, shapein, kernel, mode='reflect', cval=0.0, origin=0, **kwargs): """ Generate a convolution operator wrapping scipy.ndimage.convolve function. The kernel is reversed for the transposition. Note that kernel with even shapes are not handled. """ if kernel.ndim == 1: from scipy.ndimage import convolve1d as convolve else: from scipy.ndimage import convolve self.kernel = kernel self.mode = mode self.cval = cval self.origin = origin # check kernel shape parity if np.any(np.asarray(self.kernel.shape) % 2 != 1): ValueError("kernel should have even shape.") # reverse kernel s = (slice(None, None, -1), ) * kernel.ndim self.rkernel = kernel[s] shapeout = shapein matvec = lambda x: convolve(x, self.kernel, mode=mode, cval=cval, origin=origin) rmatvec = lambda x: convolve(x, self.rkernel, mode=mode, cval=cval, origin=origin) NDOperator.__init__(self, shapein, shapeout, matvec, rmatvec, **kwargs)
def lsf_to_lpc(all_lsf): if len(all_lsf.shape) < 2: all_lsf = all_lsf[None] order = all_lsf.shape[1] all_lpc = np.zeros((len(all_lsf), order + 1)) for i in range(len(all_lsf)): lsf = all_lsf[i] zeros = np.exp(1j * lsf) sum_zeros = zeros[::2] diff_zeros = zeros[1::2] sum_zeros = np.hstack((sum_zeros, np.conj(sum_zeros))) diff_zeros = np.hstack((diff_zeros, np.conj(diff_zeros))) sum_filt = np.poly(sum_zeros) diff_filt = np.poly(diff_zeros) if order % 2 != 0: deconv_diff = sg.convolve(diff_filt, [1, 0, -1]) deconv_sum = sum_filt else: deconv_diff = sg.convolve(diff_filt, [1, -1]) deconv_sum = sg.convolve(sum_filt, [1, 1]) lpc = .5 * (deconv_sum + deconv_diff) # Last coefficient is 0 and not returned all_lpc[i] = lpc[:-1] return np.squeeze(all_lpc)
def convolve(self, f): from scipy.signal import convolve e_field = self.E_field_as_numpy() f_data = np.zeros((self.dim_x(), self.dim_y())) result = np.zeros((self.numberEnergies(), self.dim_x(), self.dim_y(), 2), dtype=np.complex128) print("Convolve I_X ", end="") for i_x, x_cooridinate in enumerate(self.absolute_x_coordinates()): if i_x%100 ==0: print(" ",i_x , end="") for i_y, y_cooridinate in enumerate(self.absolute_y_coordinates()): f_data[i_x, i_y] = f(x_cooridinate,y_cooridinate) for index_energy in range(self.numberEnergies()): for pol in (0,1): print("Convolving pol", pol) #r = convolve(f_data, f_data,mode='same') r = convolve(e_field[index_energy,:,:,pol].real, f_data,mode='same') r = r + 1j *convolve(e_field[index_energy,:,:,pol].imag, f_data,mode='same') for i_x, x_cooridinate in enumerate(self.absolute_x_coordinates()): for i_y, y_cooridinate in enumerate(self.absolute_y_coordinates()): result[index_energy, i_x , i_y , pol] = r[i_x,i_y] convolved_wavefront = NumpyWavefront(result, self.x_start(), self.x_end(), self.y_start(), self.y_end(), self.z()) return convolved_wavefront
def get_corr (im, pars): # transform 2-d image to 1-d total signal vectors totsig, totsigla = get_totsig(im,pars.la) ln1 = im.npix / 2 ln2 = im.npix quad_len = ln1*ln1 # compute staypuft signal for each pixel mask = totsig > 40.0 p0 = np.fabs(pars.ampscale * mask * totsig) p1 = np.fabs(pars.ampscale * mask * totsigla) ekern = np.exp(-np.arange(ln1*pars.tx)/pars.hh) qkern = pars.a1*np.arange(ln1*pars.tx) + pars.a2 e = convolve (p0, ekern, mode='full') q = convolve (p1, qkern, mode='full') b = e[0:quad_len] + q[0:quad_len] # transform the correction vector back into a 2-d image quad b = b[::-1] b = np.reshape (b, (ln1,ln1)) b = np.transpose(b) # replicate the correction into all 4 full image quads im.data[0:ln1,0:ln1] = b im.data[0:ln1,ln1:ln2] = b im.data[ln1:ln2,0:ln1] = b im.data[ln1:ln2,ln1:ln2] = b return im
def test_consistency_convolve_funcs(self): # Compare np.convolve, signal.convolve, signal.convolve2d a = np.arange(5) b = np.array([3.2, 1.4, 3]) for mode in ["full", "valid", "same"]: assert_almost_equal(np.convolve(a, b, mode=mode), signal.convolve(a, b, mode=mode)) assert_almost_equal(np.squeeze(signal.convolve2d([a], [b], mode=mode)), signal.convolve(a, b, mode=mode))
def degrades(V, W, H, rate, s, niter=20): """ Deconvolution by Gradient Descent with Sparsification. """ V, W, H = normalize(V), normalize(W), normalize(H) for iter in xrange(niter): convolved_pieces = np.vstack([signal.convolve(W[r], H[r], mode='full') for r in xrange(W.shape[0])]) convolved = np.sum(convolved_pieces, axis=0) delta = V - convolved projected_H = fft_deconvolve(delta, W) H = magical_entropy_hammer(H, H + projected_H * rate, 0.01, axis=1) convolved_pieces = np.vstack([signal.convolve(W[r], H[r], mode='full') for r in xrange(W.shape[0])]) convolved = np.sum(convolved_pieces, axis=0) delta = V - convolved projected_W = fft_deconvolve(delta, H) W = magical_entropy_hammer(W, W + projected_W * rate, 0.001, axis=1) print np.sum(np.abs(delta)) print H pylab.clf() pylab.subplot(311) pylab.plot(W.T) pylab.subplot(312) pylab.plot(H.T) pylab.subplot(313) pylab.plot(V) pylab.plot(convolved) return W, H
def kfilter_coeffs(fs): # Pre filter f0 = 1500.0; w0 = 2*np.pi*f0/fs; Q = 0.5 gain = 4.0 A = 10**(gain/40) S = 1.0 alpha = np.sin(w0)/2 * np.sqrt((A + 1/A)*(1/S -1) + 2); b0 = A*( (A+1) + (A-1)*np.cos(w0) + 2*np.sqrt(A)*alpha ); b1 = -2*A*( (A-1) + (A+1)*np.cos(w0) ); b2 = A*( (A+1) + (A-1)*np.cos(w0) - 2*np.sqrt(A)*alpha ); a0 = (A+1) - (A-1)*np.cos(w0) + 2*np.sqrt(A)*alpha; a1 = 2*( (A-1) - (A+1)*np.cos(w0) ); a2 = (A+1) - (A-1)*np.cos(w0) - 2*np.sqrt(A)*alpha; b_pre = [b0, b1, b2]/a0 a_pre = [a0, a1, a2]/a0 # Highpass f0 = 38.0; w0 = 2*np.pi*f0/fs; Q = 0.5; alpha = np.sin(w0)/(2*Q); b0 = (1 + np.cos(w0))/2; b1 = -(1 + np.cos(w0)); b2 = (1 + np.cos(w0))/2; a0 = 1 + alpha; a1 = -2*np.cos(w0); a2 = 1 - alpha; b_hp = [b0, b1, b2]/a0 a_hp = [a0, a1, a2]/a0 b = signal.convolve(b_pre, b_hp) a = signal.convolve(a_pre, a_hp) return (b, a)
def gaussian( u, v, size) : """Smooths the velocity field with a Gaussian kernel. Parameters ---------- u : 2d np.ndarray the u velocity component field v : 2d np.ndarray the v velocity component field size : int the half width of the kernel. Kernel has shape 2*size+1 Returns ------- uf : 2d np.ndarray the smoothed u velocity component field vf : 2d np.ndarray the smoothed v velocity component field """ g = _gaussian_kernel( size=size ) uf = convolve( u, g, mode='same') vf = convolve( v, g, mode='same') return uf, vf
def __init__ (self, var, saxis, kernel, fft): # {{{ ''' __init__()''' import numpy as np assert len(kernel) <= var.shape[saxis], 'Kernel must not be longer than dimension being smoothed.' # Construct new variable self.saxis = saxis self.var = var self.kernel = kernel self.fft = fft self.klen = len(kernel) # Normalize and reshape kernel self.kernel /= np.sum(self.kernel) self.kernel.shape = [self.klen if i == saxis else 1 for i in range(var.naxes)] # Determine which convolution function to use from scipy import signal as sg tdata = np.ones(len(kernel), 'd') if self.fft: try: sg.fftconvolve(tdata, kernel, 'same', old_behaviour=False) self._convolve = lambda x, y, z: sg.fftconvolve(x, y, z, old_behaviour=False) except TypeError: self._convolve = sg.fftconvolve else: try: sg.convolve(tdata, kernel, 'same', old_behaviour=False) self._convolve = lambda x, y, z: sg.convolve(x, y, z, old_behaviour=False) except TypeError: self._convolve = sg.convolve Var.__init__(self, var.axes, var.dtype, name=var.name, atts=var.atts, plotatts=var.plotatts)
def gaussian_differentiation_kernel(sigma, num_stds, order, delta, scale): """ http://en.wikipedia.org/wiki/Scale_space#Gaussian_derivatives :param sigma: :param num_stds: :param order: :param delta: :param scale: :return: """ delta = list(delta) g = gaussian_kernel(sigma, num_stds) d = np.ones((1,) * len(order)) for i in range(len(order)): _d = differentiation_kernel(order[i]).astype(float) if len(_d) % 2 != 1: _d = (np.pad(_d, ((0, 1),), 'constant') + np.pad(_d, ((1, 0),), 'constant')) / 2. delta[i] *= 2 _d /= delta[i] ** order[i] _d *= np.sqrt(scale[i]) ** order[i] shp = np.ones(len(order), int) shp[i] = _d.shape[0] _d.shape = shp d = spsig.convolve(d, _d) d = spsig.convolve(g, d) return d
def find_peaks(fft_set, sign="+", alpha=0.15, threshold=2.0): """ Method to find peaks on a fft set. :type threshold: object :param fft_set: :param sign: :param alpha: noise threshold :param threshold: :return: """ if sign == "-": fft_set = -fft_set # Get derivative derivation_vector = [1, 0, -1] d_fft_set = convolve(fft_set, derivation_vector, "same") # Checking for sign-flipping and derivative _sign = np.sign(d_fft_set) d_sign = convolve(_sign, derivation_vector, "valid") candidates = np.where(d_fft_set > 0)[0] + (len(derivation_vector) - 1) peaks = sorted(set(candidates).intersection(np.where(d_sign == -2)[0] + 1)) # Noise remover peaks = np.array(peaks)[fft_set[peaks] > alpha] return clean_adjacent_points(peaks, fft_set, float(threshold))
def deriv2D(data,axis=-1,dx=1.0,noise_suppression=True): """ Takes 1D or 2D Derivative of 2D array using convolution result = deriv2D(data) result = deriv2D(data, dx) output is 2D (if only one axis specified) output is 3D if no axis specified [nx,ny,2] with the third dimension being [dfdx, dfdy] keywords: axis = 0/1 If no axis specified 2D derivative will be returned dx = 1.0 axis spacing, must be 2D if 2D deriv is taken - default is [1.0,1.0] noise_suppression = True noise suppressing coefficients used to take derivative - default = True """ s = data.shape if axis > len(s)-1: raise RuntimeError("ERROR: axis out of bounds for derivative") if noise_suppression: if s[axis] < 11: raise RuntimeError("Data too small to use 11th order method") tmp = array([old_div(-1.0,512.0),old_div(-8.0,512.0),old_div(-27.0,512.0),old_div(-48.0,512.0),old_div(-42.0,512.0),0.0,old_div(42.0,512.0),old_div(48.0,512.0),old_div(27.0,512.0),old_div(8.0,512.0),old_div(1.0,512.0)]) else: if s[axis] < 9: raise RuntimeError("Data too small to use 9th order method") tmp = array([old_div(1.0,280.0),old_div(-4.0,105.0),old_div(1.0,5.0),old_div(-4.0,5.0),0.0,old_div(4.0,5.0),old_div(-1.0,5.0),old_div(4.0,105.0),old_div(-1.0,280.0)]) N = old_div((tmp.size-1),2) if axis==1: W = transpose(tmp[:,None]) data_deriv = convolve(data,W,mode='same')/dx*-1.0 for i in range(s[0]): data_deriv[i,0:N-1] = old_div(deriv(data[i,0:N-1]),dx) data_deriv[i,s[1]-N:] = old_div(deriv(data[i,s[1]-N:]),dx) elif axis==0: W = tmp[:,None] data_deriv = convolve(data,W,mode='same')/dx*-1.0 for i in range(s[1]): data_deriv[0:N-1,i] = old_div(deriv(data[0:N-1,i]),dx) data_deriv[s[0]-N:,i] = old_div(deriv(data[s[0]-N:,i]),dx) else: data_deriv = zeros((s[0],s[1],2)) if len(dx)==1: dx = array([dx,dx]) W = tmp[:,None]#transpose(multiply(tmp,ones((s[1],tmp.size)))) data_deriv[:,:,0] = convolve(data,W,mode='same')/dx[0]*-1.0 for i in range(s[1]): data_deriv[0:N-1,i,0] = old_div(deriv(data[0:N-1,i]),dx[0]) data_deriv[s[0]-N:s[0]+1,i,0] = old_div(deriv(data[s[0]-N:s[0]+1,i]),dx[0]) W = transpose(tmp[:,None])#multiply(tmp,ones((s[0],tmp.size))) data_deriv[:,:,1] = convolve(data,W,mode='same')/dx[1]*-1.0 for i in range(s[0]): data_deriv[i,0:N-1,1] = old_div(deriv(data[i,0:N-1]),dx[1]) data_deriv[i,s[1]-N:s[1]+1,1] = old_div(deriv(data[i,s[1]-N:s[1]+1]),dx[1]) return data_deriv
def kernel_func(X, Y): r"""Smooth histogram Y with kernel Y """ if Y is None: return X return (convolve(X, Y, mode="same") / convolve(np.ones_like(X), Y, mode="same"))
def dconv2d_k(dout,input,k,type): dk=None if type=='valid': dk=sg.convolve(input, numpy.rot90(dout,2),'valid') elif type=='full': dk=sg.convolve(dout,numpy.rot90(dout,2),'valid') else: raise TypeError('type argument is error') return dk
def ABAB(A,B,f,t): rate = 1/(t[1]-t[0]) y = np.zeros(len(t)) c1 = dirac_comb(f,t) c2 = half_period_shift(dirac_comb(f,t),f,rate) y1 = convolve(A,c1) y2 = convolve(B,c2) y = y1+ y2 return y[0:len(t)]
def calculate_flow(self, tactile_array, rows, columns): """ Calculates the optical flow in a tactile array using convolution as described in [1]. :param tactile_array: A list (one-dimensional) containing the intensity values of a tactile sensor. :type tactile_array: [] :param rows: The vertical size, in tactels, of the tactile sensor. :type rows: int :param columns: The horizontal size, in tactels, of the tactile sensor. :type columns: int :return: The slip vectors in the horizontal (X) and vertical direction (Y). :rtype: (float, float) [1] Alcazar, J. A., and Barajas, L. G. "Estimating object grasp sliding via pressure array sensing." In Robotics and Automation (ICRA), 2012 IEEE International Conference on, pp. 1740-1746. IEEE, 2012. """ assert (rows * columns) == len(tactile_array), "Rows and columns do not match array size!" tactile_matrix = numpy.array([tactile_array]) tactile_matrix = tactile_matrix.reshape((rows, columns)) # convolve the current tactile matrix with the previous tactile matrix if self.previous_tactile_matrix is None: convolved_matrix = signal.convolve(tactile_matrix, tactile_matrix) else: convolved_matrix = signal.convolve( self.previous_tactile_matrix, tactile_matrix ) # compute slip indices [slip_index_x, slip_index_y] = slip_utils.calculate_slip_indices(convolved_matrix) # create slip vectors if self.previous_slip_index_x: slip_vector_x = slip_index_x - self.previous_slip_index_x else: slip_vector_x = slip_index_x if self.previous_slip_index_y: slip_vector_y = slip_index_y - self.previous_slip_index_y else: slip_vector_y = slip_index_y # update variables self.previous_tactile_matrix = tactile_matrix self.previous_slip_index_x = slip_index_x self.previous_slip_index_y = slip_index_y return slip_vector_x, slip_vector_y
def apply_filter(im, myfilter, dim): H, W = im.shape if dim == 'col': im_filt = sgn.convolve(im.flatten(), myfilter, 'same') im_filt = np.reshape(im_filt, [H, W]) elif dim == 'row': im_filt = sgn.convolve(im.T.flatten(), myfilter, 'same') im_filt = np.reshape(im_filt, [W, H]).T return im_filt
def get_mask(self, ar_flux): # detect low flux regions using threshold # convolve and divide by box_size to keep the same scale spec1_smooth = signal.convolve(ar_flux > -0.8, self.detect_boxcar, mode='same') / self.detect_box_size # expand the mask to nearby pixels by smoothing mask_thresh = np.array(spec1_smooth < 0.2) mask_smooth = signal.convolve(mask_thresh, self.mask_boxcar, mode='same') > 1 return mask_smooth
def peak_finder(arr, smoothing=5, ddy_thresh=-300, dy0_thresh=5): array = medfilt(arr, smoothing) x = arange(len(array)) kernel = [4, 0, -4] dY = convolve(array, kernel, 'same') ddy = convolve(dY, kernel, 'same') falloff = -15000*exp(-0.003*x) #This has to be worked on masked_array = ma.masked_where(logical_or(ddy>falloff+ddy_thresh, abs(dY) > dy0_thresh) , arr) x_masked = ma.array(x, mask=masked_array.mask) return ma.compressed(x_masked)
def computeRawAAL(rawPosVector, cMass=False, groverFormula=False): """ Computation of angle-arc-length signature of a trajectory """ rpv = rawPosVector kernel = np.array([-1, 1]) if cMass: pcMass = np.sum(rpv, axis=0) / np.float(rpv.shape[1]) else: M_ref = np.array([1,0, 0]).transpose() # M_ref = np.array([1,0]) dx = signal.convolve(rpv[:, 0], kernel, 'same') dy = signal.convolve(rpv[:, 1], kernel, 'same') # dirty fix of large values in the first elements dx[0] = dx[1] dy[0] = dy[1] M_t = np.array([dx, dy]).transpose() alpha = [] sign = 0 for i in range(M_t.shape[0]): if cMass: if i == 0: M_ref = np.append(rpv[i, :] - pcMass, 0) else: M_ref = np.append(rpv[i-1, :] - pcMass, 0) m_t = np.append(M_t[i, :], 0) if groverFormula: inner = np.linalg.norm(np.cross(M_t[i, :], M_ref)) outer = np.dot(m_t, M_ref) alpha += [np.arctan2(inner, outer)] else: dot = np.dot(m_t, M_ref) deNom = np.linalg.norm(m_t) * np.linalg.norm(M_ref) sign = 0 if np.cross(m_t, M_ref)[2] >= 0: sign = 1 else: sign = -1 if deNom == 0: # no movement alpha += [0] else: alpha += [sign * np.arccos(dot / deNom)] M = np.add.accumulate(np.sqrt((M_t[:, 0] - M_t[:, 1])**2)) return np.array([alpha, M]).transpose()
def gauss_derivatives(im, n, ny=None): """ returns x and y derivatives of an image using gaussian derivative filters of size n. The optional argument ny allows for a different size in the y direction.""" gx,gy = gauss_derivative_kernels(n, sizey=ny) imx = signal.convolve(im,gx, mode='same') imy = signal.convolve(im,gy, mode='same') return imx,imy
import numpy as np from scipy import signal from matplotlib import pyplot as plt import mysignals as sigs corr_output_signal = signal.correlate(sigs.InputSignal_1kHz_15kHz, sigs.Impulse_response, mode="same") conv_output_signal = signal.convolve(sigs.InputSignal_1kHz_15kHz, sigs.Impulse_response, mode="same") plt.plot(corr_output_signal) plt.show() #correlation looks the same as convelution becaus the signal is symmetrical in this case
import numpy as np from matplotlib import pyplot as plt from pwtools import signal from scipy.signal import convolve, gaussian, correlate from scipy.fftpack import fft nn = 200 nadd = 5 * nn t = np.linspace(0.123, 0.567, nn) x = np.sin(2 * pi * 10 * t) + np.cos(2 * pi * 3 * t) + np.sin(2 * pi * 30 * t) dt = t[1] - t[0] pad_x = signal.pad_zeros(x, nadd=nadd) pad_welch_x = signal.pad_zeros(x * signal.welch(nn), nadd=nadd) kern = gaussian(M=20, std=2) # width M must be 6..10 x std smooth_pad_x = convolve(signal.pad_zeros(x, nadd=nadd), kern, 'same') / 10.0 ##mirr_x = signal.mirror(x) ##welch_mirr_x = signal.mirror(x)*signal.welch(2*nn-1) ##pad_welch_mirr_x = signal.pad_zeros(signal.mirror(x)*signal.welch(2*nn-1), ## nadd=2*nn-1) plt.figure() plt.plot(pad_x, label='pad_x (padded signal)') plt.plot(pad_welch_x, label='pad_welch_x') plt.plot(smooth_pad_x, label='smooth_pad_x') plt.xlabel('time [s]') plt.xlim(0, 300) plt.legend() plt.figure() f, d = signal.ezfft(x, dt)
def test_complex(self): x = array([1 + 1j, 2 + 1j, 3 + 1j]) y = array([1 + 1j, 2 + 1j]) z = convolve(x, y) assert_array_equal(z, array([2j, 2 + 6j, 5 + 8j, 5 + 5j]))
def test_same_mode(self): a = [1, 2, 3, 3, 1, 2] b = [1, 4, 3, 4, 5, 6, 7, 4, 3, 2, 1, 1, 3] c = convolve(a, b, 'same') d = array([57, 61, 63, 57, 45, 36]) assert_array_equal(c, d)
def test_valid_mode(self): a = [1, 2, 3, 6, 5, 3] b = [2, 3, 4, 5, 3, 4, 2, 2, 1] c = convolve(a, b, 'valid') assert_array_equal(c, array([70, 78, 73, 65]))
raise ValueError("a must be 2-d") code = r""" int i,j; for(i=1;i<Na[0]-1;i++) { for(j=1;j<Na[1]-1;j++) { B2(i,j) = A2(i,j) + A2(i-1,j)*0.5 + A2(i+1,j)*0.5 + A2(i,j-1)*0.5 + A2(i,j+1)*0.5 + A2(i-1,j-1)*0.25 + A2(i-1,j+1)*0.25 + A2(i+1,j-1)*0.25 + A2(i+1,j+1)*0.25; } } """ b = zeros_like(a) weave.inline(code, ['a', 'b']) return b a = [None] * 10 print(example1(a)) print(a) a = rand(512, 512) b = arr(a) h = [[0.25, 0.5, 0.25], [0.5, 1, 0.5], [0.25, 0.5, 0.25]] import scipy.signal as ss b2 = ss.convolve(h, a, 'same')
tinnom = 'Sin(x)/(x)' s = np.linspace(-10, 10, 50) sin = np.sin(s) / (s) winnom = 'Escalon' es = np.arange(0, 10, 0.5) esc = np.piecewise(es, es >= 5, [1, 0]) signom = 'Impulso' i = np.linspace(0, 10, 50) imp = np.zeros(len(s)) imp[25] = 1 sig = imp win = esc filtered = signal.convolve(sig, win, mode='same') / sum(win) import matplotlib.pyplot as plt fig, (ax_orig, ax_win, ax_filt) = plt.subplots(3, 1, sharex=True) ax_orig.plot(sig) ax_orig.set_title(signom) ax_orig.margins(0, 0.1) ax_win.plot(win) ax_win.set_title(winnom) ax_win.margins(0, 0.1) ax_filt.plot(filtered) ax_filt.set_title('Señales Convolucionadas') ax_filt.margins(0, 0.1) fig.tight_layout() plt.show()
def smooth(self, a, filter_n=51, width=0.5): W = signal.slepian(filter_n, width=width) W = W/np.sum(W) s = signal.convolve(a, W, mode='valid') return np.hstack([[s[0]]*(filter_n//2), s, [s[-1]]*(filter_n//2)])
def moving_average(sig, r=5): from scipy.signal import convolve return convolve(sig, ones((r, )) / r, mode='valid')
def add_color_patches_rand_gt(data, opt, prev, p=.125, num_points=None, use_avg=True, samp='normal'): # Add random color points sampled from ground truth based on: # Number of points # - if num_points is 0, then sample from geometric distribution, drawn from probability p # - if num_points > 0, then sample that number of points # Location of points # - if samp is 'normal', draw from N(0.5, 0.25) of image # - otherwise, draw from U[0, 1] of image N, C, H, W = data['ab'].shape data['hint_B'] = torch.zeros_like(data['ab']) data['mask_B'] = torch.zeros_like(data['gray']) if prev is not None: l2_dist = torch.sum(torch.pow(data['ab'] - prev, 2), dim=1).detach().numpy() k = 1 / opt.mean_kernel**2 * np.ones( [opt.mean_kernel, opt.mean_kernel]) l2_mean = np.zeros([ l2_dist.shape[0], int(opt.fineSize / opt.mean_kernel), int(opt.fineSize / opt.mean_kernel) ]) for i in range(l2_dist.shape[0]): l2_mean[i, :, :] = signal.convolve( l2_dist[i, :, :], k, mode="valid")[::opt.mean_kernel, ::opt.mean_kernel] # 7x7 mean for nn in range(N): pp = 0 cont_cond = True while cont_cond: if num_points is None: # draw from geometric # embed() cont_cond = np.random.rand() < (1 - p) else: # add certain number of points cont_cond = pp < num_points if not cont_cond: # skip out of loop if condition not met continue P = np.random.choice(opt.sample_Ps) # patch size # sample location if samp == 'normal': # geometric distribution h = int( np.clip( np.random.normal((H - P + 1) / 2., (H - P + 1) / 4.), 0, H - P)) w = int( np.clip( np.random.normal((W - P + 1) / 2., (W - P + 1) / 4.), 0, W - P)) elif samp == 'uniform': # uniform distribution h = np.random.randint(H - P + 1) w = np.random.randint(W - P + 1) # sample location - L2 distance method else: area_h_, area_w_ = np.where( l2_mean[nn, :, :] == np.max(l2_mean[nn, :, :])) area_h, area_w = area_h_[0] * opt.mean_kernel, area_w_[ 0] * opt.mean_kernel # set to 0 in case of repeating l2_mean[nn, area_h_[0], area_w_[0]] = 0 max_area = l2_dist[nn, area_h:area_h + opt.mean_kernel, area_w:area_w + opt.mean_kernel] h_, w_ = np.where(max_area == np.max(max_area)) h, w = h_[0] + area_h, w_[0] + area_w # add color point if use_avg: # embed() data['hint_B'][nn, :, h:h + P, w:w + P] = torch.mean( torch.mean(data['ab'][nn, :, h:h + P, w:w + P], dim=2, keepdim=True), dim=1, keepdim=True).view(1, C, 1, 1) else: data['hint_B'][nn, :, h:h + P, w:w + P] = data['ab'][nn, :, h:h + P, w:w + P] data['mask_B'][nn, :, h:h + P, w:w + P] = 1 # increment counter pp += 1 data['mask_B'] -= opt.mask_cent data['clicks'] = torch.cat((data['mask_B'], data['hint_B']), dim=1) return data
def vad(x, framelen=None, sr=None, frameshift=None): if sr is None: sr = 16000 if framelen is None: framelen = 256 if frameshift is None: frameshift = 128 amp_th1 = 8 amp_th2 = 20 zcr_th = 5 maxsilence = 8 minlen = 15 status = 0 count = 0 silence = 0 x = x / np.absolute(x).max() tmp1 = enframe(x[0:(len(x) - 1)], framelen, frameshift) tmp2 = enframe(x[1:(len(x) - 1)], framelen, frameshift) signs = (tmp1 * tmp2) < 0 diffs = (tmp1 - tmp2) > 0.05 zcr = np.sum(signs * diffs, axis=1) filter_coeff = np.array([1, -0.9375]) pre_emphasis = signal.convolve(x, filter_coeff)[0:len(x)] amp = np.sum(np.absolute(enframe(pre_emphasis, framelen, frameshift)), axis=1) amp_th1 = min(amp_th1, amp.max() / 3) amp_th2 = min(amp_th2, amp.max() / 8) x1 = [] x2 = [] t = 0 for n in range(len(zcr)): if status == 0 or status == 1: if amp[n] > amp_th1: x1.append(max(n - count - 1, 1)) status = 2 silence = 0 count = count + 1 elif amp[n] > amp_th2 or zcr[n] > zcr_th: status = 1 count = count + 1 else: status = 0 count = 0 continue if status == 2: if amp[n] > amp_th2 or zcr[n] > zcr_th: count = count + 1 else: silence = silence + 1 if silence < maxsilence: count = count + 1 elif count < minlen: status = 0 silence = 0 count = 0 else: status = 0 count = count - silence / 2 x2.append(x1[t] + count - 1) t = t + 1 return x1, x2
def smoothing(response, response_time): ''' Smoothing response :param response: numpy array (n_trial, n_time) :param response_time: numpy array (n_time,) :return: ''' dt = response_time[1] - response_time[0] filter_type = 'gauss' filter_width = 0.04 # Make filter if filter_type == 'gauss': # Filter parameters fw = filter_width # Time axis nt = round(fw*3.75/dt) tf = np.arange(-nt, nt+1)*dt # Make filter rf = np.exp(-tf**2/(2.*fw**2)) elif filter_type == 'box': # Filter parameters fw = filter_width # Box width nt = round(fw/2/dt) # Make filter rf = np.ones(2*nt+1) rf /= sum(rf) # Initialize response_smth = response # if len(rf) < 2: # return response_smth # Temporal smoothing # Dimensions n_trial, n_time = response.shape from scipy.signal import convolve # Loop over trials for i_trial in range(n_trial): # Pad extremes rpad = np.concatenate((np.repeat(response[i_trial,0], len(rf)), response[i_trial,:], np.repeat(response[i_trial,-1], len(rf)))) filtered = convolve(rpad, rf, mode='same') # Shift rfil = filtered[len(rf):len(rf)+n_time] response_smth[i_trial] = rfil return response_smth
def minimize_junction_Y(amplitude, peaks, peak_type, dx): print("Analyzing Y jaws...") amp_prev = 0 amp_filt_prev = 0 fig = plt.figure(figsize=(10, 6)) # create the plot kk = 0 # counter for figure generation for j in range(0, amplitude.shape[1] - 1): for k in range(j + 1, amplitude.shape[1]): # looping through remaining images # print('k=',k) amp_base_res = signal.convolve(amplitude[:, j], amplitude[:, j], mode="full") amp_base_res = signal.resample( amp_base_res / np.amax(amp_base_res), int(np.ceil(len(amp_base_res) / 2)), ) amp_overlay_res = signal.convolve(amplitude[:, k], amplitude[:, k], mode="full") amp_overlay_res = signal.resample( amp_overlay_res / np.amax(amp_overlay_res), int(np.ceil(len(amp_overlay_res) / 2)), ) peak1, _ = find_peaks(amp_base_res, prominence=0.5) peak2, _ = find_peaks(amp_overlay_res, prominence=0.5) if (abs(peak2 - peak1) < 2500 ): # if the two peaks are close together proceeed to analysis kk = kk + 1 # incrementing the figure generator cumsum_prev = 1e7 if peak2 < peak1: amp_base_res = amplitude[:, k] amp_overlay_res = amplitude[:, j] else: amp_base_res = amplitude[:, j] amp_overlay_res = amplitude[:, k] if (peak_type[kk - 1] == 0 ): # kk-1 to start from the null element of the array inc = -1 else: inc = 1 for i in range(0, inc * 80, inc * 1): # x = np.linspace(0, 0 + (len(amp_base_res) * dx), len(amplitude), # endpoint=False) # definition of the distance axis amp_overlay_res_roll = np.roll(amp_overlay_res, i) # amplitude is the vector to analyze +-500 samples from the center amp_tot = ( amp_base_res[peaks[kk - 1] - 1000:peaks[kk - 1] + 1000] + amp_overlay_res_roll[peaks[kk - 1] - 1000:peaks[kk - 1] + 1000] ) # divided by 2 to normalize # print('Analyzing peak=',peaks[kk - 1]) # xsel = x[peaks[kk-1] - 1000:peaks[kk-1] + 1000] amp_filt = rm.running_mean(amp_tot, 281) cumsum = np.sum(np.abs(amp_tot - amp_filt)) if ( # pylint: disable = no-else-break cumsum > cumsum_prev): # then we went too far break else: amp_prev = amp_tot amp_filt_prev = amp_filt cumsum_prev = cumsum ax = fig.add_subplot(amplitude.shape[1] - 1, 1, kk) ax.plot(amp_prev) ax.plot(amp_filt_prev) if kk == 1: ax.set_title("Minimization result", fontsize=16) if (kk == amplitude.shape[1] - 1 ): # if we reach the final plot the add the x axis label ax.set_xlabel("distance [mm]") ax.set_ylabel("amplitude") if peaks[kk - 1] != 0: ax.annotate( "delta=" + str(abs(i - inc * 1) * dx) + " mm", xy=(2, 1), xycoords="axes fraction", xytext=(0.35, 0.10), ) else: ax.annotate( "delta= 0 mm (NO PEAK FOUND)", xy=(2, 1), xycoords="axes fraction", xytext=(0.35, 0.10), ) # else: # print(j, k, 'the data is not contiguous finding another curve in dataset') return fig
def mix_spc_noi_0401(self, mode): """ (1) load multi-channel speech (2) calculate noise rir (=speech rir + 90/180/270 degree) (3) convolve noise (random selected) and noise rir (4) mix multi-channel speech and multi-channel noise with SNR (random selected) :param mode: tr/cv/tt :return: save noisy(mix), clean(s1), noise(s2) files / save 'output.csv' file """ # path set spc_path = os.getcwd() + '/multi_channel_speech/' + mode noi_path = os.getcwd() + '/Data/' + mode + '/noise' snr_list = [-5, 0, 5, 10, 15, 20] save_path = os.getcwd() + '/output/' + mode Path(save_path + '/mix').mkdir(parents=True, exist_ok=True) Path(save_path + '/s1').mkdir(parents=True, exist_ok=True) Path(save_path + '/s2').mkdir(parents=True, exist_ok=True) # multi-channel speech list s_list = glob(spc_path + '/*.wav') # single-channel noise list n_list = glob(noi_path + '/*.wav') # make 'output.csv' f = open(f'output/{mode}/output.csv', 'w', newline='') wr = csv.writer(f) wr.writerow([ 'order', 'speech', 'room', 'speech_rir', 'noise', 'noise_rir', 'azimuth', 'snr' ]) for i, s in enumerate(s_list): multi_ch_aud, fs = librosa.core.load(s, sr=None, mono=False) multi_ch_aud_na = os.path.splitext(os.path.basename(s))[0] # select noise azimuth split = multi_ch_aud_na.split('_') spc_na = f'{split[-2]}_{split[-1]}' spc_rir_na = f'{split[1]}_{split[2]}_{split[3]}' # print(time.time() - start) # noise rir = speech rir + 90/180/270 degree az = int(split[1][2:]) room = split[0] n = np.random.randint(1, 4) noi_az = (az + 90 * n) % 360 # +90 +180 +270 degree split = multi_ch_aud_na.split('_') noi_rir_na = f'az{noi_az}_{split[2]}_{split[3]}' noi_rir = os.getcwd() + f'/rir/{mode}/{split[0]}/{noi_rir_na}.npz' if mode == 'cv': noi_rir = os.getcwd() + f'/rir/tr/{split[0]}/{noi_rir_na}.npz' # select and load random noise idx_n = np.random.randint(0, len(n_list)) noi, fs2 = librosa.core.load(n_list[idx_n], sr=None) noi_na = os.path.splitext(os.path.basename(n_list[idx_n]))[0] assert fs == fs2 # convolve noise with RIR npz = np.load(noi_rir, allow_pickle=True) rir = npz['rir'] rand_start = np.random.randint( 0, noi.shape[0] - multi_ch_aud.shape[1] - 8191) multi_ch_noi_tmp = ss.convolve( rir, noi[rand_start:rand_start + multi_ch_aud.shape[1] + 8191, np.newaxis]) multi_ch_noi = multi_ch_noi_tmp[8191:-8191, :].transpose() # mix speech and noise with SNR idx_snr = np.random.randint(0, len(snr_list)) snr = snr_list[idx_snr] noisy, clean, noise = self.snr_mix(multi_ch_aud, multi_ch_noi, snr) audiowrite( save_path + f'/mix/noisy_{i + 1:#05d}_{noi_na}_{snr}.wav', noisy.transpose(), fs) audiowrite(save_path + f'/s1/clean_{i + 1:#05d}.wav', clean.transpose(), fs) audiowrite(save_path + f'/s2/noise_{i + 1:#05d}.wav', noise.transpose(), fs) wr.writerow( [i, spc_na, room, spc_rir_na, noi_na, noi_rir_na, 90 * n, snr]) f.close()
zeroframe = np.mean(bigzero, axis=2) print(np.mean(zerolist - zeroframe)) print(np.std(zerolist - zeroframe)) #quit() hdulist = fits.open('Dark40.fit') darkarr = hdulist[0].data redarr = darkarr - zeroframe bins = range(-20, 40) plt.hist(np.ravel(redarr), bins, normed='True') #plt.show() #print(np.mean(bigzero(100,100,:)),np.std(bigzero(100,100,:))) #hdulist = fits.open('Dark120.fit') #dark40arr = hdulist[0].data #hdulist.close() #redim= np.abs(dark40arr - zeroarr) #bins= range(0,40) #plt.hist(np.ravel(redim), bins,normed='True') xlist = np.arange(-20, 50, 0.01) ylist = Poisson(xlist, 2.4) ylist[ylist == np.inf] = 0 print(np.mean(redarr)) zlist = gaussian(np.arange(0, 40, 0.01), 20, 8) conlist = convolve(ylist, zlist, mode='same') / 100 plt.plot(xlist, conlist) plt.show()
def analysis(self): """ For each session, channel """ if self.subject_data is None: print('%s: compute or load data first with .load_data()!' % self.subject) # open a parallel pool using joblib # with Parallel(n_jobs=int(NUM_CORES/2) if NUM_CORES != 1 else 1, verbose=5) as parallel: # loop over sessions for session_name, session_grp in self.subject_data.items(): print('{} processing.'.format(session_grp.name)) # and channels for channel_num, channel_grp in tqdm(session_grp.items()): self.res[channel_grp.name] = {} self.res[channel_grp.name]['firing_rates'] = {} # load behavioral events events = pd.read_hdf(self.subject_data.filename, channel_grp.name + '/event') events['item_name'] = events.name.apply(lambda x: x.split('_')[1]) # load eeg for this channel. eeg_channel = self._create_eeg_timeseries(channel_grp, events) # length of buffer in samples. Used below for extracting smoothed spikes # samples = int(np.ceil(float(eeg_channel['samplerate']) * self.buffer)) # also store region and hemisphere for easy reference. and time self.res[channel_grp.name]['region'] = eeg_channel.event.data['region'][0] self.res[channel_grp.name]['hemi'] = eeg_channel.event.data['hemi'][0] # for each cluster in the channel, summarize the spike activity for cluster_num, cluster_grp in channel_grp['spike_times'].items(): clust_str = cluster_grp.name.split('/')[-1] # first compute number of spikes at each timepoint and the time in samples when each occurred spike_counts, spike_rel_times = self._create_spiking_counts(cluster_grp, events, eeg_channel.shape[1]) # based on the spiking, compute firing rate and normalized firing rate for the default # presentation interval firing_df = self._make_firing_df(eeg_channel.time.data, spike_counts, events) # also smooth firing rate and compute the above info for binned chunks of time kern_width_samples = int(eeg_channel.samplerate.data / (1000/self.kern_width)) kern = signal.gaussian(kern_width_samples, self.kern_sd) kern /= kern.sum() smoothed_spike_counts = np.stack([signal.convolve(x, kern, mode='same') for x in spike_counts], 0) # now compute the firing rate data for the binned intervals df_binned = [] for this_bin in self.binned_intervals: this_df = self._make_firing_df(eeg_channel.time.data, smoothed_spike_counts, events, item_interval=this_bin) this_df = pd.concat([this_df], keys=['{}-{}'.format(*this_bin)]) df_binned.append(this_df) df_binned = pd.concat(df_binned, axis=0) self.res[channel_grp.name]['firing_rates'][clust_str] = {} self.res[channel_grp.name]['firing_rates'][clust_str]['paired_firing_df'] = firing_df self.res[channel_grp.name]['firing_rates'][clust_str]['binned_paired_firing_df'] = df_binned
def mix_spc_noi_tt(self): """ (1) load single channel speech / single channel speech (2) select speech rir and noise rir (3) convolve speech(noise) and speech(noise) rir (4) mix multi-channel speech and multi-channel noise (5) room(2) * noise(4) * SNR(5) :return: save noisy(mix), clean(s1), noise(s2) files / save 'output.csv' file """ # path set spc_path = '/home/dail/PycharmProjects/DCCRN/datasets/tr/clean' noi_path = '/home/dail/PycharmProjects/DCCRN/datasets/tr/noise' snr_list = [-5, 0, 5, 10, 15] save_path = os.getcwd() + '/output/tt' Path(save_path + '/mix').mkdir(parents=True, exist_ok=True) Path(save_path + '/s1').mkdir(parents=True, exist_ok=True) Path(save_path + '/s2').mkdir(parents=True, exist_ok=True) # multi-channel speech list s_list = glob(spc_path + '/*.wav') # single-channel noise list n_list = glob(noi_path + '/*.wav') # make 'output.csv' f = open(f'output/tt/output.csv', 'w', newline='') wr = csv.writer(f) wr.writerow([ 'order', 'speech', 'room', 'speech_rir', 'noise', 'noise_rir', 'snr' ]) cnt = 0 for i, s in enumerate(s_list): # multi_ch_aud, fs = librosa.core.load(s, sr=None, mono=False) # multi_ch_aud_na = os.path.splitext(os.path.basename(s))[0] spc, fs = audioread(s) spc_na = os.path.splitext(os.path.basename(s))[0] # select speech/noise rir # np.random.seed(1) rand_azi_s = np.random.choice( np.concatenate((np.arange(31), np.arange(330, 360)), axis=0)) # np.random.seed(1) rand_azi_n = np.random.choice(np.arange(180, 271)) rand_r = np.round(np.random.choice(np.linspace(1, 2.2, 5)), 1) spc_rir_na = f'az{rand_azi_s}_el0_r{rand_r}' noi_rir_na = f'az{rand_azi_n}_el0_r{rand_r}' room = ['R4', 'R5'] # room for n in range(2): spc_rir = os.getcwd() + f'/rir/tt/{room[n]}/{spc_rir_na}.npz' npz_s = np.load(spc_rir, allow_pickle=True) rir_s = npz_s['rir'] multi_ch_spc = ss.convolve(rir_s, spc[:, np.newaxis]) multi_ch_spc = multi_ch_spc.transpose() noi_rir = os.getcwd() + f'/rir/tt/{room[n]}/{noi_rir_na}.npz' npz_n = np.load(noi_rir, allow_pickle=True) rir_n = npz_n['rir'] # noise for idx_n in range(len(n_list)): noi, fs2 = librosa.core.load(n_list[idx_n], sr=None) noi_na = os.path.splitext(os.path.basename( n_list[idx_n]))[0] assert fs == fs2 rand_start = np.random.randint( 0, noi.shape[0] - multi_ch_spc.shape[1] - 8191) multi_ch_noi_tmp = ss.convolve( rir_n, noi[rand_start:rand_start + multi_ch_spc.shape[1] + 8191, np.newaxis]) multi_ch_noi = multi_ch_noi_tmp[8191:-8191, :].transpose() # mix speech and noise with SNR # idx_snr = np.random.randint(0, len(snr_list)) for l in range(len(snr_list)): cnt = cnt + 1 snr = snr_list[l] noisy, clean, noise = self.snr_mix( multi_ch_spc, multi_ch_noi, snr) audiowrite( save_path + f'/mix/noisy_{cnt:#05d}_{noi_na}_{snr}.wav', noisy.transpose(), fs) audiowrite(save_path + f'/s1/clean_{cnt:#05d}.wav', clean.transpose(), fs) audiowrite(save_path + f'/s2/noise_{cnt:#05d}.wav', noise.transpose(), fs) wr.writerow([ cnt, spc_na, room[n], spc_rir_na, noi_na, noi_rir_na, snr ]) f.close()
def convolution_filter(x, filt, nsides=2): """ Linear filtering via convolution. Centered and backward displaced moving weighted average. Parameters ---------- x : array_like data array, 1d or 2d, if 2d then observations in rows filt : array_like Linear filter coefficients in reverse time-order. Should have the same number of dimensions as x though if 1d and ``x`` is 2d will be coerced to 2d. nsides : int, optional If 2, a centered moving average is computed using the filter coefficients. If 1, the filter coefficients are for past values only. Both methods use scipy.signal.convolve. Returns ------- y : ndarray, 2d Filtered array, number of columns determined by x and filt. If a pandas object is given, a pandas object is returned. The index of the return is the exact same as the time period in ``x`` Notes ----- In nsides == 1, x is filtered :: y[n] = filt[0]*x[n-1] + ... + filt[n_filt-1]*x[n-n_filt] where n_filt is len(filt). If nsides == 2, x is filtered around lag 0 :: y[n] = filt[0]*x[n - n_filt/2] + ... + filt[n_filt / 2] * x[n] + ... + x[n + n_filt/2] where n_filt is len(filt). If n_filt is even, then more of the filter is forward in time than backward. If filt is 1d or (nlags,1) one lag polynomial is applied to all variables (columns of x). If filt is 2d, (nlags, nvars) each series is independently filtered with its own lag polynomial, uses loop over nvar. This is different than the usual 2d vs 2d convolution. Filtering is done with scipy.signal.convolve, so it will be reasonably fast for medium sized data. For large data fft convolution would be faster. """ # for nsides shift the index instead of using 0 for 0 lag this # allows correct handling of NaNs if nsides == 1: trim_head = len(filt) - 1 trim_tail = None elif nsides == 2: trim_head = int(np.ceil(len(filt) / 2.) - 1) or None trim_tail = int(np.ceil(len(filt) / 2.) - len(filt) % 2) or None else: # pragma : no cover raise ValueError("nsides must be 1 or 2") pw = PandasWrapper(x) x = array_like(x, 'x', maxdim=2) filt = array_like(filt, 'filt', ndim=x.ndim) if filt.ndim == 1 or min(filt.shape) == 1: result = signal.convolve(x, filt, mode='valid') else: # filt.ndim == 2 nlags = filt.shape[0] nvar = x.shape[1] result = np.zeros((x.shape[0] - nlags + 1, nvar)) if nsides == 2: for i in range(nvar): # could also use np.convolve, but easier for swiching to fft result[:, i] = signal.convolve(x[:, i], filt[:, i], mode='valid') elif nsides == 1: for i in range(nvar): result[:, i] = signal.convolve(x[:, i], np.r_[0, filt[:, i]], mode='valid') result = _pad_nans(result, trim_head, trim_tail) return pw.wrap(result)
(4 * K * t)) + np.exp(-((x + x_o + v * t - 2 * n * l)**2) / (4 * K * t)) I_x += np.exp(-((x - x_o - v * t - 2 * n * l)**2) / (4 * K * t)) + np.exp(-((x + x_o + v * t + 2 * n * l)**2) / (4 * K * t)) sinks = np.exp( -(Q + d + s) * t ) #numpy array of size len(t). Calculates the effect of ventilation, deactivation and settling sinks I = 1 / ( 4 * np.pi * K * t ) * I_y * I_x * sinks #Impulse function at (x,y) - numpy array of size len(t) #use Scipy Convolve function for S and I to calculate the C at (x,y) C = convolve(S, I)[0:len(t)] / (h / 2) #use Scipy cumtrapz function to calculate the dose (array of len(t)-1) at (x,y) dose = p * cumtrapz(C, t) #calculate P (array of len(t)-1) P = 1 - np.exp(-dose * k) t = t / 60 #convert time-axis to minutes for plotting of graph P = P * 100 #convert probability to percent for plotting of graph #Uses Matplotlib.pyplot to produce a line graph P vs t[1:] plt.plot(t[1:], P) #Change axis fontsize to 12 plt.xticks(fontsize=12) plt.yticks(fontsize=12) #label axes plt.xlabel("Time (min)")
for i in range(box_width, len(d)-1): if i % 1000 == 0: print(i) data = np.array(d[(i - box_width+1):(i+1)]) sigs = np.zeros((data.shape[0], 3)) sigs[..., 0] = (data[..., 0] + data[..., 1])/2.0 sigs[..., 1] = (data[..., 2] + data[..., 3])/2.0 sigs[..., 2] = (data[..., 4] + data[..., 5])/2.0 # fft_len = np.fft.rfft(data[..., 0]).shape[0] features = np.array([]) for j in range(3): sig = sigs[..., j] conv1 = signal.convolve(sig, wavelet1, 'same') conv2 = signal.convolve(sig, wavelet2, 'same') fourier = np.fft.fft(sig) fourier1 = np.fft.fft(conv1) fourier2 = np.fft.fft(conv2) features = np.hstack([features, np.abs(fourier), np.abs(fourier1), np.abs(fourier2)]) # not sure if this is a good idea --> # features = np.hstack([features, np.angle(fourier), np.angle(fourier1), np.angle(fourier2)]) features_arr[i, ...] = features feature_names = [] for i in range(3): feature_names.extend(['c' + str(i) + '_abs_A_' + str(x)
def _test(): convolve(a, b, 'valid')
def _fast_kde(x, cumulative=False, bw=4.5, xmin=None, xmax=None): """Fast Fourier transform-based Gaussian kernel density estimate (KDE). The code was adapted from https://github.com/mfouesneau/faststats Parameters ---------- x : Numpy array or list cumulative : bool If true, estimate the cdf instead of the pdf bw : float Bandwidth scaling factor for the KDE. Should be larger than 0. The higher this number the smoother the KDE will be. Defaults to 4.5 which is essentially the same as the Scott's rule of thumb (the default rule used by SciPy). xmin : float Manually set lower limit. xmax : float Manually set upper limit. Returns ------- density: A gridded 1D KDE of the input points (x) xmin: minimum value of x xmax: maximum value of x """ x = np.asarray(x, dtype=float) x = x[np.isfinite(x)] if x.size == 0: warnings.warn("kde plot failed, you may want to check your data") return np.array([np.nan]), np.nan, np.nan len_x = len(x) n_points = 200 if (xmin or xmax) is None else 500 if xmin is None: xmin = np.min(x) if xmax is None: xmax = np.max(x) assert np.min(x) >= xmin assert np.max(x) <= xmax log_len_x = np.log(len_x) * bw n_bins = min(int(len_x ** (1 / 3) * log_len_x * 2), n_points) if n_bins < 2: warnings.warn("kde plot failed, you may want to check your data") return np.array([np.nan]), np.nan, np.nan _, grid, _ = histogram(x, n_bins, range_hist=(xmin, xmax)) scotts_factor = len_x ** (-0.2) kern_nx = int(scotts_factor * 2 * np.pi * log_len_x) kernel = gaussian(kern_nx, scotts_factor * log_len_x) npad = min(n_bins, 2 * kern_nx) grid = np.concatenate([grid[npad:0:-1], grid, grid[n_bins : n_bins - npad : -1]]) density = convolve(grid, kernel, mode="same", method="direct")[npad : npad + n_bins] norm_factor = (2 * np.pi * log_len_x ** 2 * scotts_factor ** 2) ** 0.5 density /= norm_factor if cumulative: density = density.cumsum() / density.sum() return density, xmin, xmax
def test_zero_order(self): a = 1289 b = 4567 c = convolve(a, b) assert_array_equal(c, a * b)
#del original_data additiveout = calibrators[pol].lincal(data[p], additivein, nthread=nthread, verbose=True) #######################remove additive############################### if removeadditive: nadditiveloop = 1 for i in range(nadditiveloop): #subtimer = omni.Timer() additivein[:, :, calibrators[pol].Info. subsetbl] = additivein[:, :, calibrators[pol].Info. subsetbl] + additiveout weight = ss.convolve(np.ones(additivein.shape[0]), np.ones(removeadditiveperiod * 2 + 1), mode='same') #for f in range(additivein.shape[1]):#doing for loop to save memory usage at the expense of negligible time #additivein[:,f] = ss.convolve(additivein[:,f], np.ones(removeadditiveperiod * 2 + 1)[:, None], mode='same')/weight[:, None] additivein = ( (sfil.convolve1d(np.real(additivein), np.ones(removeadditiveperiod * 2 + 1), mode='constant') + 1j * sfil.convolve1d(np.imag(additivein), np.ones(removeadditiveperiod * 2 + 1), mode='constant')) / weight[:, None, None]).astype('complex64') calibrators[pol].computeUBLFit = False additiveout = calibrators[pol].lincal(data[p], additivein, nthread=nthread,
def test_basic(self): a = [3, 4, 5, 6, 5, 4] b = [1, 2, 3] c = convolve(a, b) assert_array_equal(c, array([3, 10, 22, 28, 32, 32, 23, 12]))
# %% from scipy import signal import sympy as sp import numpy as np # %% X = [1, -2, 3, 4] H = [1, 2, 3] Y = signal.convolve(X, H) print("conv", Y) X = [11, 8, 3, 7, 5, 100, 13, 74, 19] H = [8, 3, 7] Y = signal.correlate(X, H) print("cor", Y) Xx, rem = signal.deconvolve(Y, H) print("deconv", Xx) #%% def matest(a): if type(a) == list: return np.array([a]) else: return a def my_conv(X, H): X = matest(X) H = matest(H)
z1, p1, k1 = sig.tf2zpk(Gnum, Gden) z2, p2, k2 = sig.tf2zpk(Anum, Aden) broot = np.roots(B) print("Z1: ", z1) print("P1: ", p1) print("K1: ", k1) print("Z2: ", z2) print("P2: ", p2) print("K2: ", k2) print("Broots: ", broot) opennum = sig.convolve(Gnum, Anum) openden = sig.convolve(Gden, Aden) tout1, yout1 = sig.step((opennum, openden), T=t) plt.figure(figsize=(10, 10)) plt.plot(tout1, yout1) plt.title('Part One: Open System') closenum = sig.convolve(Anum, Gnum) #den1= sig.convolve(Gnum, B) #print(len(den1)) #print(len(Gden)) #den2 = den1 + Gden #closeden= sig.convolve(Aden, den2) closeden = sig.convolve(Aden, (sig.convolve(Gnum, B) + Gden))
def main(argv=sys.argv): global eplat, eplon, epdepth, orig GFdir = "/home/roberto/data/GFS/" beta = 4.e3 #m/s rho = 3.e3 #kg/m^3 mu = rho*beta*beta mu =40e9 Lbdm0min = 1e-26*np.array([125.]) Lbdsmooth = 1e-26*np.array([100.]) #~ Lbdm0min = 1e-26*np.linspace(60.,500,40) #~ Lbdsmooth = 1e-26*np.linspace(60.,500,40)#*0.5 corners = 4. fmin = 0.001 fmax = 0.005 ### Data from Chilean 2010 EQ (Same as W phase inv.) strike = 18. dip = 18. rake = 104. # 109. #rake = 45. rakeA = rake + 45. rakeB = rake - 45. #################### nsx = 21 nsy = 11 Min_h = 10. flen = 600. #Fault's longitude [km] along strike fwid = 300. #Fault's longitude [km] along dip sflen = flen/float(nsx) sfwid = fwid/float(nsy) swp = [1, 0, 2] nsf = nsx*nsy ################### t_h = 10. MISFIT = np.array([]) #RUPVEL = np.arange(1.0, 5.0, 0.05) RupVel = 2.1 # Best fit #RupVel = 2.25 #From Lay et al. #for RupVel in RUPVEL: print "****************************" print RupVel print "****************************" NP = [strike, dip, rake] NPA = [strike, dip, rakeA] NPB = [strike, dip, rakeB] M = np.array(NodalPlanetoMT(NP)) MA = np.array(NodalPlanetoMT(NPA)) MB = np.array(NodalPlanetoMT(NPB)) Mp = np.sum(M**2)/np.sqrt(2) ############# #Loading req file and EQparameters parameters={} with open(argv[1],'r') as file: for line in file: line = line.split() key = line[0] val = line[1:] parameters[key] = val #~ cmteplat = float(parameters['eplat'][0]) #~ cmteplon = float(parameters['eplon'][0]) #~ cmtepdepth=float(parameters['epdepth'][0]) orig = UTCDateTime(parameters['origin_time'][0]) ####Hypocentre from ### http://earthquake.usgs.gov/earthquakes/eqinthenews/2010/us2010tfan/ cmteplat = -35.91#-35.85#-36.03#-35.83 cmteplon = -72.73#-72.72#-72.83# -72.67 cmtepdepth= 35. eq_hyp = (cmteplat,cmteplon,cmtepdepth) ############ grid, sblt = fault_grid('CL-2010',cmteplat,cmteplon,cmtepdepth,0, Min_h,\ strike, dip, rake, flen, fwid, nsx, nsy, Verbose=False, ffi_io=True, gmt_io=True) print ('CL-2010',cmteplat,cmteplon,cmtepdepth,0, Min_h,\ strike, dip, rake, flen, fwid, nsx, nsy,\ ) print grid[0][1] #sys.exit() ############# #Loading files and setting dirs: inputfile = os.path.abspath(argv[1]) if not os.path.exists(inputfile): print inputfile, "does not exist."; exit() workdir = "/".join(inputfile.split("/")[:-1]) basename = inputfile.split("/")[-1][:-4] if workdir[-1] != "/": workdir += "/" try : os.mkdir(workdir+"WPinv") except OSError: pass#print "Directory WPtraces already exists. Skipping" trfile = open(workdir+"goodtraces.dat") trlist = [] #Loading Good traces files: while 1: line = trfile.readline().rstrip('\r\n') if not line: break trlist.append(line.split()[0]) trfile.close() ############# # Reading traces: st = read(workdir+"WPtraces/" + basename + ".decov.trim.mseed") ############################################################################# ######Determining the sf closest to the hypocentre: min_Dist_hyp_subf = flen *fwid for subf in range(nsf): sblat = grid[subf][1] sblon = grid[subf][0] sbdepth = grid[subf][2] sf_hyp = (sblat,sblon, sbdepth) Dist_hyp_subf = hypo2dist(eq_hyp,sf_hyp) if Dist_hyp_subf < min_Dist_hyp_subf: min_Dist_hyp_subf = Dist_hyp_subf min_sb_hyp = sf_hyp hyp_subf = subf print hyp_subf, min_sb_hyp, min_Dist_hyp_subf ####Determining trimming times: test_tr = read(GFdir + "H003.5/PP/GF.0001.SY.LHZ.SAC")[0] t0 = test_tr.stats.starttime TrimmingTimes = {} # Min. Distace from the fault to each station. A =0 for trid in trlist: tr = st.select(id=trid)[0] metafile = workdir + "DATA/" + "META." + tr.id + ".xml" META = DU.getMetadataFromXML(metafile)[tr.id] stlat = META['latitude'] stlon = META['longitude'] dist = locations2degrees(min_sb_hyp[0],min_sb_hyp[1],\ stlat,stlon) parrivaltime = getTravelTimes(dist,min_sb_hyp[2])[0]['time'] ta = t0 + parrivaltime tb = ta + round(15.*dist) TrimmingTimes[trid] = (ta, tb) ############################################################################## ##### DIST = [] # Ordering the stations in terms of distance for trid in trlist: metafile = workdir + "DATA/" + "META." + trid + ".xml" META = DU.getMetadataFromXML(metafile)[trid] lat = META['latitude'] lon = META['longitude'] trdist = locations2degrees(cmteplat,cmteplon,lat,lon) DIST.append(trdist) DistIndex = lstargsort(DIST) if len(argv) == 3: trlist = [argv[2]] OneStation = True else: trlist = [trlist[i] for i in DistIndex] OneStation = False ##### client = Client() ObservedDisp = np.array([]) gridlat = [] gridlon = [] griddepth = [] sbarea = [] mindist = flen*fwid # min distance hyp-subfault ##########Loop for each subfault for subf in range(nsf): print "**********" print subf eplat = grid[subf][1] eplon = grid[subf][0] epdepth = grid[subf][2] ## Storing the subfault's location centered in the hypcenter gridlat.append(eplat-cmteplat) gridlon.append(eplon-cmteplon) griddepth.append(epdepth) strike = grid[subf][3] #+ 360. dip = grid[subf][4] rake = grid[subf][5] # NP = [strike, dip, rake] M = np.array(NodalPlanetoMT(NP)) #Calculating the time dalay: sf_hyp = (eplat,eplon, epdepth) Dist_ep_subf = hypo2dist(eq_hyp,sf_hyp) t_d = round(Dist_ep_subf/RupVel) #-59. print eplat,eplon, epdepth #t_d = 0. # Determining depth dir: depth = [] depthdir = [] for file in os.listdir(GFdir): if file[-2:] == ".5": depthdir.append(file) depth.append(float(file[1:-2])) BestDirIndex = np.argsort(abs(epdepth-np.array(depth)))[0] hdir = GFdir + depthdir[BestDirIndex] + "/" # hdir is the absolute path to the closest deepth. SYN = np.array([]) SYNA = np.array([]) SYNB = np.array([]) #Main loop : for trid in trlist: tr = st.select(id=trid)[0] metafile = workdir + "DATA/" + "META." + tr.id + ".xml" META = DU.getMetadataFromXML(metafile)[tr.id] lat = META['latitude'] lon = META['longitude'] trPPsy, trRRsy, trRTsy, trTTsy = \ GFSelectZ(lat,lon,hdir) tr.stats.delta = trPPsy.stats.delta azi = -np.pi/180.*gps2DistAzimuth(lat,lon,\ eplat,eplon)[2] trROT = MTrotationZ(azi, trPPsy, trRRsy, trRTsy, trTTsy) #Triangle dt = trROT[0].stats.delta trianglen = 2.*t_h/dt-1. window = triang(trianglen) window /= np.sum(window) #window = np.array([1.]) FirstValid = int(trianglen/2.) + 1 dist = locations2degrees(eplat,eplon,lat,lon) parrivaltime = getTravelTimes(dist,epdepth)[0]['time'] t1 = TrimmingTimes[trid][0] - t_d t2 = TrimmingTimes[trid][1] - t_d #~ t1 = trROT[0].stats.starttime + parrivaltime- t_d #~ t2 = t1+ round(MinDist[tr.id]*15. ) N = len(trROT[0]) for trR in trROT: trR.data *= 10.**-21 ## To get M in Nm trR.data -= trR.data[0] AUX1 = len(trR) trR.data = convolve(trR.data,window,mode='valid') AUX2 = len(trR) mean = np.mean(np.hstack((trR.data[0]*np.ones(FirstValid),\ trR.data[:60./trR.stats.delta*1.-FirstValid+1]))) #mean = np.mean(trR.data[:60]) trR.data -= mean trR.data = bp.bandpassfilter(trR.data,len(trR), trR.stats. delta, corners , 1 , fmin, fmax) t_l = dt*0.5*(AUX1 - AUX2) trR.trim(t1-t_l,t2-t_l, pad=True, fill_value=trR.data[0]) #We lost t_h due to the convolution #~ for trR in trROT: #~ trR.data *= 10.**-23 ## To get M in Nm #~ trR.data -= trR.data[0] #~ trR.data = convolve(trR.data,window,mode='same') #~ # mean = np.mean(np.hstack((trR.data[0]*np.ones(FirstValid),\ #~ # trR.data[:60./trR.stats.delta*1.-FirstValid+1]))) #~ mean = np.mean(trR.data[:60]) #~ trR.data -= mean #~ trR.data = bp.bandpassfilter(trR.data,len(trR), trR.stats.delta,\ #~ corners ,1 , fmin, fmax) #~ trR.trim(t1,t2,pad=True, fill_value=trR.data[0]) nmin = min(len(tr.data),len(trROT[0].data)) tr.data = tr.data[:nmin] for trR in trROT: trR.data = trR.data[:nmin] ############# trROT = np.array(trROT) syn = np.dot(trROT.T,M) synA = np.dot(trROT.T,MA) synB = np.dot(trROT.T,MB) SYN = np.append(SYN,syn) SYNA = np.append(SYNA,synA) SYNB = np.append(SYNB,synB) if subf == 0 : ObservedDisp = np.append(ObservedDisp,tr.data,0) sbarea.append(grid[subf][6]) print np.shape(A), np.shape(np.array([SYN])) if subf == 0: A = np.array([SYN]) AA = np.array([SYNA]) AB = np.array([SYNB]) else: A = np.append(A,np.array([SYN]),0) AA = np.append(AA,np.array([SYNA]),0) AB = np.append(AB,np.array([SYNB]),0) #Full matrix with the two rake's component AC = np.vstack((AA,AB)) #MISFIT = np.array([]) ########## Stabilizing the solution: #### Moment minimization: #~ constraintD = np.zeros(nsf) #~ ObservedDispcons = np.append(ObservedDisp,constraintD) #~ for lbd in Lbd: #~ constraintF = lbd*np.eye(nsf,nsf) #~ Acons = np.append(A,constraintF,1) #~ print np.shape(Acons.T), np.shape(ObservedDispcons) #~ R = nnls(Acons.T,ObservedDispcons) #~ M = R[0] #~ #M = np.zeros(nsf) #~ #M[::2] = 1 #~ fit = np.dot(A.T,M) #~ misfit = 100.*np.sum(np.abs(fit-ObservedDisp))\ #~ /np.sum(np.abs(ObservedDisp)) #~ MISFIT = np.append(MISFIT,misfit) #~ plt.figure() #~ plt.plot(Lbd,MISFIT) #~ ########################################### #~ ### Smoothing: #~ constraintF_base = SmoothMatrix(nsx,nsy) #~ constraintD = np.zeros(np.shape(constraintF_base)[0]) #~ ObservedDispcons = np.append(ObservedDisp,constraintD) #~ for lbd in Lbd: #~ constraintF = lbd*constraintF_base #~ Acons = np.append(A,constraintF.T,1) #~ #print np.shape(Acons.T), np.shape(ObservedDispcons) #~ R = nnls(Acons.T,ObservedDispcons) #~ M = R[0] #~ fit = np.dot(A.T,M) #~ misfit = 100.*np.sum(np.abs(fit-ObservedDisp))\ #~ /np.sum(np.abs(ObservedDisp)) #~ print lbd, misfit #~ MISFIT = np.append(MISFIT,misfit) #~ ########################################### ########################################### #~ ##### Moment Minimization (including rake projections): #~ constraintD = np.zeros(2*nsf) #~ ObservedDispcons = np.append(ObservedDisp,constraintD) #~ for lbd in Lbd: #~ constraintF = lbd*np.eye(2*nsf,2*nsf) #~ ACcons = np.append(AC,constraintF,1) #~ print np.shape(ACcons.T), np.shape(ObservedDispcons) #~ R = nnls(ACcons.T,ObservedDispcons) #~ M = R[0] #~ fit = np.dot(AC.T,M) #~ misfit = 100.*np.sum(np.abs(fit-ObservedDisp))\ #~ /np.sum(np.abs(ObservedDisp)) #~ MISFIT = np.append(MISFIT,misfit) #~ M = np.sqrt(M[:nsf]**2+M[nsf:]**2) ############################################## ### Smoothing (including rake projections): #~ constraintF_base = SmoothMatrix(nsx,nsy) #~ Nbase = np.shape(constraintF_base)[0] #~ constraintD = np.zeros(2*Nbase) #~ constraintF_base_big = np.zeros((2*Nbase, 2*nsf)) #~ constraintF_base_big[:Nbase,:nsf]= constraintF_base #~ constraintF_base_big[Nbase:,nsf:]= constraintF_base #~ ObservedDispcons = np.append(ObservedDisp,constraintD) #~ for lbd in Lbd: #~ constraintF = lbd*constraintF_base_big #~ ACcons = np.append(AC,constraintF.T,1) #~ #print np.shape(Acons.T), np.shape(ObservedDispcons) #~ R = nnls(ACcons.T,ObservedDispcons) #~ M = R[0] #~ fit = np.dot(AC.T,M) #~ misfit = 100.*np.sum(np.abs(fit-ObservedDisp))\ #~ /np.sum(np.abs(ObservedDisp)) #~ print lbd, misfit #~ MISFIT = np.append(MISFIT,misfit) #~ M = np.sqrt(M[:nsf]**2+M[nsf:]**2) ########################################### #~ ##### Moment Minimization and Smoothing #~ #### (including rake projections): #~ mom0 = [] #~ constraintF_base = SmoothMatrix(nsx,nsy) #~ Nbase = np.shape(constraintF_base)[0] #~ constraintDsmoo = np.zeros(2*Nbase) #~ constraintDmin = np.zeros(2*nsf) #~ constraintF_base_big = np.zeros((2*Nbase, 2*nsf)) #~ constraintF_base_big[:Nbase,:nsf]= constraintF_base #~ constraintF_base_big[Nbase:,nsf:]= constraintF_base #~ ObservedDispcons = np.concatenate((ObservedDisp, #~ constraintDmin, #~ constraintDsmoo )) #~ for lbdm0 in Lbdm0min: #~ constraintFmin = lbdm0*np.eye(2*nsf,2*nsf) #~ for lbdsm in Lbdsmooth: #~ constraintFsmoo = lbdsm*constraintF_base_big #~ ACcons = np.hstack((AC, constraintFmin, constraintFsmoo.T)) #~ print lbdm0, lbdsm #~ R = nnls(ACcons.T,ObservedDispcons) #~ M = R[0] #~ fit = np.dot(AC.T,M) #~ misfit = 100.*np.sum(np.abs(fit-ObservedDisp))\ #~ /np.sum(np.abs(ObservedDisp)) #~ MISFIT = np.append(MISFIT,misfit) #~ MA = M[:nsf] #~ MB = M[nsf:] #~ M = np.sqrt(MA**2+MB**2) #~ mom0.append(np.sum(M)) ############################################## # Rotation to the rake's conventional angle: #MB, MA = Rot2D(MB,MA,-rakeB) print np.shape(M), np.shape(A.T) R = nnls(A.T,ObservedDisp) M = R[0] #~ M = np.zeros(nsf) #~ M[::2] = 1 fit = np.dot(A.T,M) MA = M MB = M np.save("RealSol", M) nm0 = np.size(Lbdm0min) nsmth = np.size(Lbdsmooth) #~ plt.figure() #~ plt.pcolor(1./Lbdsmooth, 1./Lbdm0min,MISFIT.reshape(nm0,nsmth)) #~ plt.xlabel(r'$1/ \lambda_{2}$', fontsize = 24) #~ plt.ylabel(r'$1/ \lambda_{1}$',fontsize = 24 ) #~ plt.ylim((1./Lbdm0min).min(),(1./Lbdm0min).max() ) #~ plt.ylim((1./Lbdsmooth).min(),(1./Lbdsmooth).max() ) #~ cbar = plt.colorbar() #~ cbar.set_label("Misfit %") #~ print np.shape(Lbdm0min), np.shape(mom0) #~ plt.figure() #~ CS = plt.contour(1./Lbdsmooth, 1./Lbdm0min,MISFIT.reshape(nm0,nsmth) ) #~ plt.xlabel(r'$1/ \lambda_{2}$', fontsize = 24) #~ plt.ylabel(r'$1/ \lambda_{1}$',fontsize = 24 ) #~ plt.clabel(CS, inline=1, fontsize=10) #~ plt.title('Misfit') #~ plt.figure() #~ plt.plot(1./Lbdm0min,MISFIT) #~ plt.xlabel(r'$1/ \lambda_{2}$', fontsize = 24) #~ plt.ylabel("Misfit %") #~ plt.figure() #~ plt.plot(Lbdm0min,mom0) #~ plt.ylabel(r'$M_0\, [Nm]$', fontsize = 24) #~ plt.xlabel(r'$\lambda_{M0}$', fontsize = 24) misfit = 100.*np.sum(np.abs(fit-ObservedDisp))/np.sum(np.abs(ObservedDisp)) print "Residual: ", 1000.*R[1] print misfit #SLIP = M*Mp/mu/(1.e6*np.array(sbarea)) sbarea = sflen*sfwid SLIP = M/(mu*1.e6*sbarea) SLIP = SLIP.reshape(nsx,nsy).T[::-1] moment = M.reshape(nsx,nsy).T[::-1] plt.figure(figsize = (13,5)) plt.plot(fit,'b' ,label="Fit") plt.plot(ObservedDisp,'r',label="Observed") plt.xlabel("Time [s]") plt.ylabel("Displacement [m]") plt.legend() np.set_printoptions(linewidth=1000,precision=3) print "***********" print sbarea print SLIP print np.mean(SLIP) print "Moment:" print np.sum(M) ### SLIPS Distribution (as the synthetics) : SLIPS = M.reshape(nsx,nsy).T SLIPS /= mu*1.e6*sbarea #~ #########Ploting slip distribution: #~ #we are going to reflect the y axis later, so: hypsbloc = [hyp_subf / nsy , -(hyp_subf % nsy) - 2] #Creating the strike and dip axis: StrikeAx= np.linspace(0,flen,nsx+1) DipAx= np.linspace(0,fwid,nsy+1) DepthAx = DipAx*np.sin(np.pi/180.*dip) + Min_h print DepthAx hlstrike = StrikeAx[hypsbloc[0]] + sflen*0.5 #we are going to reflect the axis later, so: hldip = DipAx[hypsbloc[1]] + sfwid*0.5 hldepth = DepthAx[hypsbloc[1]] + sfwid*0.5*np.sin(np.pi/180.*dip) StrikeAx = StrikeAx - hlstrike DipAx = DipAx - hldip XX, YY = np.meshgrid(StrikeAx, DepthAx) XX, ZZ = np.meshgrid(StrikeAx, DipAx ) ######Plot: (Old colormap: "gist_rainbow_r") plt.figure(figsize = (13,6)) ax = host_subplot(111) im = ax.pcolor(XX, YY, SLIPS, cmap="jet") ax.set_ylabel('Depth [km]') ax.set_ylim(DepthAx[-1],DepthAx[0]) # Creating a twin plot ax2 = ax.twinx() im2 = ax2.pcolor(XX, ZZ, SLIPS[::-1,:], cmap="jet") ax2.set_ylabel('Distance along the dip [km]') ax2.set_xlabel('Distance along the strike [km]') ax2.set_ylim(DipAx[0],DipAx[-1]) ax2.set_xlim(StrikeAx[0],StrikeAx[-1]) ax.axis["bottom"].major_ticklabels.set_visible(False) ax2.axis["bottom"].major_ticklabels.set_visible(False) ax2.axis["top"].set_visible(True) ax2.axis["top"].label.set_visible(True) divider = make_axes_locatable(ax) cax = divider.append_axes("bottom", size="5%", pad=0.1) cb = plt.colorbar(im, cax=cax, orientation="horizontal") cb.set_label("Slip [m]") ax2.plot([0], [0], '*', ms=225./(nsy+4)) ax2.set_xticks(ax2.get_xticks()[1:-1]) #~ ### Rake plot: plt.figure(figsize = (13,6)) fig = host_subplot(111) XXq, ZZq = np.meshgrid(StrikeAx[:-1]+sflen, DipAx[:-1]+sfwid ) Q = plt.quiver(XXq,ZZq, MB.reshape(nsx,nsy).T[::-1,:]/(mu*1.e6*sbarea), MA.reshape(nsx,nsy).T[::-1,:]/(mu*1.e6*sbarea), SLIPS[::-1,:], units='xy',scale = 0.5 , linewidths=(2,), edgecolors=('k'), headaxislength=5 ) fig.set_ylim([ZZq.min()-80,ZZq.max()+80]) fig.set_xlim([XXq.min()-20, XXq.max()+20 ]) fig.set_ylabel('Distance along dip [km]') fig.set_xlabel('Distance along the strike [km]') fig2 = fig.twinx() fig2.set_xlabel('Distance along the strike [km]') fig.axis["bottom"].major_ticklabels.set_visible(False) fig.axis["bottom"].label.set_visible(False) fig2.axis["top"].set_visible(True) fig2.axis["top"].label.set_visible(True) fig2.axis["right"].major_ticklabels.set_visible(False) divider = make_axes_locatable(fig) cax = divider.append_axes("bottom", size="5%", pad=0.1) cb = plt.colorbar(im, cax=cax, orientation="horizontal") cb.set_label("Slip [m]") plt.show() ############# #~ print np.shape(MISFIT), np.shape(RUPVEL) #~ plt.figure() #~ plt.plot(RUPVEL,MISFIT) #~ plt.xlabel("Rupture Velocity [km/s]") #~ plt.ylabel("Misfit %") #~ plt.show() print np.shape(MB.reshape(nsx,nsy).T) print np.shape(ZZ)
def get_ns_power(df, n=3): if 'Watts' not in df.columns: print('No "Watts" column in DataFrame') return np.zeros(df.index.values.shape) return convolve(df['Watts'], boxcar(n), 'same') / n
def digit_baseband(): Ts = 1 N_sample = 8 # 每个码元的抽样点数 dt = Ts / N_sample # 抽样时间间隔 N = 1000 # 码元数 T = 1 t = np.arange(0, N * N_sample * dt, dt) gt1 = np.ones((1, N_sample)) # NRZ非归零波形 gt2 = np.ones((1, N_sample // 2)) # RZ归零波形 gt2 = np.hstack((gt2, np.zeros((1, N_sample // 2)))) mt3 = sinc((t - 5) / Ts).reshape(1, -1) # sin(pi * t / Ts) / (pi * t / Ts) gt3 = mt3[0:10 * N_sample].reshape((1, -1)) d = (np.sign(np.random.randn(1, N)) + 1) / 2 data = sigexpand(d, N_sample) # 对序列间隔插入N_sample - 1个0 st1 = convolve(data, gt1) st2 = convolve(data, gt2) d = 2 * d - 1 #变成双极性序列 data = sigexpand(d, N_sample) st3 = convolve(data, gt3) f1, st1f = T2F(t, st1[:len(t)]) f2, st2f = T2F(t, st2[:len(t)]) f3, st3f = T2F(t, st3[:len(t)]) fig1 = plt.figure(1, figsize=(13, 8), dpi=98) fig1.add_subplot(321) plt.subplot(3, 2, 1, ylabel='单极性NRZ波形') plt.xlim(0, 20) # axis([0 20 - 1.5 1.5]); plt.ylim(-2, 2) # axis([0 20 - 1.5 1.5]); plt.grid("-.") plt.plot(t, st1[0][:len(t)]) fig1.add_subplot(322) plt.grid("-.") plt.xlim(-5, 5) # axis([0 20 - 1.5 1.5]); plt.ylim(-40, 10) plt.plot(f1, 10 * np.log10(abs(st1f)**2 / T)) fig1.add_subplot(323, ylabel='单极性RZ波形') plt.grid("-.") plt.xlim(0, 20) plt.ylim(-1.5, 1.5) plt.plot(t, st2[0][:len(t)]) fig1.add_subplot(324, ylabel='单极性RZ功率谱密度(dB/Hz)') plt.grid("-.") plt.xlim(-5, 5) plt.ylim(-40, 10) plt.plot(f2, 10 * np.log10(abs(st2f)**2 / T)) fig1.add_subplot(325, ylabel='双极性sinc波形', xlabel='t/Ts') plt.plot(t - 5, st3[0][:len(t)]) plt.grid("-.") plt.xlim(0, 20) plt.ylim(-2, 2) fig1.add_subplot(326, ylabel='sinc波形功率谱密度(dB/Hz)', xlabel='f*Ts') plt.grid("-.") plt.xlim(-5, 5) plt.ylim(-40, 10) plt.plot(f3[:-1], 10 * np.log10(abs(st3f)**2 / T)) plt.show()