def test_centrfreq(): # db1 is Haar function, frequency=1 w = pywt.Wavelet('db1') expected = 1 result = pywt.central_frequency(w, precision=12) assert_almost_equal(result, expected, decimal=3) # db2, frequency=2/3 w = pywt.Wavelet('db2') expected = 2/3. result = pywt.central_frequency(w, precision=12) assert_almost_equal(result, expected)
def compute_CWT_feature_L(data,scale=32,wavelet = 'mexh'): """ Compute features based on continuous wavelet transform of EMG signal """ n,t,c = data.shape cwt = np.zeros((n,4*c)) #print(cwt.shape) fc = pywt.central_frequency(wavelet) cparam = 2 * fc * scale scales = cparam / np.arange(int(scale+1), 1, -1) #scales = np.arange(1,scale+1) for i in range(n): for j in range(c): cwtmatr,_ = pywt.cwt(data[i,:,j],scales,wavelet) mean_abs = np.mean(np.abs(cwtmatr),axis=1) mean_coe = np.mean(mean_abs) min_coe = np.min(mean_abs) mean_scale = mean_abs@scales/mean_abs.sum() total = (cumtrapz(mean_abs,scales,initial=0)) #print(i,j,total[-1]) w=np.where(total>=(total[-1]/2))[0][0] median_scale = scales[w] #print(i,j*4,(j+1)*4) cwt[i,j*4:(j+1)*4] = [mean_coe,min_coe,mean_scale,median_scale] return cwt
def signal2spectrum(data,stft_window_size,stft_stride,cwt_wavename,cwt_scale_num,n_downsample=1, log = True, log_alpha = 0.1, mod = 'stft'): # window : ('tukey',0.5) hann if n_downsample != 1: data = downsample(data,alpha=n_downsample) if mod == 'stft': zxx = scipy.signal.stft(data, window='hann', nperseg=stft_window_size,noverlap=stft_window_size-stft_stride)[2] spectrum = np.abs(zxx) if log: spectrum = np.log1p(spectrum) h = spectrum.shape[0] x = np.linspace(h*log_alpha, h-1,num=h+1,dtype=np.int64) index = (np.log1p(x)-np.log1p(h*log_alpha))/(np.log1p(h)-np.log1p(h*log_alpha))*h spectrum_new = np.zeros_like(spectrum) for i in range(h): spectrum_new[int(index[i]):int(index[i+1])] = spectrum[i] spectrum = spectrum_new if mod == 'cwt': fc = pywt.central_frequency(cwt_wavename) cparam = 2 * fc * cwt_scale_num scales = cparam / np.arange(cwt_scale_num, 1, -1) cwtmatr, frequencies = pywt.cwt(data, scales, cwt_wavename,method='fft') spectrum = np.abs(cwtmatr) spectrum = cv2.resize(spectrum,(cwt_scale_num-1,cwt_scale_num-1),interpolation=cv2.INTER_AREA) return spectrum
def plot_tf_cwt(self, TRAI, wavelet_name='morl', save_path=None): i = self.data_tra[int(TRAI - 1)] if self.device == 'vallen': sig = np.multiply(array.array('h', bytes(i[-2])), i[-3] * 1000) time = np.linspace(0, pow(i[-5], -1) * (i[-4] - 1) * pow(10, 6), i[-4]) elif self.device == 'stream': sig = np.multiply(array.array('h', bytes(i[-1])), i[-2]) time = np.linspace(0, pow(i[3], -1) * (i[4] - 1) * pow(10, 6), i[4]) scales = pywt.central_frequency(wavelet_name) * 1e3 / np.arange( 1, 1e3, 1e0) [cwtmatr_new, frequencies_new] = pywt.cwt(sig, scales, wavelet_name, 1.0 / i[3]) plt.figure(figsize=(5.12, 5.12)) plt.contourf(time, frequencies_new / 1000, abs(cwtmatr_new)) plt.ylim(20, 1000) plt.xlabel('Time (μs)') plt.ylabel('Frequency (kHz)') if save_path: plt.gca().xaxis.set_major_locator(plt.NullLocator()) plt.gca().yaxis.set_major_locator(plt.NullLocator()) plt.subplots_adjust(top=1, bottom=0, right=1, left=0, hspace=0, wspace=0) plt.margins(0, 0) plt.savefig(os.path.join(save_path, '%i.jpg' % TRAI), pad_inches=0)
def compute_CWT_feature(data,scale=32,wavelet = 'mexh'): """ Compute features based on continuous wavelet transform of EMG signal """ n,t,c = data.shape f=4 cwt = np.zeros((n,f*c)) #print(cwt.shape) fc = pywt.central_frequency(wavelet) cparam = 2 * fc * scale scales = cparam / np.arange(int(scale+1), 1, -1) #scales = np.arange(1,scale+1) batch = 5 N = np.ceil(n/batch).astype(np.int32) for i in range(N): cwtmatr,_ = pywt.cwt(data[i*batch:(i+1)*batch,:,:],scales,wavelet,axis=1) cwtmatr = cwtmatr.transpose(1,0,2,3) mean_abs = np.mean(np.abs(cwtmatr),axis=2) mean_coe = np.mean(mean_abs,axis=1) min_coe = np.min(mean_abs,axis=1) mean_scale = scales@mean_abs/mean_abs.sum(axis=1) total = (cumtrapz(mean_abs,scales,axis=1,initial=0)) w=np.greater_equal(total,total[:,-1:,:]/2) median_scale = np.zeros((cwtmatr.shape[0],c)) for j in range(cwtmatr.shape[0]): for k in range(c): median_scale[j,k] = scales[w[j,:,k]][0] cwt[i*batch:(i+1)*batch,::f] = mean_coe cwt[i*batch:(i+1)*batch,1::f] = min_coe cwt[i*batch:(i+1)*batch,2::f] = mean_scale cwt[i*batch:(i+1)*batch,3::f] = median_scale return cwt
def get_cwt_scales(wavelet, lower_freq, upper_freq, dt, num): """ Get expected range of frequencies for cwt. """ central_freq = pywt.central_frequency(wavelet, precision=15) scales = np.geomspace(central_freq / (upper_freq * dt), central_freq / (lower_freq * dt), num=num, endpoint=True) return scales
def ft(t, data, sampling_rate): wavename = 'cgau8' totalscal = 512 fc = pywt.central_frequency(wavename) cparam = 2 * fc * totalscal scales = cparam / np.arange(totalscal, 10, -10) [cwtmatr, frequencies] = pywt.cwt(data, scales, wavename, 1.0 / sampling_rate) plt.contourf(t, frequencies, abs(cwtmatr)) plt.ylabel(u"frequency(Hz)") plt.xlabel(u"time(s)") plt.subplots_adjust(hspace=0.4)
def main(): sampling_rate = 360 wavelet = "mexh" # mexh, morl, gaus8, gaus4 scales = pywt.central_frequency(wavelet) * sampling_rate / np.arange( 1, 101, 1) (x1_train, x2_train, y_train, groups_train), (x1_test, x2_test, y_test, groups_test) = load_data(wavelet=wavelet, scales=scales, sampling_rate=sampling_rate) print("Data loaded successfully!") log_dir = "./logs/{}".format(wavelet) shutil.rmtree(log_dir, ignore_errors=True) callbacks = [ Initializer("[conv|fc]*.weight", fn=torch.nn.init.kaiming_normal_), Initializer("[conv|fc]*.bias", fn=partial(torch.nn.init.constant_, val=0.0)), LRScheduler(policy=StepLR, step_size=5, gamma=0.1), EpochScoring(scoring=make_scorer(f1_score, average="macro"), lower_is_better=False, name="valid_f1"), TensorBoard(SummaryWriter(log_dir)) ] net = NeuralNetClassifier( # skorch is extensive package of pytorch for compatible with scikit-learn MyModule, criterion=torch.nn.CrossEntropyLoss, optimizer=torch.optim.Adam, lr=0.001, max_epochs=30, batch_size=1024, train_split=predefined_split( Dataset({ "x1": x1_test, "x2": x2_test }, y_test)), verbose=1, device="cuda", callbacks=callbacks, iterator_train__shuffle=True, optimizer__weight_decay=0, ) net.fit({"x1": x1_train, "x2": x2_train}, y_train) y_true, y_pred = y_test, net.predict({"x1": x1_test, "x2": x2_test}) print(confusion_matrix(y_true, y_pred)) print(classification_report(y_true, y_pred, digits=4)) net.save_params(f_params="./models/model_{}.pkl".format(wavelet))
def get_dataset(data_length=1000, sample_rate=2e-6): # Load CSV Files # TODO: Use numpy instead of pandas I_sin_5k = pd.read_csv('data/raw/I(sin_5k_hiB).csv', header=None).iloc[:, 1:data_length + 1] V_sin_5k = pd.read_csv('data/raw/V(sin_5k_hiB).csv', header=None).iloc[:, 1:data_length + 1] I_tri_5k = pd.read_csv('data/raw/I(tri_5k_hiB).csv', header=None).iloc[:, 1:data_length + 1] V_tri_5k = pd.read_csv('data/raw/V(tri_5k_hiB).csv', header=None).iloc[:, 1:data_length + 1] I_trap_5k = pd.read_csv('data/raw/I(trap_5k_hiB).csv', header=None).iloc[:, 1:data_length + 1] V_trap_5k = pd.read_csv('data/raw/V(trap_5k_hiB).csv', header=None).iloc[:, 1:data_length + 1] I = pd.concat([I_sin_5k, I_tri_5k, I_trap_5k], ignore_index=True) V = pd.concat([V_sin_5k, V_tri_5k, V_trap_5k], ignore_index=True) # Compute scalograms wave_name = 'cgau8' total_scale = 30 fc = pywt.central_frequency(wave_name) fmax = 10e3 cparam = (1 / sample_rate) / fmax * fc * total_scale scales = cparam / np.arange(total_scale, 1, -1) data_size = I.shape[0] image_size = 24 scalogram = np.zeros([data_size, image_size, image_size]) for index, row in V.iterrows(): cwtmatr, _ = pywt.cwt(row, scales, wave_name, sample_rate) scalogram[index] = resize(abs(cwtmatr), (image_size, image_size)) if index % 100 == 0: print(f"Index {index} finished") # Compute labels P = V * I t = np.arange(0, (data_length - 0.5) * sample_rate, sample_rate) Loss_meas = np.trapz(P, t, axis=1) / (sample_rate * data_length) # Reshape data in_tensors = torch.from_numpy(scalogram).view(-1, 1, 24, 24) out_tensors = torch.from_numpy(Loss_meas).view(-1, 1) # Save data as CSV np.save("dataset.wavelet.in.npy", in_tensors.numpy()) np.save("dataset.wavelet.out.npy", out_tensors.numpy()) return torch.utils.data.TensorDataset(in_tensors, out_tensors)
def cwt4series(data, wavename='cmor3-3', totalscal=46, sampling_rate=100): # data为一维时序数据 # 需要确保data为(len,)格式 data = data.reshape((-1, )) fc = pywt.central_frequency(wavename) cparam = 2 * fc * totalscal scales = cparam / np.arange(totalscal, 1, -1) [cwtmatr, frequencies] = pywt.cwt(data, scales, wavename, 1.0 / sampling_rate) return [cwtmatr, frequencies]
def generate_CWT_feature(data,scale=32,wavelet = 'mexh'): """ Compute continuous wavelet transform of EMG signal """ n,t,c = data.shape fc = pywt.central_frequency(wavelet) cparam = 2 * fc * scale scales = cparam / np.arange(int(scale+1), 1, -1) cwtmatr = np.zeros((n,scale,t,c)) for i in range(n): for j in range(c): temp,_ = pywt.cwt(data[i,:,j],scales,wavelet) cwtmatr[i,:,:,j] = abs(temp) return cwtmatr
def wavelet(self, show_results=False, save=False, w='cgau8', sampling_rate=24e3, figsize=(36, 25), points=None): """ :param figsize: :param sampling_rate: 采样频率 :param show_results: :param save: :param w: 小波函数种类 :return: """ wavelet_results = [] totalscal = len(self.signals[0][0]) points = points or totalscal t = np.arange(0, points) * 24000 / points fc = pywt.central_frequency(w) # 中心频率 cparam = 2 * fc * totalscal scales = cparam / np.arange(totalscal, 1, -1) i = 0 for temp in self.signals: shape = (3, len(temp) // 3) # fig, axs = plt.subplots(shape[0], shape[1], figsize=figsize) wavelet_temp = [] for j in range(len(temp)): [cwtmatr, frequencies] = pywt.cwt(temp[j], scales, w, 1.0 / sampling_rate) # 连续小波变换 plt.subplot(shape[0], shape[1], j + 1) plt.contourf(t, frequencies, abs(cwtmatr)) plt.ylabel(u"freq(Hz)") plt.xlabel(u"time(s)") plt.title('S{} Wavelet Magnitude'.format(j)) wavelet_temp.append([cwtmatr, frequencies]) wavelet_results.append(wavelet_temp) if save: plt.savefig(os.path.join( RESULT_ROOT, str(i) + "_class_wavelet_spectrum.png"), dpi=600, bbox_inches='tight') i += 1 if show_results: plt.show() return wavelet_results
def Continuous_Wavelet_Transform(X, scales, sample_rate=500, wavelet=None, use_scipy_signal=True, *a, **k): ''' Unforturnately it's a very misleading terminology here to name it by Continuous Wavelet Transform. Actually, in engineering, both cwt and dwt are digital, point-by-point transform algorithums that can easily implemented on a computer. If two mathematicians talk about CWT, it really mean Continuous-WT. But here, CWT just misleading people. A cwt is a discret operation as well as dwt. The difference is how they convolve signal with wavelet. CWT will convolve signal with wavelet moveing foreward point-by-point while DWT moves window-by-window. When decomposition level grows, wavelet need to be expanded in length. CWT wavelet length will be 2, 3, 4, 5, ... and DWT will be 2, 4, 8, ... ''' # check params if np.isscalar(scales): scales = np.arange(1, scales + 1) scales = np.array(scales) assert 0 not in scales if not use_scipy_signal and wavelet not in pywt.wavelist(): wavelet = 'morl' # prepare wavelets if use_scipy_signal: wavelets = [ wavelet(min(10 * scale, X.shape[1]), scale) for scale in scales ] else: int_psi, x = pywt.integrate_wavelet(wavelet, precision=10) wavelets = [] for scale in scales: j = np.arange(scale * (x[-1] - x[0]) + 1) j = np.floor(j / scale / (x[1] - x[0])) wavelets.append(int_psi[np.int32(j[j < len(int_psi)])][::-1]) # convolve coef = np.array([[np.convolve(ch, w, mode='same') for w in wavelets] for ch in X]) if use_scipy_signal: freq = None else: coef = -np.sqrt(scales).reshape(len(scales), 1) * np.diff(coef) freq = (pywt.central_frequency(wavelet, 10) / scales * sample_rate) return coef, freq
def calculatecorr(self, filepath): interval = 5 dt = 0.0000001 * interval fs = 10000000 / interval start = 250000 end = 350000 with open(filepath, "rb") as fb: data = fb.read() ch1ch2 = struct.unpack("<" + str(int(len(data) / 2)) + "H", data) ch1ch2 = np.array(ch1ch2) ch1ch2 = (ch1ch2 - 8192) * 2.5 / 8192 datay1 = ch1ch2[::2] datay2 = ch1ch2[1::2] data1 = datay1[start:end:interval] data2 = datay2[start:end:interval] wavelet = 'morl' c = pywt.central_frequency(wavelet) fa = np.arange(20000, 400000 + 1, 10000) scales = np.array(float(c)) * fs / np.array(fa) [cfs1, frequencies1] = pywt.cwt(data1, scales, wavelet, dt) [cfs2, frequencies2] = pywt.cwt(data2, scales, wavelet, dt) power1 = (abs(cfs1))**2 power2 = (abs(cfs2))**2 for i, f in enumerate(fa): mean1 = power1[i].mean() power1[i] = power1[i] / mean1 mean2 = power2[i].mean() power2[i] = power2[i] / mean2 temp = signal.correlate(power1[i], power2[i], mode='same', method='fft') corr = (np.where(temp == max(temp))[0][0] - len(temp) / 2) * dt * 1000 self.dict_fitting[self.source_loc].append([f, corr]) showdict = "" for item in sorted(self.dict_fitting[self.source_loc]): showdict += "freq:%dHz corr:%.4fms\r\n" % (item[0], item[1]) self.textEdit_time_difference.setText(showdict)
def plot_wav_freq(wav=None, figsize=None, ax=None, yscale='linear', annotate=True, clearx=False): """Plot wavelet representation in **frequency domain** see ``plot_wav()`` for parameters. """ if wav is None: wav = get_default_wavelet() wav = _wavelet_instance(wav) fun_wav, time = wav.wavefun() if ax is None: fig, ax = plt.subplots(1, 1, figsize=figsize) # frequency domain plot df = 1 / (time[-1] - time[0]) freq = np.arange(len(time)) * df fft = np.abs(np.fft.fft(fun_wav) / np.sqrt(len(fun_wav))) ax.plot(freq, fft) #ax2.set_yscale('log') ax.set_xlim(0, df * len(freq) / 2) ax.set_title("Frequency support") if clearx: ax.set_xticks([]) else: ax.set_xlabel("Frequency [Hz]") ax.set_yscale(yscale) ax.set_ylim(-0.1, 1.1) central_frequency = wav.center_frequency if not central_frequency: central_frequency = pywt.central_frequency(wav) bandwidth_frequency = wav.bandwidth_frequency if wav.bandwidth_frequency else 0 ax.plot(central_frequency * np.ones(2), ax.get_ylim()) if annotate: ax.annotate("central_freq=%0.1fHz\nbandwidth_param=%0.1f" % (central_frequency, bandwidth_frequency), xy=(central_frequency, 0.5), xytext=(central_frequency + 2, 0.6), arrowprops=dict(facecolor='black', shrink=0.01)) return ax
def ft_diff(t, data_real, data_pre, sampling_rate): wavename = 'cgau8' totalscal = 512 fc = pywt.central_frequency(wavename) cparam = 2 * fc * totalscal scales = cparam / np.arange(totalscal, 10, -10) [cwtmatr_real, frequencies] = pywt.cwt(data_real, scales, wavename, 1.0 / sampling_rate) [cwtmatr_pre, frequencies] = pywt.cwt(data_pre, scales, wavename, 1.0 / sampling_rate) cwtmatr_plot = (np.exp(abs(cwtmatr_real)) - np.exp(abs(cwtmatr_pre))) / (np.exp(abs(cwtmatr_pre))) plt.contourf(t, frequencies, abs(cwtmatr_plot)) plt.ylabel(u"frequency(Hz)") plt.xlabel(u"time(s)") plt.subplots_adjust(hspace=0.4) plt.colorbar()
def periods2scales(periods, wavelet=None, dt=1.0): """Helper function to convert periods values (in the pseudo period wavelet sense) to scales values Arguments --------- - periods : np.ndarray() of positive strictly increasing values The ``periods`` array should be consistent with the ``time`` array passed to ``cws()``. If no ``time`` values are provided the period on the scaleogram will be in sample units. Note: you should check that periods minimum value is larger than the duration of two data sample because the sectrum has no physical meaning bellow these values. - wavelet : pywt.ContinuousWavelet instance or string name dt=[1.0] : specify the time interval between two samples of data When no ``time`` array is passed to ``cws()``, there is no need to set this parameter and the default value of 1 is used. Note: for a scale value of ``s`` and a wavelet Central frequency ``C``, the period ``p`` is:: p = s / C Example : Build a spectrum with constant period bins in log space ------- import numpy as np import scaleogram as scg periods = np.logspace(np.log10(2), np.log10(100), 100) wavelet = 'cgau5' scales = periods2scales(periods, wavelet) data = np.random.randn(512) # gaussian noise scg.cws( data, scales=scales, wavelet=wavelet, yscale='log', title="CWT of gaussian noise with constant binning in Y logscale") """ if wavelet is None: wavelet = get_default_wavelet() if isinstance(wavelet, six.string_types): wavelet = pywt.ContinuousWavelet(wavelet) else: assert (isinstance(wavelet, pywt.ContinuousWavelet)) return (periods / dt) * pywt.central_frequency(wavelet)
def calc_k0(self): fig_size = 20 interval = 5 dt = 0.0000001 * interval fs = 10000000 / interval start = 250000 end = 350000 path = "samples" filelisttemp = os.listdir(path) for filename in filelisttemp: filepath = path + "/" + filename with open(filepath, "rb") as fb: data = fb.read() ch1ch2 = struct.unpack("<"+str(int(len(data)/2))+"H", data) ch1ch2 = np.array(ch1ch2) ch1ch2 = (ch1ch2-8192)*2.5/8192 datay1 = ch1ch2[::2] datay2 = ch1ch2[1::2] data1 = datay1[start:end:interval] data2 = datay2[start:end:interval] wavelet = 'morl' c = pywt.central_frequency(wavelet) fa = np.arange(400000, 20000 - 1, -20000) scales = np.array(float(c)) * fs / np.array(fa) [cfs1,frequencies1] = pywt.cwt(data1,scales,wavelet,dt) [cfs2,frequencies2] = pywt.cwt(data2,scales,wavelet,dt) power1 = (abs(cfs1)) ** 2 power2 = (abs(cfs2)) ** 2 length_now = len(power1[0]) power1 = np.reshape(power1,(len(power1),fig_size,int(length_now/fig_size))) power2 = np.reshape(power2,(len(power2),fig_size,int(length_now/fig_size))) power1 = np.log10(np.mean(power1,axis=2)) power2 = np.log10(np.mean(power2,axis=2)) mx = power1.max() mn = power1.min() power1 = (power1-mn) / (mx-mn) * 255.0 power1 = np.floor(power1) mx = power2.max() mn = power2.min() power2 = (power2-mn) / (mx-mn) * 255.0 power2 = np.floor(power2) self.k0.append(power1) self.k0_norm.append(sqrt((power1 ** 2).sum())) self.k0.append(power2) self.k0_norm.append(sqrt((power2 ** 2).sum()))
def signal_pywt(signals): #幅值数据 data_amp = signals #小波名称 wavename = 'cgau8' #采样频率 sampling_rate = 100 # 小波计算scale,决定变换后频率下限 totalscal = 128 fc = pywt.central_frequency(wavename) cparam = 2 * fc * totalscal scales = cparam / np.arange(totalscal, 1, -1) # 小波变换,得到小波系数与频率 [cwtmatr, frequencies] = pywt.cwt(data_amp, scales, wavename, 1.0 / sampling_rate) Abs_cwtmatr = abs(cwtmatr) return frequencies, Abs_cwtmatr
def wvread_video(file_path): audio = AudioSegment.from_file(file_path, 'mp4') waveData = np.fromstring( audio.raw_data, dtype=np.int16) # np.fromstring(strData, dtype=np.int16) # 将字符串转化为int nchannels = audio.channels framerate = audio.frame_rate nframes = waveData.shape[0] // nchannels pltframe = 2048 time = np.arange(0, pltframe) * (1.0 / framerate) waveData = waveData * 1.0 / (max(abs(waveData))) # wave幅值归一化 waveData = np.reshape(waveData, [nframes, nchannels]) np_audio = waveData[:, 0] # first channel np_audio = np_audio[88200:88200 + pltframe] # 傅里叶变换 # transformed = np.fft.fft(np_audio) # 傅里叶变换 # shifted = np.fft.fftshift(transformed) # 移频 # plt.figure() # plt.subplot(2,1,1) # plt.plot(time, np_audio) # plt.subplot(2,1,2) # plt.plot(transformed) # 绘制变换后的信号 # plt.show() # 每1ms有44.1frame 每960ms有42336frame wavename = 'cgau8' totalscal = 4096 fc = pywt.central_frequency(wavename) cparam = 2 * fc * totalscal scales = cparam / np.arange(totalscal, 1, -1) [cwtmatr, frequencies] = pywt.cwt(np_audio, scales, wavename, 1.0 / framerate) plt.figure(figsize=(8, 4)) plt.subplot(211) plt.plot(time, np_audio) plt.xlabel(u"time(s)") plt.title(u"300Hz 200Hz 100Hz Time spectrum") plt.subplot(212) plt.contourf(time, frequencies, abs(cwtmatr)) plt.ylabel(u"freq(Hz)") plt.xlabel(u"time(s)") plt.subplots_adjust(hspace=0.4) plt.show()
def cal_wave(data, sampling_rate, total_scale=32, wave_name='cgau8'): time = np.arange(0, len(data)) / sampling_rate fc = pywt.central_frequency(wave_name) c_param = 2 * fc * total_scale scales = c_param / np.arange(total_scale, 1, -1) [cwt_mat, frequencies] = pywt.cwt(data, scales, wave_name, 1.0 / sampling_rate) # plt.figure(figsize=(8, 4)) # plt.subplot(211) # plt.plot(time, data) # plt.xlabel(u"Time(s)") # plt.title(u"300HzAnd200HzAnd100Hz") # plt.subplot(212) # plt.contourf(time, frequencies, abs(cwt_mat)) # plt.ylabel(u"Frequency(Hz)") # plt.xlabel(u"Time(s)") # plt.subplots_adjust(hspace=0.4) # plt.show() return cwt_mat, frequencies
def spec_wavlet(t, x, nfft=1024, wavename='cgau8', vmax=0.1): dt = (t[22] - t[2]) / 20 ts = dt fs = 1 / ts fc = pywt.central_frequency(wavename) cparam = 2 * fc * nfft scales = cparam / np.arange(nfft, 1, -1) [cwtmatr, f] = pywt.cwt(x, scales, wavename, 1 / fs) Zxx = np.abs(cwtmatr) tf = t f = f / 1000. vmin = 0 if vmax == -1: Zxx = np.log10(Zxx) - np.log10(np.max(Zxx)) vmax = np.max(Zxx) vmin = np.min(Zxx) return tf, f, Zxx, vmin, vmax
def wavelet2image(signal, sampling_rate, freq_dim_scale=256, wavelet_name='morl'): """ :param signal: 1D temporal sequence :param sampling_rate: sampling rate for the sequence :param freq_dim_scale: frequency resolution :param wavelet_name: wavelet name for CWT, here we have 'morl', 'gaus', 'cmor',... :return: time-freq image and its reciprocal frequencies """ freq_centre = pywt.central_frequency(wavelet_name) # 所选小波的中心频率 cparam = 2 * freq_centre * freq_dim_scale scales = cparam / np.arange(1, freq_dim_scale + 1, 1) # 获取小波基函数的尺度参数 a 的倒数 [cwt_matrix, frequencies] = pywt.cwt(signal, scales, wavelet_name, 1.0 / sampling_rate) return abs(cwt_matrix), frequencies
def MyPywtCWT(data): pass ''' --原始数据信息初始化--''' # Fs = 500000 #采样频率:500 000 Hz ; 采样周期:2 us ''' --尺度计算-- ''' wavename = 'gaus1' totalscal = 256 #尺度序列的长度 #Fc = 2000; #小波中心频率(Hz)(“主波峰之间的差值”=2000Hz) #Fc = pywt.central_frequency(wavename, precision=8) Fc = pywt.central_frequency(wavename) C = 2 * Fc * totalscal # C为常数,用于计算尺度序列. C = 2*Fc/totalscal scal = C / np.arange(1, totalscal + 1) #尺度序列,范围(2*Fc,inf) #--连续小波变换-- coef, freqs = pywt.cwt(data, scal, wavename) coef = np.abs(coef) return coef, freqs
def MyCWT(data): pass #--原始数据初始化-- #x = np.arange(len(data)) y = data # Fs = 500000 #采样频率:500 000 Hz # #采样周期:2 us #--尺度计算-- wavename = 'gaus1' totalscal = 64 #尺度序列的长度 #Fc = 2000; #小波中心频率(Hz)(“主波峰之间的差值”=2000Hz) #Fc = pywt.central_frequency(wavename, precision=8) Fc = pywt.central_frequency(wavename) C = 2 * Fc * totalscal # C 为常数,C = 2*Fc/totalscal scal = C / np.arange(1, totalscal + 1) #尺度序列,范围(2*Fc,inf) #--连续小波变换-- coef, freqs = pywt.cwt(y, scal, wavename) return coef, freqs
def frequency2scale(frequency, wavelet, sr): """determine appropriate wavelet scale for desired center frequency Args: frequency: desired center frequency of wavelet in Hz (1/seconds) wavelet: (str) name of pywt wavelet, eg 'morl' for Morlet sr: sample rate in Hz (1/seconds) Returns: scale: (float) scale parameter for pywt.ctw() to extract desired frequency Note: this function is not exactly an inverse of pywt.scale2frequency(), because that function returns frequency in sample-units (cycles/sample) rather than frequency in Hz (cycles/second). In other words, freuquency_hz = pywt.scale2frequency(w,scale)*sr. """ from pywt import central_frequency # get center frequency of this wavelet cf = central_frequency(wavelet) # calculate scale return cf * sr / frequency
import matplotlib.pyplot as plt import pywt import os import numpy as np import scipy.io as scio from TheRealEDA import FrequencyAnalysis, get_damage """ 小波变换样例!后续就用这个 """ sampling_rate = 24e3 # 采样频率 t = np.arange(0, 1e4/sampling_rate, 1.0/sampling_rate) w = "cgau8" totalscal = 3500 - 700 fc = pywt.central_frequency(w) # 中心频率 cparam = 2 * fc * totalscal scales = cparam/np.arange(totalscal, 1, -1) damage = get_damage() fa = FrequencyAnalysis(damage) signals = fa.signals figsize = (11, 8) shape = (3, 2) s17 = signals[17] s25 = signals[25] s17_temp = []
def Continuous_Wavelt_Transform(data, wavename, totalscal, sampling_rate): fc = pywt.central_frequency(wavename) # central frequency cparam = 2 * fc * totalscal scales = cparam / np.arange(1, totalscal + 1) [coef, freqs] = pywt.cwt(data, scales, wavename, 1.0 / sampling_rate) return coef, freqs
ch2 = (float(ch2) - 8192) / 8192 * 2.5 ch1 = float(ch1) ch2 = float(ch2) data1.append(ch1) data2.append(ch2) t.append(x * 0.0000001) x = x + 1 fb.close() data1 = data1[int(start / interval):int(end / interval)] data2 = data2[int(start / interval):int(end / interval)] t = t[int(start / interval):int(end / interval)] wavelet = 'morl' c = pywt.central_frequency(wavelet) fa = np.arange(400000, 20000 - 1, -100) scales = np.array(float(c)) * fs / np.array(fa) [cfs1, frequencies1] = pywt.cwt(data1, scales, wavelet, dt) [cfs2, frequencies2] = pywt.cwt(data2, scales, wavelet, dt) power1 = (abs(cfs1)) power2 = (abs(cfs2)) plt.subplot(2, 1, 1) plt.imshow(power1, cmap=cmap) plt.axis('off') plt.subplot(2, 1, 2) plt.imshow(power2, cmap=cmap) plt.axis('off')
import matplotlib.pyplot as plt import numpy as np import pywt import librosa #filepath='output/07_05/generated_5.wav' filepath = 'C_major.wav' y, fs = librosa.load(filepath) t = np.arange(0, len(y) / float(fs), 1.0 / fs) wavename = 'cgau8' totalscal = 256 fc = pywt.central_frequency(wavename) cparam = 2 * fc * totalscal scales = cparam / np.arange(totalscal, 1, -1) [cwtmatr, frequencies] = pywt.cwt(y, scales, wavename, 1.0 / fs) plt.figure(figsize=(8, 4)) plt.subplot(211) plt.plot(t, y) plt.xlabel("time (sec)") plt.title("Spectrogram") plt.subplot(212) plt.contourf(t, frequencies, abs(cwtmatr)) plt.ylabel("frequency (Hz)") plt.ylim(0, 1000) plt.xlabel("time (sec)") plt.subplots_adjust(hspace=0.4) plt.show()