def __init__(self, signal, time, frequency=100e3, wavelet='Mexican'):
"""
Parameters
----------
signal : ndarray
Signal to be analyzed
time : ndarray
Time basis
frequency : Float
Fourier frequency for the analysis
wavelet : :obj: `str`
String indicating the type of wavelet used
for the analysis. Default is 'Mexican'
"""
if wavelet == 'Mexican':
self.mother = wav.MexicanHat()
elif wavelet == 'DOG1':
self.mother = wav.DOG(m=1)
elif wavelet == 'Morlet':
self.mother = wav.Morlet()
else:
print 'Not a valid wavelet using Mexican'
self.mother = wav.MexicanHat()
# inizializza l'opportuna scala
self.fr = frequency
self.scale = 1. / self.mother.flambda() / self.fr
self.sig = copy.deepcopy(signal)
self.nsamp = signal.size
self.time = copy.deepcopy(time)
self.dt = (time.max() - time.min()) / (self.nsamp - 1)
self.Fs = 1. / self.dt
self.cwt()
def get_lf0_cwt(lf0):
mother = wavelet.MexicanHat()
dt = 0.005
dj = 0.015
s0 = dt*2
J = 513 - 1
Wavelet_lf0, scales, freqs, coi, fft, fftfreqs = wavelet.cwt(np.squeeze(lf0), dt, dj, s0, J, mother)
Wavelet_lf0 = np.real(Wavelet_lf0).T
return Wavelet_lf0, scales
def get_lf0_cwt(lf0):
mother = wavelet.MexicanHat()
# dt = 0.005
dt = 0.005
dj = 1
s0 = dt * 2
J = 9
Wavelet_lf0, scales, freqs, coi, fft, fftfreqs = wavelet.cwt(
np.squeeze(lf0), dt, dj, s0, J, mother)
Wavelet_lf0 = np.real(Wavelet_lf0).T # 取实数 并进行转置
return Wavelet_lf0, scales
def __init__(self, scale_min, scale_max, scale_count):
self.wavelet_type = "mexicanhat"
self.order = "freq" # other option is "normal"
self.scale_count = scale_count
self.scales = np.linspace(scale_min,
scale_max + 1,
num=scale_count,
endpoint=False,
dtype=int)
self.freqs = 1 / (pycwt.MexicanHat().flambda() * self.scales)
self.delta_t = 1
def inverse_cwt(wl, scales=None):
# wl: [10, T]
mother = wavelet.MexicanHat()
dt = 0.005
dj = 1
s0 = dt * 2
J = 9
C_delta = 3.541
if scales is None:
scales = np.array([0.01, 0.02, 0.04, 0.08, 0.16, 0.32, 0.64, 1.28, 2.56, 5.12])
icwt_signal = wavelet.icwt(wl, scales, dt, dj, mother) / C_delta
return icwt_signal
def get_lf0_le_cwt(lf0, le):
mother = wavelet.MexicanHat()
dt = 0.005
dj = 1
s0 = dt * 2
J = 9
C_delta = 3.541
Wavelet_lf0, scales, _, _, _, _ = wavelet.cwt(np.squeeze(lf0), dt, dj, s0, J, mother)
Wavelet_le, scales, _, _, _, _ = wavelet.cwt(np.squeeze(le), dt, dj, s0, J, mother)
Wavelet_lf0 = np.real(Wavelet_lf0).T
Wavelet_le = np.real(Wavelet_le).T # (T, D=10)
lf0_le_cwt = np.concatenate((Wavelet_lf0, Wavelet_le), -1)
return lf0_le_cwt
def get_lf0_cwt(lf0):
mother = wavelet.MexicanHat()
#dt = 0.005
dt = 0.005
dj = 1
s0 = dt * 2
J = 9
#C_delta = 3.541
#Wavelet_lf0, scales, _, _, _, _ = wavelet.cwt(np.squeeze(lf0), dt, dj, s0, J, mother)
Wavelet_lf0, scales, freqs, coi, fft, fftfreqs = wavelet.cwt(
np.squeeze(lf0), dt, dj, s0, J, mother)
#Wavelet_le, scales, _, _, _, _ = wavelet.cwt(np.squeeze(le), dt, dj, s0, J, mother)
Wavelet_lf0 = np.real(Wavelet_lf0).T
#Wavelet_le = np.real(Wavelet_le).T # (T, D=10)
#0lf0_le_cwt = np.concatenate((Wavelet_lf0, Wavelet_le), -1)
# iwave = wavelet.icwt(np.squeeze(lf0), scales, dt, dj, mother) * std
return Wavelet_lf0, scales
def cwt_analysis(params, mother_name="mexican_hat",num_scales=12, first_scale = None, first_freq = None, scale_distance=1.0, apply_coi=True, period=5, frame_rate = 200):
"""Achieve the continous wavelet analysis of given parameters
Parameters
----------
params: arraylike
The parameters to analyze.
mother_name: string, optional
The name of the mother wavelet [default: mexican_hat].
num_scales: int, optional
The number of scales [default: 12].
first_scale: int, optional
The width of the shortest scale
first_freq: int, optional
The highest frequency in Hz
scale_distance: float, optional
The distance between scales [default: 1.0].
apply_coi: boolean, optional
Apply the Cone Of Influence (coi)
period: int, optional
The period of the mother wavelet [default: 5].
frame_rate: int, optional
The signal frame rate [default: 200].
Returns
-------
wavelet_matrix: ndarray
The wavelet data resulting from the analysis
scales: arraylike
The scale indices corresponding to the wavelet data
"""
# setup wavelet transform
dt = 1. /float(frame_rate) # frame length
if not first_scale:
first_scale = dt # first scale, here frame length
if first_freq:
first_scale = _freq2scale(first_freq, mother_name, period)
dj = scale_distance # distance between scales in octaves
J = num_scales # number of scales
mother = cwt.MexicanHat()
if str.lower(mother_name) == "morlet":
mother = cwt.Morlet(period)
elif str.lower(mother_name) == "paul":
mother = cwt.Paul(period)
wavelet_matrix, scales, freqs, coi, fft, fftfreqs = _padded_cwt(params, dt, dj, first_scale, J,mother, 400)
#wavelet_matrix, scales, freqs, coi, fft, fftfreqs = cwt.cwt(f0_mean_sub, dt, dj, s0, J,mother)
#wavelet_matrix = abs(wavelet_matrix)
wavelet_matrix = _scale_for_reconstruction((wavelet_matrix), scales, dj, dt,mother=mother_name,period=period)
if apply_coi:
#wavelet_matrix = _zero_outside_coi(wavelet_matrix, scales/dt*0.5)
wavelet_matrix = _zero_outside_coi(wavelet_matrix, freqs, frame_rate)
import numpy as np
np.set_printoptions(precision=3, suppress=True)
return (wavelet_matrix,scales,freqs)
# append
Runup.append(np.array(runup))
Runup_time.append(np.array(runup_time))
Swash_Runs.append(g.strftime("%Y%m%d-%H%M"))
return Swash_Runs, Runup_time, Runup
if __name__ == '__main__':
print("\nProcessing swash-by-swash data, please wait...")
# Constants
Qb_TRX = 0.9
MOTHER = wavelet.MexicanHat()
DT = 1 # 1 second
S0 = 0.25 * DT # starting scale, in this case 0.25*1 = 0.25 seconds
DJ = 1 / 12 # twelve sub-octaves per octaves
J = 8 / DJ # eight powers of two with dj sub-octaves
LIMS = [25, 250]
# Labels
labels = np.array([
2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0
])
# KDE parameters
CLIP = (-np.inf, np.inf)
CUT = 4
def parse_frames(image_file, sig=0.95):
"""
"""
cap = cv2.VideoCapture(image_file)
if verbose: print("Video successfully loaded")
FRAME_COUNT = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
FPS = cap.get(cv2.CAP_PROP_FPS)
if verbose > 1:
FRAME_HEIGHT = cap.get(cv2.CAP_PROP_FRAME_HEIGHT)
FRAME_WIDTH = cap.get(cv2.CAP_PROP_FRAME_WIDTH)
print(
"INFO: \n Frame count: ",
FRAME_COUNT,
"\n",
"FPS: ",
FPS,
" \n",
"FRAME_HEIGHT: ",
FRAME_HEIGHT,
" \n",
"FRAME_WIDTH: ",
FRAME_WIDTH,
" \n",
)
directory = os.getcwd(
) + '\\analysis\\{}_{}_{}_{}({})_{}_{}_scaled\\'.format(
date, trial_type, name, wavelet, order, per_min, per_max)
if not os.path.exists(directory):
os.makedirs(directory)
made = False
frame_idx = 0
idx = 0
dropped = 0
skip = True
thresh = None
df_wav = pd.DataFrame()
df_auc = pd.DataFrame()
df_for = pd.DataFrame()
df_pow = pd.DataFrame()
for i in range(FRAME_COUNT):
a, img = cap.read()
if a:
frame_idx += 1
if made == False:
#first we need to manually determine the boundaries and angle
res = bg.manual_format(img)
#print(res)
x, y, w, h, angle = res
horizon_begin = x
horizon_end = x + w
vert_begin = y
vert_end = y + h
#scale_array = np.zeros((FRAME_COUNT, abs(horizon_begin - horizon_end)))
#area_time = np.zeros((FRAME_COUNT))
#df[']
print("Now Select the Red dot")
red_res = bg.manual_format(img, stop_sign=True)
red_x, red_y, red_w, red_h = red_res
box_h_begin = red_x
box_h_end = red_x + red_w
box_v_begin = red_y
box_v_end = red_y + red_h
made = True
#dims = (vert_begin, vert_end, horizon_begin, horizon_end)
real_time = i / FPS
rows, cols, chs = img.shape
M = cv2.getRotationMatrix2D((cols / 2, rows / 2), angle, 1)
rot_img = cv2.warpAffine(img, M, (cols, rows))
roi = rot_img[vert_begin:vert_end, horizon_begin:horizon_end, :]
red_box = img[box_v_begin:box_v_end, box_h_begin:box_h_end, 2]
if thresh == None:
thresh = np.mean(red_box)
#print(np.mean(red_box))
percent_drop = 1 - (np.mean(red_box) / thresh)
print(percent_drop)
if percent_drop >= 0.18:
#cv2.imshow("Red Image", red_box)
#cv2.waitKey(0)
skip = False
if skip:
if verbose >= 1:
print('Frame is skipped {} / {}'.format(
frame_idx, FRAME_COUNT))
continue
if verbose >= 1:
print('Processing frame {} / {}'.format(
frame_idx, FRAME_COUNT))
idx += 1
begin_code, data_line = extract_frame(roi)
#We need to detrend the data before sending it away
N = len(data_line)
dt = su / N
t = np.arange(0, N) * dt
t = t - np.mean(t)
var, std, dat_norm = detrend(data_line)
###################################################################
if wavelet == 'DOG':
mother = cwt.DOG(order)
elif wavelet == 'Paul':
mother = cwt.Paul(order)
elif wavelet == 'Morlet':
mother = cwt.Morlet(order)
elif wavelet == 'MexicanHat':
mother = cwt.MexicanHat(order)
s0 = 4 * dt
try:
alpha, _, _ = cwt.ar1(dat_norm)
except:
alpha = 0.95
wave, scales, freqs, coi, fft, fftfreqs = cwt.cwt(
dat_norm, dt, dj, s0, J, mother)
iwave = cwt.icwt(
wave, scales, dt, dj,
mother) * std #This is a reconstruction of the wave
power = (np.abs(wave))**2 #This is the power spectra
fft_power = np.abs(fft)**2 #This is the fourier power
period = 1 / freqs #This is the periods of the wavelet analysis in cm
power /= scales[:,
None] #This is an option suggested by Liu et. al.
#Next we calculate the significance of the power spectra. Significane where power / sig95 > 1
signif, fft_theor = cwt.significance(1.0,
dt,
scales,
0,
alpha,
significance_level=0.95,
wavelet=mother)
sig95 = np.ones([1, N]) * signif[:, None]
sig95 = power / sig95
#This is the significance of the global wave
glbl_power = power.mean(axis=1)
dof = N - scales # Correction for padding at edges
glbl_signif, tmp = cwt.significance(var,
dt,
scales,
1,
alpha,
significance_level=0.95,
dof=dof,
wavelet=mother)
sel = find((period >= per_min) & (period < per_max))
Cdelta = mother.cdelta
scale_avg = (scales * np.ones((N, 1))).transpose()
scale_avg = power / scale_avg # As in Torrence and Compo (1998) equation 24
#scale_avg = var * dj * dt / Cdelta * scale_avg[sel, :].sum(axis=0)
#scale_array[i,:] = scale_array[i,:]/np.max(scale_array[i,:])
#data_array[i,:] = data_array[i,:]/np.max(data_array[i,:])
scale_avg = var * dj * dt / Cdelta * scale_avg[sel, :].sum(axis=0)
scale_avg_signif, tmp = cwt.significance(
var,
dt,
scales,
2,
alpha,
significance_level=0.95,
dof=[scales[sel[0]], scales[sel[-1]]],
wavelet=mother)
Yticks = 2**np.arange(np.ceil(np.log2(period.min())),
np.ceil(np.log2(period.max())))
plt.close('all')
plt.ioff()
figprops = dict(figsize=(11, 8), dpi=72)
fig = plt.figure(**figprops)
wx = plt.axes([0.77, 0.75, 0.2, 0.2])
imz = 0
for idxy in range(0, len(period), 10):
wx.plot(t, mother.psi(t / period[idxy]) + imz, linewidth=1.5)
imz += 1
wx.xaxis.set_ticklabels([])
#wx.set_ylim([-10,10])
# First sub-plot, the original time series anomaly and inverse wavelet
# transform.
ax = plt.axes([0.1, 0.75, 0.65, 0.2])
ax.plot(t,
data_line - np.mean(data_line),
'k',
label="Original Data")
ax.plot(t,
iwave,
'-',
linewidth=1,
color=[0.5, 0.5, 0.5],
label="Reconstructed wave")
ax.plot(t,
dat_norm,
'--k',
linewidth=1.5,
color=[0.5, 0.5, 0.5],
label="Denoised Wave")
ax.set_title(
'a) {:10.2f} from beginning of trial.'.format(real_time))
ax.set_ylabel(r'{} [{}]'.format("Amplitude", unit))
ax.legend(loc=1)
ax.set_ylim([-200, 200])
#If the non-serrated section, bounds are 200 -
# Second sub-plot, the normalized wavelet power spectrum and significance
# level contour lines and cone of influece hatched area. Note that period
# scale is logarithmic.
bx = plt.axes([0.1, 0.37, 0.65, 0.28], sharex=ax)
levels = [0.0625, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16]
cont = bx.contourf(t,
np.log2(period),
np.log2(power),
np.log2(levels),
extend='both',
cmap=plt.cm.viridis)
extent = [t.min(), t.max(), 0, max(period)]
bx.contour(t,
np.log2(period),
sig95, [-99, 1],
colors='k',
linewidths=2,
extent=extent)
bx.fill(np.concatenate(
[t, t[-1:] + dt, t[-1:] + dt, t[:1] - dt, t[:1] - dt]),
np.concatenate([
np.log2(coi), [1e-9],
np.log2(period[-1:]),
np.log2(period[-1:]), [1e-9]
]),
'k',
alpha=0.3,
hatch='x')
bx.set_title(
'b) {} Octaves Wavelet Power Spectrum [{}({})]'.format(
octaves, mother.name, order))
bx.set_ylabel('Period (cm)')
#
Yticks = 2**np.arange(np.ceil(np.log2(period.min())),
np.ceil(np.log2(period.max())))
bx.set_yticks(np.log2(Yticks))
bx.set_yticklabels(Yticks)
cbar = fig.colorbar(cont, ax=bx)
# Third sub-plot, the global wavelet and Fourier power spectra and theoretical
# noise spectra. Note that period scale is logarithmic.
cx = plt.axes([0.77, 0.37, 0.2, 0.28], sharey=bx)
cx.plot(glbl_signif, np.log2(period), 'k--')
cx.plot(var * fft_theor, np.log2(period), '--', color='#cccccc')
cx.plot(var * fft_power,
np.log2(1. / fftfreqs),
'-',
color='#cccccc',
linewidth=1.)
cx.plot(var * glbl_power, np.log2(period), 'k-', linewidth=1.5)
cx.set_title('c) Global Wavelet Spectrum')
cx.set_xlabel(r'Power [({})^2]'.format(unit))
#cx.set_xlim([0, (var*fft_theor).max()])
plt.xscale('log')
cx.set_ylim(np.log2([period.min(), period.max()]))
cx.set_yticks(np.log2(Yticks))
cx.set_yticklabels(Yticks)
#if sig_array == []:
yvals = np.linspace(Yticks.min(), Yticks.max(), len(period))
plt.xscale('linear')
plt.setp(cx.get_yticklabels(), visible=False)
# Fourth sub-plot, the scale averaged wavelet spectrum.
dx = plt.axes([0.1, 0.07, 0.65, 0.2], sharex=ax)
dx.axhline(scale_avg_signif,
color='k',
linestyle='--',
linewidth=1.)
dx.plot(t, scale_avg, 'k-', linewidth=1.5)
dx.set_title('d) {}-{}cm scale-averaged power'.format(
per_min, per_max))
dx.set_xlabel('Distance from center(cm)')
dx.set_ylabel(r'Average variance [{}]'.format(unit))
#dx.set_ylim([0,500])
ax.set_xlim([t.min(), t.max()])
#plt.savefig(directory+'{}_analysis_frame-{}.png'.format(name, idx), bbox = 'tight')
if verbose >= 2:
print('*' * int((i / FRAME_COUNT) * 100))
df_wav[real_time] = (pd.Series(dat_norm, index=t))
df_pow[real_time] = (pd.Series(var * glbl_power,
index=np.log2(period)))
df_for[real_time] = (pd.Series(var * fft_power,
index=np.log2(1. / fftfreqs)))
df_auc[real_time] = [np.trapz(data_line)]
else:
print("Frame #{} has dropped".format(i))
dropped += 1
if verbose >= 1: print('All images saved')
if verbose >= 1:
print("{:10.2f} % of the frames have dropped".format(
(dropped / FRAME_COUNT) * 100))
#Plotting and saving tyhe
row, cols = df_pow.shape
time = np.arange(0, cols) / FPS
plt.close('all')
plt.ioff()
plt.contourf(time, df_pow.index.tolist(), df_pow)
plt.contour(time, df_pow.index.tolist(), df_pow)
plt.title("Global Power over Time")
plt.ylabel("Period[cm]")
plt.xlabel("Time")
cax = plt.gca()
#plt.xscale('log')
cax.set_ylim(np.log2([period.min(), period.max()]))
cax.set_yticks(np.log2(Yticks))
cax.set_yticklabels(Yticks)
plt.savefig(directory + '{}_global_power-{}.png'.format(name, idx),
bbox='tight')
row, cols = df_for.shape
time = np.arange(0, cols) / FPS
plt.close('all')
plt.ioff()
plt.contourf(time, df_for.index.tolist(), df_for)
plt.contour(time, df_for.index.tolist(), df_for)
plt.title("Fourier Power over Time")
plt.ylabel("Period[cm]")
plt.xlabel("Time")
cax = plt.gca()
#plt.xscale('log')
cax.set_ylim(np.log2([period.min(), period.max()]))
cax.set_yticks(np.log2(Yticks))
cax.set_yticklabels(Yticks)
plt.savefig(directory + '{}_fourier_power-{}.png'.format(name, idx),
bbox='tight')
plt.close('all')
plt.ioff()
rows, cols = df_auc.shape
time = np.arange(0, cols) / FPS
plt.plot(time, df_auc.T)
plt.xlabel("Time")
plt.ylabel("Area under the curve in cm")
plt.title("Area under the curve over time")
plt.savefig(directory + '{}_area_under_curve-{}.png'.format(name, idx),
bbox='tight')
df_wav['Mean'] = df_wav.mean(axis=1)
df_pow['Mean'] = df_pow.mean(axis=1)
df_for['Mean'] = df_for.mean(axis=1)
df_auc['Mean'] = df_auc.mean(axis=1)
df_wav['Standard Deviation'] = df_wav.std(axis=1)
df_pow['Standard Deviation'] = df_pow.std(axis=1)
df_for['Standard Deviation'] = df_for.std(axis=1)
df_auc['Standard Deviation'] = df_auc.std(axis=1)
##[Writing analysis to excel]##############################################
print("Writing files")
writer = pd.ExcelWriter(directory + "analysis{}.xlsx".format(trial_name))
df_wav.to_excel(writer, "Raw Waveforms")
df_auc.to_excel(writer, "Area Under the Curve")
df_for.to_excel(writer, "Fourier Spectra")
df_pow.to_excel(writer, "Global Power Spectra")
writer.save()
##[Writing means to a single file]#########################################
#filename = 'C:\\pyscripts\\wavelet_analysis\\Overall_Analysis.xlsx'
#append_data(filename, df_pow['Mean'].values, str(trial_name), Yticks)
##[Plotting mean power and foruier]########################################
plt.close('all')
plt.ioff()
plt.plot(df_pow['Mean'], df_pow.index.tolist(), label="Global Power")
plt.plot(df_for['Mean'], df_for.index.tolist(), label="Fourier Power")
plt.title("Global Power averaged over Time")
plt.ylabel("Period[cm]")
plt.xlabel("Power[cm^2]")
cax = plt.gca()
#plt.xscale('log')
cax.set_ylim(np.log2([period.min(), period.max()]))
cax.set_yticks(np.log2(Yticks))
cax.set_yticklabels(Yticks)
plt.legend()
plt.savefig(directory + '{}_both_{}.png'.format(name, idx), bbox='tight')
plt.close('all')
plt.ioff()
plt.plot(df_pow['Mean'], df_pow.index.tolist(), label="Global Power")
plt.title("Global Power averaged over Time")
plt.ylabel("Period[cm]")
plt.xlabel("Power[cm^2]")
cax = plt.gca()
#plt.xscale('log')
cax.set_ylim(np.log2([period.min(), period.max()]))
cax.set_yticks(np.log2(Yticks))
cax.set_yticklabels(Yticks)
plt.legend()
plt.savefig(directory + '{}_global_power_{}.png'.format(name, idx),
bbox='tight')
plt.close('all')
plt.ioff()
plt.plot(df_for['Mean'], df_for.index.tolist(), label="Fourier Power")
plt.title("Fourier averaged over Time")
plt.ylabel("Period[cm]")
plt.xlabel("Power[cm^2]")
cax = plt.gca()
#plt.xscale('log')
cax.set_ylim(np.log2([period.min(), period.max()]))
cax.set_yticks(np.log2(Yticks))
cax.set_yticklabels(Yticks)
plt.legend()
plt.savefig(directory + '{}_fourier_{}.png'.format(name, idx),
bbox='tight')
cap.release()
return directory
import numpy as np
from scipy import signal
from scipy import interpolate
import pycwt as wavelet
from statsmodels.tsa.ar_model import AutoReg
mother_wave_dict = {
'gaussian': wavelet.DOG(),
'paul': wavelet.Paul(),
'mexican_hat': wavelet.MexicanHat()
}
def calculate_power(freq, pow, fmin, fmax):
"""
Compute the power within the band range
Parameters
----------
freq: array-like
list of all frequencies need to be computed
pow: array-like
the power of relevant frequencies
fmin: float
lower bound of the selected band
fmax: float
upper bound of the selected band
Returns
-------
:float
def limStructure(self,
frequency=100e3,
wavelet='Mexican',
peaks=False,
valleys=False):
"""
Determination of the time location of the intermittent
structure accordingly to the method defined in
*M. Onorato et al Phys. Rev. E 61, 1447 (2000)*
Parameters
----------
frequency : :obj: `float`
Fourier frequency considered for the analysis
wavelet : :obj: `string`
Mother wavelet for the continuous wavelet analysis
possibilityes are *Mexican [default]*, *DOG1* or
*Morlet*
peaks : :obj: `Boolean`
if set it computes the structure only for the peaks
Default is False
valleys : :obj: `Boolean`
if set it computes the structure only for the valleys
Default is False
Returns
-------
maxima : :obj: `ndarray`
A binary array equal to 1 at the identification of
the structure (local maxima)
allmax : :obj: `ndarray`
A binary array equal to 1 in all the region where the
signal is above the threshold
Attributes
----------
scale : :obj: `float`
Corresponding scale for the chosen wavelet
"""
if wavelet == 'Mexican':
self.mother = wav.MexicanHat()
elif wavelet == 'DOG1':
self.mother = wav.DOG(m=1)
elif wavelet == 'Morlet':
self.mother = wav.Morlet()
else:
print('Not a valid wavelet using Mexican')
self.mother = wav.Mexican_hat()
self.freq = frequency
self.scale = 1. / self.mother.flambda() / self.freq
# compute the continuous wavelet transform
wt, sc, freqs, coi, fft, fftfreqs = wav.cwt(self.sig, self.dt, 0.25,
self.scale, 0, self.mother)
wt = np.real(np.squeeze(wt))
wtOr = wt.copy()
# normalization
wt = (wt - wt.mean()) / wt.std()
self.lim = np.squeeze(np.abs(wt**2) / np.mean(wt**2))
flatness = self.flatness
newflat = flatness
threshold = 20.
while newflat >= 3.05 and threshold > 0:
threshold -= 0.2
d_ev = (self.lim > threshold)
count = np.count_nonzero(d_ev)
if 0 < count < self.lim.size:
newflat = np.mean(wt[~d_ev] ** 4) / \
np.mean(wt[~d_ev] ** 2) ** 2
# now we have identified the threshold
# we need to find the maximum above the treshold
maxima = np.zeros(self.sig.size)
allmax = np.zeros(self.sig.size)
allmax[(self.lim > threshold)] = 1
imin = 0
for i in range(maxima.size - 1):
i += 1
if self.lim[i] >= threshold > self.lim[i - 1]:
imin = i
if self.lim[i] < threshold <= self.lim[i - 1]:
imax = i - 1
if imax == imin:
d = 0
else:
d = self.lim[imin:imax].argmax()
maxima[imin + d] = 1
if peaks:
ddPeak = ((maxima == 1) & (wtOr > 0))
maxima[~ddPeak] = 0
if valleys:
ddPeak = ((maxima == 1) & (wtOr < 0))
maxima[~ddPeak] = 0
return maxima, allmax
