def test_ben():
LB = -5
UB = 5
N = 1000
Fc = 1.1
[psi, x] = ref_ben(LB, UB, N,Fc)
w = pywt.ContinuousWavelet("ben-{}".format(Fc))
assert_almost_equal(w.center_frequency, Fc)
w.upper_bound = UB
w.lower_bound = LB
PSI, X = w.wavefun(length=N)
assert_allclose(np.real(PSI), np.real(psi))
assert_allclose(np.imag(PSI), np.imag(psi))
assert_allclose(X, x)
LB = -5
UB = 5
N = 1001
[psi, x] = ref_ben(LB, UB, N,Fc)
w = pywt.ContinuousWavelet("ben-{}".format(Fc))
assert_almost_equal(w.center_frequency, Fc)
w.upper_bound = UB
w.lower_bound = LB
PSI, X = w.wavefun(length=N)
assert_allclose(np.real(PSI), np.real(psi))
assert_allclose(np.imag(PSI), np.imag(psi))
assert_allclose(X, x)
def test_mexh():
LB = -5
UB = 5
N = 1000
[psi, x] = ref_mexh(LB, UB, N)
w = pywt.ContinuousWavelet("mexh")
w.upper_bound = UB
w.lower_bound = LB
PSI, X = w.wavefun(length=N)
assert_allclose(np.real(PSI), np.real(psi))
assert_allclose(np.imag(PSI), np.imag(psi))
assert_allclose(X, x)
LB = -5
UB = 5
N = 1001
[psi, x] = ref_mexh(LB, UB, N)
w = pywt.ContinuousWavelet("mexh")
w.upper_bound = UB
w.lower_bound = LB
PSI, X = w.wavefun(length=N)
assert_allclose(np.real(PSI), np.real(psi))
assert_allclose(np.imag(PSI), np.imag(psi))
assert_allclose(X, x)
def perform_wavelet_analysis(time_series, central_freq, sampling_rate,
peak_tresh):
mean = sum(time_series) / len(time_series)
time_series = time_series - mean
ts = 1 / sampling_rate
central_scale = sampling_rate / central_freq
wav = pywt.ContinuousWavelet('cmor2-1.0')
f_bound_high = central_scale / 2
f_bound_low = central_scale / 2
bands = 64
widths = np.linspace(central_scale - f_bound_high,
central_scale + f_bound_low, bands)
# (IMPORTANTE) devo trovare la formula che lega direttamente la frequenza rilevata dalla fft coi parametri da settare per le wavelets
# in pratica ho capito che a bassissime frequenze non ho bisogno di un numero di bande superiore a 50
# oltretutto a basse frequenze l'analisi wavelet è molto più lenta
# un altro parametro molto importante è la larghezza della banda di analisi
# il limite inferiore (in frequenza) deve essere aumentato
# 6 Hz -> bands = 100, f_bound_high = central_scale / 20, f_bound_low = central_scale / 80
# 0.15 Hz -> bands = 20, f_bound_high = central_scale / 3, f_bound_low = central_scale / 1
cwtmatr, freqs = pywt.cwt(time_series, widths, wav, ts)
cwt_freq_peaks = []
times = 0
for time_stamp in cwtmatr.T: # [int(len(cwtmatr.T)/3):int(len(cwtmatr.T)*2/3)]:
abs_ts = abs(time_stamp)
max_value = max(abs_ts)
indexes = peakutils.indexes(abs_ts, thres=peak_tresh, min_dist=20)
for i in indexes:
cwt_freq_peaks.append(freqs[i])
times = times + 1
#print("Peaks: " + str(cwt_freq_peaks))
#print("Freqs: " + str(freqs))
freq_det_cwt = np.mean(cwt_freq_peaks)
return cwtmatr, freq_det_cwt
def IC_FC_detection(data, scale=10, thres=0.65):
"""
This function will do two continuous wavelet
tranformations and will detect IC and FC
respectively by the peak times detected.
* Data: is the data we want to do the CWT over
* Scale: is the scale that we want to use to
extract a specific frequency
* Thres: is the threshold used for detecting peaks
"""
wavelet = pywt.ContinuousWavelet("gaus2") # We use a Gaussian Wavelet
# IC
coefs, _ = pywt.cwt(data, scale, wavelet)
final = coefs[0]
IC = peakutils.indexes(
-final, thres, min_dist=25) # predefined interval from 0.25 to 2.25s
# FC
coefs_2, _ = pywt.cwt(final, scale, wavelet)
final_2 = coefs_2[0]
FC = peakutils.indexes(
final_2, thres, min_dist=25) # predefined interval from 0.25 to 2.25s
return final, final_2, IC, FC
def test_accuracy_pymatbridge_cwt():
rstate = np.random.RandomState(1234)
# max RMSE (was 1.0e-10, is reduced to 5.0e-5 due to different coefficents)
epsilon = 1e-15
epsilon_psi = 1e-15
mlab.start()
try:
for wavelet in wavelets:
with warnings.catch_warnings():
warnings.simplefilter('ignore', FutureWarning)
w = pywt.ContinuousWavelet(wavelet)
if np.any((wavelet == np.array(['shan', 'cmor'])), axis=0):
mlab.set_variable(
'wavelet', wavelet + str(w.bandwidth_frequency) + '-' +
str(w.center_frequency))
elif wavelet == 'fbsp':
mlab.set_variable(
'wavelet', wavelet + str(w.fbsp_order) + '-' +
str(w.bandwidth_frequency) + '-' + str(w.center_frequency))
else:
mlab.set_variable('wavelet', wavelet)
mlab_code = ("psi = wavefun(wavelet,10)")
res = mlab.run_code(mlab_code)
psi = np.asarray(mlab.get_variable('psi'))
yield _check_accuracy_psi, w, psi, wavelet, epsilon_psi
for N in _get_data_sizes(w):
data = rstate.randn(N)
mlab.set_variable('data', data)
for scales in _get_scales(w):
coefs = _compute_matlab_result(data, wavelet, scales)
yield _check_accuracy, data, w, scales, coefs, wavelet, epsilon
finally:
mlab.stop()
def describe(signal):
w = pywt.ContinuousWavelet('mexh')
signal_with_noise = signal + np.random.uniform(-0.5, 0.5, N)
amp, scales = pywt.cwt(signal_with_noise,
2**np.arange(7),
w,
sampling_period=0.25)
to_show = 5
def reconstruction_plot(yyy, color='r'):
"""Plot signal vector on x [0,1] independently of amount of values it contains."""
length = len(yyy)
mean = length // 2
delta = length // to_show // 2
plt.plot(
np.linspace(0, 1, length)[mean - delta:mean + delta + 1],
yyy[mean - delta:mean + delta + 1], color)
# plt.plot(np.linspace(0, 1, len(yyy)), yyy, color)
# plt.plot(np.linspace(0, 1, N)[:N//to_show + 1],
# signal_with_noise[:N//to_show + 1], 'b')
reconstruction_plot(signal_with_noise, 'orange')
reconstruction_plot(amp[0], 'r')
reconstruction_plot(amp[2], 'g')
plt.show()
def identify_scale(Vz, plot_this=False):
"""
This function will identify the main
wave scale that the data contains.
It is optimized to identify walking
bouts from accelerometer' measurements.
"""
scale = list(np.arange(1, 150, 1))
wavelet = pywt.ContinuousWavelet("gaus2")
coefs, _ = pywt.cwt(Vz, scale, wavelet)
averages = list()
for i in coefs:
averages.append(np.average(abs(i)))
if plot_this:
plt.plot(scale, averages)
plt.title("Scale Optimization")
plt.show()
# We want to get the first peak as it should
# symbolize the first main frequency.
peaks, _ = find_peaks(averages)
if len(peaks) == 0:
return max(averages)
else:
return peaks[0]
def _create_scaleogram(signal: np.ndarray,
graph_wavelet_signal: bool) -> np.ndarray:
"""Creates scaleogram for signal.
"""
# Length of the signal: 128
n = len(signal)
time_list = np.arange(n)
# Scale 1 corresponds to a wavelet of width 17 (lower_bound=-8, upper_bound=8).
# Scale n corresponds to a wavelet of width n*17.
scale_list = np.arange(0, n) / 8 + 1
wavelet = 'mexh'
scaleogram = pywt.cwt(signal, scale_list, wavelet)[0]
scaleogram = _normalize(scaleogram)
if graph_wavelet_signal:
signal = _normalize(signal)
x = np.append([time_list], [time_list], axis=0)
# Graph the narrowest wavelet together with the signal.
[wav_narrowest,
_] = pywt.ContinuousWavelet(wavelet).wavefun(length=n *
int(scale_list[0]))
y = np.append([wav_narrowest], [signal], axis=0)
utils_graph.graph_overlapping_lines(
x, y, ['Mexican hat wavelet', 'Signal'], 'Time', 'Scale',
'Example of a signal and narrowest wavelet', PLOTS_FOLDER,
'sample_narrowest_wavelet.html')
# Graph the widest wavelet together with the signal.
# wavefun gives us the original wavelet, with a width of 17 (scale=1).
# We want to stretch that signal by scale_list[n-1].
# So we oversample the wavelet computation and take the n points in
# the middle.
[wav_widest,
_] = pywt.ContinuousWavelet(wavelet).wavefun(length=n *
int(scale_list[n - 1]))
middle = len(wav_widest) // 2
lower_bound = middle - n // 2
upper_bound = lower_bound + n
wav_widest = wav_widest[lower_bound:upper_bound]
y = np.append([wav_widest], [signal], axis=0)
utils_graph.graph_overlapping_lines(
x, y, ['Mexican hat wavelet', 'Signal'], 'Time', 'Scale',
'Example of a signal and widest wavelet', PLOTS_FOLDER,
'sample_widest_wavelet.html')
return scaleogram
def dominant_wavenumber(field, grid, n_scales=120, smoothing=(21, 7)):
"""Dominant zonal wavenumber at every gridpoint of field.
Implements the procedure of Ghinassi et al. (2018) based on a wavelet
analysis of the input field.
- `n_scales` determines the number of scales used in the continuous wavelet
transform.
- `smoothing` determines the full width at half maximum of the Hann filter
in zonal and meridional direction in degrees longitude/latitude.
Returns the gridded dominant zonal wavenumber.
Requires `pywt` (version >= 1.1.0) and `scipy`.
"""
import pywt
from scipy import signal
# Truncate zonal fourier spectrum of meridional wind after wavenumber 20
x = _restrict_fourier_zonal(field, 0, 20)
# Triplicate field to avoid boundary issues (pywt.cwt does not support
# periodic mode as of version 1.1)
x = np.hstack([x, x, x])
# Use the complex Morlet wavelet
morlet = pywt.ContinuousWavelet("cmor1.0-1.0")
# ...
scales = 3 * 2**np.linspace(0, 6, n_scales)
# Apply the continuous wavelet transform
coef, freqs = pywt.cwt(x, scales=scales, wavelet=morlet, axis=_ZONAL)
# Extract the middle domain, throw away the periodic padding
ii = coef.shape[-1] // 3
coef = coef[:, :, ii:-ii]
# Obtain the power spectrum
power = np.abs(coef)**2
# Determine wavenumbers from scales
wavenum = pywt.scale2frequency(morlet, scales) * grid.shape[_ZONAL]
# Dominant wavenumber is that of maximum power in the spectrum
dom_wavenum = wavenum[np.argmax(power, axis=0)]
# Smooth dominant wavenumber with Hann windows. Window width is given as
# full width at half maximum, which is half of the full width. Choose the
# nearest odd number of gridpoints available to the desired value.
smooth_lon, smooth_lat = smoothing
hann_lon = signal.windows.hann(
int(smooth_lon / 360 * grid.shape[_ZONAL]) * 2 + 1)
hann_lon = hann_lon / np.sum(hann_lon)
hann_lat = signal.windows.hann(
int(smooth_lat / 180 * grid.shape[_MERIDIONAL]) * 2 + 1)
hann_lat = hann_lat / np.sum(hann_lat)
# Apply zonal filter first with periodic boundary
dom_wavenum = signal.convolve2d(dom_wavenum,
hann_lon[None, :],
mode="same",
boundary="wrap")
# Then apply meridional filter with symmetrical boundary
dom_wavenum = signal.convolve2d(dom_wavenum,
hann_lat[:, None],
mode="same",
boundary="symm")
return dom_wavenum
def scalo2sig(scalo, name, scales=np.arange(1, 128), wavelet='morl'):
mwf = pywt.ContinuousWavelet(wavelet).wavefun()
y_0 = mwf[0][np.argmin(np.abs(mwf[1]))]
r_sum = np.transpose(np.sum(np.transpose(scalo) / scales**0.5, axis=-1))
audio = r_sum * (1 / y_0)
newDir = './Audio_Results/audio_from_scalo'
if not os.path.exists(newDir):
os.makedirs(newDir)
sf.write(f"{newDir}/{name}.wav", audio, 22500)
def _wavelet_instance(wavelet):
"""Function responsible for returning the correct pywt.ContinuousWavelet
"""
if isinstance(wavelet, pywt.ContinuousWavelet):
return wavelet
if isinstance(wavelet, six.string_types):
return pywt.ContinuousWavelet(wavelet)
else:
raise ValueError("Expecting a string name for the wavelet," +
" or pywt.ContinuousWavelet. Got: " + str(wavelet))
def get_list_of_continuous_wavelets():
l = []
for name in pywt.wavelist(kind='continuous'):
# supress warnings when the wavelet name is missing parameters
completion = {
'cmor': 'cmor1.5-1.0',
'fbsp': 'fbsp1-1.5-1.0',
'shan': 'shan1.5-1.0' }
if name in completion:
name = completion[name]# supress warning
l.append( name+" :\t"+pywt.ContinuousWavelet(name).family_name )
return l
def test_cgau():
LB = -5
UB = 5
N = 1000
for num in np.arange(1, 9):
[psi, x] = ref_cgau(LB, UB, N, num)
w = pywt.ContinuousWavelet("cgau" + str(num))
PSI, X = w.wavefun(length=N)
assert_allclose(np.real(PSI), np.real(psi))
assert_allclose(np.imag(PSI), np.imag(psi))
assert_allclose(X, x)
def test_accuracy_precomputed_cwt():
# Keep this specific random seed to match the precomputed Matlab result.
rstate = np.random.RandomState(1234)
# has to be improved
epsilon = 1e-15
epsilon32 = 1e-5
epsilon_psi = 1e-15
for wavelet in wavelets:
w = pywt.ContinuousWavelet(wavelet)
w32 = pywt.ContinuousWavelet(wavelet, dtype=np.float32)
psi = _load_matlab_result_psi(wavelet)
yield _check_accuracy_psi, w, psi, wavelet, epsilon_psi
for N in _get_data_sizes(w):
data = rstate.randn(N)
data32 = data.astype(np.float32)
scales_count = 0
for scales in _get_scales(w):
scales_count += 1
coefs = _load_matlab_result(data, wavelet, scales_count)
yield _check_accuracy, data, w, scales, coefs, wavelet, epsilon
yield _check_accuracy, data32, w32, scales, coefs, wavelet, epsilon32
def __init__(self, id=0):
with open("config/wavelets/default_wavelet.json") as f:
data = json.load(f)
config = load_config(id, data)
self.B = float(config["wavelet"]["B"])
self.C = float(config["wavelet"]["C"])
self.name = config["wavelet"]["name"]
self.min_scales = int(config["wavelet"]["min_scales"])
self.max_scales = int(config["wavelet"]["max_scales"])
self.scales = np.arange(self.min_scales, self.max_scales)
self.wavelet = pywt.ContinuousWavelet('%s%s-%s' % (self.name, self.B, self.C))
def do_pywt_transform(data,
quality=44100,
scalogram_quality=2000,
base_freq=30000,
num_octaves=2,
voices_per_octave=50):
"""Actually perform the wavelet transform, using the PyWavelet module."""
CORRECTION_FACTOR = 10000
try:
import pywt
except ImportError:
print(
"Sorry, you need the PyWavelets (\"pywt\") module to create scalograms.",
file=sys.stderr)
sys.exit(1)
# workaround--the pywt has accuracy bugs when we get to high freqs, so slow everything down
base_freq /= CORRECTION_FACTOR
quality /= CORRECTION_FACTOR
scalogram_quality /= CORRECTION_FACTOR
# construct the wavelet we want
wavelet = pywt.ContinuousWavelet('cmor')
wavelet.bandwidth_frequency = Scalogram.BANDWIDTH_FREQ
wavelet.center_frequency = base_freq * 2 # put the center freq in the middle of the expected range
base_scale = quality * wavelet.center_frequency / base_freq
far_scale = base_scale / 2**num_octaves
scales = np.geomspace(base_scale,
far_scale,
num=num_octaves * voices_per_octave + 1,
endpoint=True)
#mags = np.empty((len(scales), int(len(data) * scalogram_quality / quality)))
mags = np.empty(
(int(len(data) * scalogram_quality / quality), len(scales)))
freqs = np.empty(len(scales))
# do actual calculation 1 scale at a time, resampling the magnitudes (saves memory)
factor = int(quality / scalogram_quality)
for f in range(len(scales)):
coeffs, freq = pywt.cwt(data, scales[f], wavelet, 1 / quality)
freqs[f] = freq[0] * CORRECTION_FACTOR
for t in range(len(mags)):
mags[t][f] = (abs(coeffs[0][t * factor:(t + 1) *
factor])).mean()
return (freqs, mags)
def test_cmor():
LB = -20
UB = 20
N = 1000
Fb = 1
Fc = 1.5
[psi, x] = ref_cmor(LB, UB, N, Fb, Fc)
w = pywt.ContinuousWavelet("cmor{}-{}".format(Fb, Fc))
assert_almost_equal(w.center_frequency, Fc)
assert_almost_equal(w.bandwidth_frequency, Fb)
w.upper_bound = UB
w.lower_bound = LB
PSI, X = w.wavefun(length=N)
assert_allclose(np.real(PSI), np.real(psi), atol=1e-15)
assert_allclose(np.imag(PSI), np.imag(psi), atol=1e-15)
assert_allclose(X, x, atol=1e-15)
LB = -20
UB = 20
N = 1000
Fb = 1.5
Fc = 1
[psi, x] = ref_cmor(LB, UB, N, Fb, Fc)
w = pywt.ContinuousWavelet("cmor{}-{}".format(Fb, Fc))
assert_almost_equal(w.center_frequency, Fc)
assert_almost_equal(w.bandwidth_frequency, Fb)
w.upper_bound = UB
w.lower_bound = LB
PSI, X = w.wavefun(length=N)
assert_allclose(np.real(PSI), np.real(psi), atol=1e-15)
assert_allclose(np.imag(PSI), np.imag(psi), atol=1e-15)
assert_allclose(X, x, atol=1e-15)
def plot_signal_decomp2(data,w,scale,title):
w = pywt.ContinuousWavelet(w)#选取小波函数
a = data
coefs=[]
freqs=[]
coefs, freqs=pywt.cwt(a,scale,w)
#X,Y=coefs.shape#增加等高线表示
im=plt.matshow(coefs,interpolation='nearest',cmap='jet')
plt.colorbar(im)
#plt.title('RH CWT')
plt.xlabel('time(day)')
plt.ylabel('scale')
plt.title(title,verticalalignment='bottom')
plt.show()
return coefs
def gen_spike_track(dat_3D, frames, fps=50):
# fps is the desired framerate of the output video
output = np.array([], dtype='float32')
w_length = 100
bitrate = 44100
length = 1. / fps # length of a frame in seconds
num_samps_per_frame = int(bitrate * length)
spikeshape = pywt.ContinuousWavelet('mexh').wavefun(length=w_length)[0]
for ii, frame in enumerate(frames):
frame_sound = np.zeros(num_samps_per_frame, dtype='float32')
num_spikes = spikes_in_frame(dat_3D, frame)
if num_spikes > 0:
frame_sound[:w_length * num_spikes] = np.tile(
spikeshape, num_spikes).ravel()
output = np.concatenate([output, frame_sound])
return output
def get_wavlist():
"""Returns the list of continuous wavelet functions available in the
PyWavelets library.
"""
l = []
for name in pywt.wavelist(kind='continuous'):
# supress warnings when the wavelet name is missing parameters
completion = {
'cmor': 'cmor1.5-1.0',
'fbsp': 'fbsp1-1.5-1.0',
'shan': 'shan1.5-1.0'
}
if name in completion:
name = completion[name] # supress warning
l.append(name + " :\t" + pywt.ContinuousWavelet(name).family_name)
return l
def _save_wavelets() -> None:
"""Saves three different kinds of mother wavelets to be used in the
theoretical part of the report.
"""
n = 100
wavelet_names = ['gaus1', 'mexh', 'morl']
titles = ['Gaussian wavelet', 'Mexican hat wavelet', 'Morlet wavelet']
file_names = ['gaussian.html', 'mexican_hat.html', 'morlet.html']
for i in range(len(wavelet_names)):
file_name = file_names[i]
path = Path(PLOTS_FOLDER, file_name)
if not path.exists():
wavelet_name = wavelet_names[i]
wavelet = pywt.ContinuousWavelet(wavelet_name)
[wavelet_fun, x] = wavelet.wavefun(length=n)
utils_graph.graph_2d_line(x, wavelet_fun, 'Time', 'Amplitude',
titles[i], PLOTS_FOLDER, file_name)
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 get_wavelet(latency, frequency, times, mwt="mexh"):
signal_frequency = 1 / (times[1] - times[0])
mother = pywt.ContinuousWavelet(mwt)
scale = signal_frequency / frequency
mex, _ = mother.wavefun(length=int(scale * 4))
center_index = int((latency - times[0]) * signal_frequency)
left_index = center_index - len(mex) // 2
res = np.zeros_like(times)
if left_index < 0:
mex = mex[-left_index:]
start = 0
else:
start = left_index
mex = mex[:len(res) - start]
res[start:start + len(mex)] = mex
return res
def drawWavalet(self, type):
font_title = {'family': 'SimHei', 'weight': 'bold', 'size': 14}
font = {'family': 'DejaVu Sans', 'weight': 'bold', 'size': 13}
if type == 'haar' or type == 'db8':
wavelet = pywt.Wavelet(type)
phi, psi, x = wavelet.wavefun(level=3)
plt.figure(figsize=(8, 7))
ax1 = plt.subplot(2, 1, 1)
ax1.plot(x, psi, color='black')
ax1.grid()
ax1.set_title(type + "母小波", font_title)
# ax1.set_ylabel('(a)')
ax2 = plt.subplot(2, 1, 2)
ax2.set_title(type + "父小波", font_title)
ax2.plot(x, phi, color='black')
ax2.grid()
# ax2.set_ylabel('(b)')
plt.savefig(self.path + type + '.png',
dpi=400,
bbox_inches='tight')
plt.show()
elif type == 'mexh' or type == 'gaus1':
wavelet = pywt.ContinuousWavelet(type)
psi, x = wavelet.wavefun(level=10)
plt.figure(figsize=(7, 4))
plt.plot(x, psi, color='black')
plt.grid()
#plt.title("Mexh 小波基函数", font_title)
plt.xlabel("X", font)
plt.ylabel("${ψ_{a,b}'(x)}$", font)
plt.savefig(self.path + type + '.png',
dpi=400,
bbox_inches='tight')
plt.show()
def test_fbsp():
LB = -20
UB = 20
N = 1000
M = 2
Fb = 1
Fc = 1.5
[psi, x] = ref_fbsp(LB, UB, N, M, Fb, Fc)
w = pywt.ContinuousWavelet("fbsp{}-{}-{}".format(M, Fb, Fc))
assert_almost_equal(w.center_frequency, Fc)
assert_almost_equal(w.bandwidth_frequency, Fb)
w.fbsp_order = M
w.upper_bound = UB
w.lower_bound = LB
PSI, X = w.wavefun(length=N)
assert_allclose(np.real(PSI), np.real(psi), atol=1e-15)
assert_allclose(np.imag(PSI), np.imag(psi), atol=1e-15)
assert_allclose(X, x, atol=1e-15)
LB = -20
UB = 20
N = 1000
M = 2
Fb = 1.5
Fc = 1
[psi, x] = ref_fbsp(LB, UB, N, M, Fb, Fc)
w = pywt.ContinuousWavelet("fbsp{}-{}-{}".format(M, Fb, Fc))
assert_almost_equal(w.center_frequency, Fc)
assert_almost_equal(w.bandwidth_frequency, Fb)
w.fbsp_order = M
w.upper_bound = UB
w.lower_bound = LB
PSI, X = w.wavefun(length=N)
assert_allclose(np.real(PSI), np.real(psi), atol=1e-15)
assert_allclose(np.imag(PSI), np.imag(psi), atol=1e-15)
assert_allclose(X, x, atol=1e-15)
LB = -20
UB = 20
N = 1000
M = 3
Fb = 1.5
Fc = 1.2
[psi, x] = ref_fbsp(LB, UB, N, M, Fb, Fc)
w = pywt.ContinuousWavelet("fbsp{}-{}-{}".format(M, Fb, Fc))
assert_almost_equal(w.center_frequency, Fc)
assert_almost_equal(w.bandwidth_frequency, Fb)
w.fbsp_order = M
w.upper_bound = UB
w.lower_bound = LB
PSI, X = w.wavefun(length=N)
# TODO: investigate why atol = 1e-5 is necessary
assert_allclose(np.real(PSI), np.real(psi), atol=1e-5)
assert_allclose(np.imag(PSI), np.imag(psi), atol=1e-5)
assert_allclose(X, x, atol=1e-15)
import numpy as np
import pywt
import matplotlib.pyplot as plt
wav = pywt.ContinuousWavelet('cmor1.5-1.0')
# print the range over which the wavelet will be evaluated
print("Continuous wavelet will be evaluated over the range [{}, {}]".format(
wav.lower_bound, wav.upper_bound))
width = wav.upper_bound - wav.lower_bound
scales = [1, 2, 3, 4, 10, 15]
max_len = int(np.max(scales) * width + 1)
t = np.arange(max_len)
fig, axes = plt.subplots(len(scales), 2, figsize=(12, 6))
for n, scale in enumerate(scales):
# The following code is adapted from the internals of cwt
int_psi, x = pywt.integrate_wavelet(wav, precision=10)
step = x[1] - x[0]
j = np.floor(np.arange(scale * width + 1) / (scale * step))
if np.max(j) >= np.size(int_psi):
j = np.delete(j, np.where((j >= np.size(int_psi)))[0])
j = j.astype(np.int_)
# normalize int_psi for easier plotting
int_psi /= np.abs(int_psi).max()
# discrete samples of the integrated wavelet
# JUST ME PLAYING AROUND
import pywt
import numpy as np
import matplotlib.pyplot as plt
import sys
TAU = 2 * np.pi
SAMPLING_RATE = 300 * 1000
SAMPLING_PERIOD = 1 / SAMPLING_RATE
SIGNAL_FREQ = 80 * 1000
AMPLITUDE = 1
VOICES_PER_OCTAVE = 64
BASE_SCALE = 133.125 # WHY?
wavelet = pywt.ContinuousWavelet('cmor5-60000')
# make data of a 2-kHz signal over 1 second, sampling rate of 100 kHz
np.set_printoptions(threshold=sys.maxsize)
# create 1 s of data at the given frequency sampling rate
x = np.arange(SAMPLING_RATE)
signal = AMPLITUDE * np.sin(TAU * x / (SAMPLING_RATE / SIGNAL_FREQ))
print(signal.shape)
print(signal[0:128])
# plot the signal
#fig,ax = plt.subplots(figsize=(50,10))
#ax.plot(x,signal)
scales = np.geomspace(BASE_SCALE * 2, BASE_SCALE / 2,
size_set = 'reduced'
# list of mode names in pywt and matlab
modes = [('zero', 'zpd'), ('constant', 'sp0'), ('symmetric', 'sym'),
('periodic', 'ppd'), ('smooth', 'sp1'), ('periodization', 'per')]
families = ('gaus', 'mexh', 'morl', 'cgau', 'shan', 'fbsp', 'cmor')
wavelets = sum([pywt.wavelist(name) for name in families], [])
rstate = np.random.RandomState(1234)
mlab.start()
try:
all_matlab_results = {}
for wavelet in wavelets:
w = pywt.ContinuousWavelet(wavelet)
if np.any((wavelet == np.array(['shan', 'cmor'])), axis=0):
mlab.set_variable(
'wavelet', wavelet + str(w.bandwidth_frequency) + '-' +
str(w.center_frequency))
elif wavelet == 'fbsp':
mlab.set_variable(
'wavelet', wavelet + str(w.fbsp_order) + '-' +
str(w.bandwidth_frequency) + '-' + str(w.center_frequency))
else:
mlab.set_variable('wavelet', wavelet)
if size_set == 'full':
data_sizes = list(range(100, 101)) + \
[100, 200, 500, 1000, 50000]
Scales = (1, np.arange(1, 3), np.arange(1, 4), np.arange(1, 5))
else:
import matplotlib.pyplot as plt
import numpy as np
import pywt
plt.rc('font', family='serif')
plt.rc('xtick', labelsize='10')
plt.rc('ytick', labelsize='10')
plt.rc('axes', titlesize=12)
plt.rc('text', usetex=True)
discrete_wavelets = ['db5', 'sym5', 'coif5', 'bior2.4']
continuous_wavelets = ['mexh', 'morl', 'shan', 'gaus5']
fig, axes = plt.subplots(1, 4, figsize=(6, 1.8))
for continuous_wavelet in enumerate(continuous_wavelets):
wavelet = pywt.ContinuousWavelet(continuous_wavelet[1])
w, x = wavelet.wavefun()
#Some wavelets names have 'wavelets' instead of 'wavelet' and it leaves an 'S'
title = wavelet.family_name.replace('wavelets', '')
title = title.replace('wavelet', '')
axes[continuous_wavelet[0]].plot(x, w, c='k', lw=1)
axes[continuous_wavelet[0]].set_title(title)
for axis in axes.ravel():
axis.set_xticks([])
axis.set_yticks([])
fig.tight_layout()
fig.savefig('D:/Thesis\Document/figures/plots/wavelets.pdf')
def test_continuous_wavelet_invalid_dtype():
with pytest.raises(ValueError):
pywt.ContinuousWavelet('gaus5', np.complex64)
with pytest.raises(ValueError):
pywt.ContinuousWavelet('gaus5', np.int_)
