PySDKit 0.4__py3-none-any.whl → 0.4.2__py3-none-any.whl

{PySDKit-0.4.dist-info → PySDKit-0.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PySDKit
-Version: 0.4
+Version: 0.4.2
 Summary: A Python library for signal decomposition algorithms with a unified interface
 Home-page: https://github.com/wwhenxuan/PySDKit
 Author: whenxuan
@@ -31,9 +31,7 @@ Requires-Dist: matplotlib (>=3.7.2)
 
 A Python library for signal decomposition algorithms
 
-<div align="center">
-<img src=".\images\Logo_sd.png" alt="Logo_sd" width="500"/>
-</div>
+![Logo](https://raw.githubusercontent.com/wwhenxuan/PySDKit/main/images/Logo_sd.png)
 
 ## Installation
 
@@ -67,7 +65,7 @@ IMFs = emd.fit_transform(signal, max_imf=2)
 plot_IMFs(signal, IMFs)
 ~~~
 
-<img src=".\images\example.jpg" alt="example" />
+![example](https://raw.githubusercontent.com/wwhenxuan/PySDKit/main/images/example.jpg)
 
 The EMD in the above example is the most classic `empirical mode decomposition` algorithm in signal decomposition. For more complex signals, you can try other algorithms such as variational mode decomposition ([`VMD`](https://ieeexplore.ieee.org/abstract/document/6655981)).
 
@@ -85,7 +83,7 @@ print(IMFs.shape)
 vmd.plot_IMFs(save_figure=True)
 ~~~
 
-<img src=".\images\vmd_example.jpg" alt="vmd_example.jpg" />
+![vmd_example](https://raw.githubusercontent.com/wwhenxuan/PySDKit/main/images/vmd_example.jpg)
 
 Better observe the characteristics of the decomposed intrinsic mode function in the frequency domain.
 
@@ -96,5 +94,4 @@ from pysdkit.plot import plot_IMFs_amplitude_spectra
 plot_IMFs_amplitude_spectra(IMFs, smooth="exp")   # use exp smooth
 ~~~
 
-<img src=".\images\frequency_example.jpg" alt="frequency_example" />
-
+![frequency_example](https://raw.githubusercontent.com/wwhenxuan/PySDKit/main/images/frequency_example.jpg)

{PySDKit-0.4.dist-info → PySDKit-0.4.2.dist-info}/RECORD

@@ -1,16 +1,16 @@
-pysdkit/__init__.py,sha256=nsuYXOdFNc3J-NNu5kkMXbeF8z_CBVLIo3tTKwEP53k,259
+pysdkit/__init__.py,sha256=dHeg5ai9k1iznEr0OdtVkKTQLmeOOTsDa9AynzOOPXA,262
 pysdkit/data/__init__.py,sha256=i_ZMKR_FcLq8wWXJ0MyLA4S41iXTMWbpf9sGpoLWdpw,621
 pysdkit/data/_add_noise.py,sha256=8cGzAquIPlf0hzTMUOBj8R1SEjGd2-JveWyzPPII05M,949
 pysdkit/data/_generator.py,sha256=gW7D9A8OTKJ5CBQ40oTbowu9PMZx-WiyN43oz42OAL4,12119
 pysdkit/emd/BEMD.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pysdkit/emd/EMD.py,sha256=xyQT7IqitAQ9mdOfDDh4QEwlFU7SODl_9y5wd3M-v-k,18090
+pysdkit/emd/EMD.py,sha256=dvhfOT_qfZnKJywQpSQSsiCNcMYF7hC9Pau4GJezcL8,18092
 pysdkit/emd/__init__.py,sha256=HdOfha6kuiKz2sdTENF_7bHTN2BT2Qtr5i1xXc9dOm8,22
 pysdkit/emd/_find_extrema.py,sha256=EnUZB9Z4uUaVTfuH2J2hERUR6cmsWQ890gQt8BpE1f0,5368
 pysdkit/emd/_prepare_points.py,sha256=XwEkwRPmHTZZcHhjiBx2lv_Qvj-gx2lw76locyOBf-8,10528
 pysdkit/emd/_splines.py,sha256=aaAULcznyn6mSciDeht4hdKZx1MhvKTvd0Z-bQVpd9E,2575
 pysdkit/emd2d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pysdkit/ewt/__init__.py,sha256=Yz5QcfLHTqf_69qJ663ESoUzrbKSnhHY0angsegqhvk,60
-pysdkit/ewt/_ewt.py,sha256=TVo7GbVtBtFr7vHFQmE2PPyxX3hp0Pe3aNQyNAH_P5E,15703
+pysdkit/ewt/__init__.py,sha256=DPk4dSLaTyelSoqZ4xCSWpGA1R3jSoNrzP-oIJG_MTQ,42
+pysdkit/ewt/ewt.py,sha256=dNPp7-nEqSZS1ZAk6ul7SDjWqo33hrh1OAvA-iYZOPg,21330
 pysdkit/metrics/_Index_of_Orthogonality.py,sha256=nmUEP56TVeZqKogP0QqylJwLL3QMxUNLup273PM1yV4,1128
 pysdkit/metrics/__init__.py,sha256=4TgRjJuOxNMCEloP-Vnq-z5VnrzYKQCypUaAMJb_nkI,169
 pysdkit/plot/__init__.py,sha256=_SklnKYnFm42Yso9R_UGkzwyyi98tTngkHhgQ4JrIug,92
@@ -18,7 +18,7 @@ pysdkit/plot/_fourier_spectra.py,sha256=7HzjHf6EeZ2DScgvMvveIQYSPVhXLfQSL6sGSUJm
 pysdkit/plot/_functions.py,sha256=rakosRbEg6KgdQJB26x6DGO6On3Ht9KD2MR2Wu7gSyc,4040
 pysdkit/plot/_plot_imfs.py,sha256=YsVyazrSwBzQ3EmLj7pzZqVmxolTbSljYnAP-sIJRdQ,4239
 pysdkit/plot/main.py,sha256=O_CKGAPPVaNBOqZwA7FrWcGJJEz76bbL_PomNJMtO7w,102
-pysdkit/utils/__init__.py,sha256=6M-DhV8ghK_O2PoMBnj6tLbv_3XcR1CeAqxw-DM0Ass,1076
+pysdkit/utils/__init__.py,sha256=1EyfVWKV6cMXPapt9lYE0pHlgAaxAhphNEo56K8GVz0,1759
 pysdkit/utils/_differ.py,sha256=q0AoYecFLOlPsFcbjV7G_r4AGfp8WfVJ3aD9rbHIdJo,866
 pysdkit/utils/_fft.py,sha256=VgluJaLeuuJ333_kJH1CKDbnlc6m_KX60pNfdRbv73Q,472
 pysdkit/utils/_function.py,sha256=dBF4gSjEBavAZjx0PrnZ8Z_iBk5T-zLmU3XEC1XvwTE,1436
@@ -30,13 +30,13 @@ pysdkit/vmd/__init__.py,sha256=nNmNpo65_SlqZhqQXsYj-FRkCO-KHSRY2XeGp5vmzPo,73
 pysdkit/vmd/_avmd.py,sha256=xUtmiyFOqkol7Oqh_yDPzGAr6b7FrfVXG6AlDOnTvr8,473
 pysdkit/vmd/_mvmd.py,sha256=ANXqmfJA0Y5Ib80Yw0URzqHIIFFiJfg5p1CswTXiM1o,9109
 pysdkit/vmd/_svmd.py,sha256=JDoR0BrocbsHn-zeg2fJ4wkuykEVh700yZKdgPk5M2o,384
-pysdkit/vmd/_vmd_c.py,sha256=BxgdERwbyEE88NWvaKCuhSBxB3gz9hUr-2qWDoRpfZU,8758
-pysdkit/vmd/_vmd_f.py,sha256=kb2GiAThe_xqU7qLATkOdlbXj4kWFFLayKJ1nouc6eQ,5402
+pysdkit/vmd/_vmd_c.py,sha256=gLhUC4PTHm2pPQI6l-Plumzm1flUJ_sYhgx79MOAEeY,8756
+pysdkit/vmd/_vmd_f.py,sha256=S0ucWz_KDsiXwmRlt6lVPRBOurXOE05WSOgggT0lqP0,5390
 pysdkit/vmd/base.py,sha256=frcDhMadR2WHM6UTnjGgufAiZhweqrNti9E71h7zUQI,3442
 pysdkit/vncmd/__init__.py,sha256=n9grWZ12fpbtfAtiQO50Bkg1sB0eiUDXbiMmbWk_i8c,25
 pysdkit/vncmd/vncmd.py,sha256=digpTAUGRsddbS3bM-9p6-5tENq-__AT7aonYgVHEzA,12362
-PySDKit-0.4.dist-info/LICENSE,sha256=ogEPNDSH0_dhiv_lT3ifVIdgIzHAqNA_SemnxUfPBJk,7048
-PySDKit-0.4.dist-info/METADATA,sha256=of4rNNif_JkVzmWHNyit6nXJjnqvKGTV4anDdQ9HOFw,4268
-PySDKit-0.4.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-PySDKit-0.4.dist-info/top_level.txt,sha256=wN_Yil0woB5Tu_WrIRt4_T4eoRyXljCYvH0dL6-7ei0,8
-PySDKit-0.4.dist-info/RECORD,,
+PySDKit-0.4.2.dist-info/LICENSE,sha256=ogEPNDSH0_dhiv_lT3ifVIdgIzHAqNA_SemnxUfPBJk,7048
+PySDKit-0.4.2.dist-info/METADATA,sha256=Ea1kcbITEGZVAdixzCTO1ZUsCz1Sej_yaoOCi2Te1fQ,4376
+PySDKit-0.4.2.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+PySDKit-0.4.2.dist-info/top_level.txt,sha256=wN_Yil0woB5Tu_WrIRt4_T4eoRyXljCYvH0dL6-7ei0,8
+PySDKit-0.4.2.dist-info/RECORD,,

pysdkit/__init__.py

@@ -11,4 +11,4 @@ from .vmd import MVMD
 from .vncmd import VNCMD
 
 # 经验小波变换
-from .ewt import EWT1D
+from .ewt import ewt, EWT

pysdkit/emd/EMD.py

@@ -449,8 +449,9 @@ class EMD(object):
 
 if __name__ == '__main__':
     from matplotlib import pyplot as plt
+
     x = np.linspace(0, 1, 1024)
     f = np.cos(22 * np.pi * x ** 2) + 6 * x ** 2
     emd = EMD(spline_kind="akima")
     IMFs = emd.fit_transform(f, max_imf=2)
-    print(IMFs.shape)
+    print(IMFs.shape)

pysdkit/ewt/__init__.py

@@ -1,2 +1,2 @@
-from ._ewt import EWT1D
-from ._ewt import EWT_Meyer_Wavelet
+from .ewt import ewt
+from .ewt import EWT

pysdkit/ewt/ewt.py

@@ -0,0 +1,500 @@
+# -*- coding: utf-8 -*-
+"""
+Created on 2024/7/12 13:41
+@author: Whenxuan Wang
+@email: wwhenxuan@gmail.com
+Empirical Wavelet Transform for 1D signals
+Original paper:
+Gilles, J., 2013. Empirical Wavelet Transform. IEEE Transactions on Signal Processing, 61(16), pp.3999–4010.
+Available at: http://ieeexplore.ieee.org/lpdocs/epic03/wrapper.htm?arnumber=6522142.
+Original Matlab toolbox: https://www.mathworks.com/matlabcentral/fileexchange/42141-empirical-wavelet-transforms
+Original Code from: https://github.com/vrcarva/ewtpy
+"""
+import numpy as np
+from scipy.ndimage.filters import gaussian_filter
+from typing import Optional
+
+
+class EWT(object):
+    """Empirical Wavelet Transform with Class Interface."""
+
+    def __init__(self,
+                 N: Optional[int] = 5,
+                 log: Optional[float] = 0,
+                 detect: Optional[str] = "locmax",
+                 completion: Optional[float] = 0,
+                 reg: Optional[str] = 'average',
+                 lengthFilter: Optional[float] = 10,
+                 sigmaFilter: Optional[float] = 5) -> None:
+        """
+        :param N: Maximum number of modes (signal components) to detect and extract.
+        :param log: Set to 0 or 1 to indicate whether to operate in the logarithmic spectrum.
+        :param detect: Method for detecting boundaries in the Fourier domain ('locmax' or other detection methods).
+        :param completion: Set to 0 or 1 to indicate whether to complete the number of modes to N if fewer are detected.
+        :param reg: Regularization method applied to the filter bank ('none', 'gaussian', or 'average').
+        :param lengthFilter: Width of the filters used in regularization (for Gaussian or average filters).
+        :param sigmaFilter: Standard deviation for the Gaussian filter in the regularization step.
+        """
+        self.N = N
+        self.log = log
+        self.detect = detect
+        self.completion = completion
+        self.reg = reg
+        self.lengthFilter = lengthFilter
+        self.sigmaFilter = sigmaFilter
+
+    def fit_transform(self, signal: np.ndarray, N: Optional[int] = None, return_all: Optional[bool] = False):
+        """
+        Perform Empirical Wavelet Transform on the input signal.
+
+        :param signal: Input signal array to be decomposed.
+        :param N: Number of modes to extract. Defaults to the value specified during initialization.
+        :param return_all: If True, return the EWT decomposition, the filter bank, and the boundaries.
+                           If False, return only the EWT decomposition.
+
+        :returns:
+            - ewt: The extracted modes from the signal.
+            - mfb: The filter bank applied in the Fourier domain (only if return_all is True).
+            - boundaries: Boundaries detected in the Fourier spectrum (only if return_all is True).
+        """
+        N = self.N if N is None else N
+        # Compute the one-sided magnitude of the signal's Fourier transform
+        signal_ff = np.fft.fft(signal)
+        signal_ff = abs(signal_ff[0:int(np.ceil(signal_ff.size / 2))])  # one-sided magnitude
+
+        # Detect boundaries in the Fourier domain
+        boundaries = EWT_Boundaries_Detect(signal_ff, self.log, self.detect, N, self.reg,
+                                           self.lengthFilter, self.sigmaFilter)
+        boundaries = boundaries * np.pi / round(signal_ff.size)
+
+        # If fewer boundaries are detected, complete to reach N-1 if completion is enabled
+        if self.completion == 1 and len(boundaries) < N - 1:
+            boundaries = EWT_Boundaries_Completion(boundaries, N - 1)
+
+        # Extend the signal by mirroring to avoid boundary effects during filtering
+        ltemp = int(np.ceil(signal.size / 2))
+        fMirr = fmirror(ts=signal, sym=ltemp, end=1)
+        ffMirr = np.fft.fft(fMirr)
+
+        # Build the filter bank based on the detected boundaries
+        mfb = EWT_Meyer_FilterBank(boundaries, ffMirr.size)
+
+        # Filter the signal to extract each subband
+        ewt = np.zeros(mfb.shape)
+        for k in range(mfb.shape[1]):
+            ewt[:, k] = np.real(np.fft.ifft(np.conjugate(mfb[:, k]) * ffMirr))
+        ewt = ewt[ltemp - 1:-ltemp, :].T
+
+        # Return the requested data
+        if return_all is True:
+            return ewt, mfb, boundaries
+        else:
+            return ewt
+
+
+def ewt(signal, N: Optional[int] = 5,
+        log: Optional[float] = 0,
+        detect: Optional[str] = "locmax",
+        completion: Optional[float] = 0,
+        reg: Optional[str] = 'average',
+        lengthFilter: Optional[float] = 10,
+        sigmaFilter: Optional[float] = 5,
+        return_all: Optional[bool] = False):
+    """
+    Empirical Wavelet Transform with Function Interface.
+
+    :param signal: The input signal to be decomposed.
+    :param N: Maximum number of modes (signal components) to detect and extract.
+    :param log: Set to 0 or 1 to indicate whether to work with the logarithmic spectrum.
+    :param detect: Method for detecting boundaries in the Fourier domain ('locmax' or other methods).
+    :param completion: Set to 0 or 1 to indicate whether to complete the number of modes to N if fewer are detected.
+    :param reg: Regularization method applied to the filter bank ('none', 'gaussian', or 'average').
+    :param lengthFilter: Width of the filters used in regularization (for Gaussian or average filters).
+    :param sigmaFilter: Standard deviation for the Gaussian filter in the regularization step.
+    :param return_all: If True, return the EWT decomposition, the filter bank, and the boundaries.
+                       If False, return only the EWT decomposition.
+
+    :returns:
+        - ewt: The extracted modes from the signal.
+        - mfb: The filter bank in the Fourier domain (only if return_all is True).
+        - boundaries: Boundaries detected in the Fourier spectrum (only if return_all is True).
+    """
+    # Compute the one-sided magnitude of the signal's Fourier transform
+    ff = np.fft.fft(signal)
+    ff = abs(ff[0:int(np.ceil(ff.size / 2))])  # one-sided magnitude
+
+    # Detect boundaries in the Fourier domain
+    boundaries = EWT_Boundaries_Detect(ff, log, detect, N, reg, lengthFilter, sigmaFilter)
+    boundaries = boundaries * np.pi / round(ff.size)
+
+    # If fewer boundaries are detected, complete to reach N-1 if completion is enabled
+    if completion == 1 and len(boundaries) < N - 1:
+        boundaries = EWT_Boundaries_Completion(boundaries, N - 1)
+
+    # Extend the signal by mirroring to avoid boundary effects during filtering
+    ltemp = int(np.ceil(signal.size / 2))  # Similar to MATLAB's round function
+    fMirr = fmirror(ts=signal, sym=ltemp, end=1)
+    ffMirr = np.fft.fft(fMirr)
+
+    # Build the filter bank based on the detected boundaries
+    mfb = EWT_Meyer_FilterBank(boundaries, ffMirr.size)
+
+    # Filter the signal to extract each subband
+    ewt = np.zeros(mfb.shape)
+    for k in range(mfb.shape[1]):
+        ewt[:, k] = np.real(np.fft.ifft(np.conjugate(mfb[:, k]) * ffMirr))
+    ewt = ewt[ltemp - 1:-ltemp, :].T
+
+    # Return the requested data
+    if return_all is True:
+        return ewt, mfb, boundaries
+    else:
+        return ewt
+
+
+def fmirror(ts: np.ndarray, sym: int, end: int):
+    """Implements a signal mirroring expansion function."""
+    fMirr = np.append(np.flip(ts[0:sym - end], axis=0), ts)
+    fMirr = np.append(fMirr, np.flip(ts[-sym - end:-end], axis=0))
+    return fMirr
+
+
+def EWT_Boundaries_Detect(ff, log, detect, N, reg, lengthFilter, sigmaFilter):
+    """
+    Segments the input function `ff` into a certain number of supports (frequency bands)
+    using different techniques for boundary detection and regularization.
+
+    :param ff: The function (signal) to segment (typically in the frequency domain).
+    :param log: 0 or 1, indicating whether to apply logarithmic transformation to the spectrum.
+    :param detect: The method used for boundary detection. Options include:
+                   - 'locmax': Mid-point between consecutive local maxima (default).
+                   - 'locmaxmin': Lowest minima between consecutive local maxima.
+                   - 'locmaxminf': Lowest minima between consecutive local maxima of the original spectrum.
+    :param N: Maximum number of supports (modes or signal components) to detect.
+    :param reg: The regularization method to apply to the spectrum. Options include:
+                - 'none': No regularization.
+                - 'gaussian': Gaussian filtering with width `lengthFilter` and standard deviation `sigmaFilter`.
+                - 'average': Average filtering with width `lengthFilter`.
+    :param lengthFilter: The width of the Gaussian or average filter for regularization.
+    :param sigmaFilter: The standard deviation of the Gaussian filter for regularization.
+
+    :returns:
+        - boundaries: A list of detected boundaries (in terms of indices).
+
+    This function detects boundaries in the frequency domain based on different detection
+    methods. The spectrum can be regularized using Gaussian or average filters, which smooths
+    out the spectrum before detection.
+
+    - The 'locmax' method detects the mid-points between consecutive local maxima.
+    - The 'locmaxmin' method extracts the lowest minima between consecutive maxima.
+    - The 'locmaxminf' method uses the regularized spectrum for maxima detection and the original spectrum for minima.
+
+    """
+    # Apply log transformation if needed
+    if log == 1:
+        ff = np.log(ff)
+
+    # Apply regularization if needed
+    if reg == 'average':
+        regFilter = np.ones(lengthFilter) / lengthFilter
+        presig = np.convolve(ff, regFilter, mode='same')  # Averaging filter
+
+    elif reg == 'gaussian':
+        regFilter = np.zeros(lengthFilter)
+        regFilter[regFilter.size // 2] = 1  # Ensure center is set for Gaussian filtering
+        presig = np.convolve(ff, gaussian_filter(regFilter, sigmaFilter), mode='same')  # Gaussian filter
+    else:
+        presig = ff  # No regularization applied
+
+    # Boundary detection based on the selected method
+    if detect == "locmax":
+        boundaries = LocalMax(presig, N)  # Mid-point between consecutive local maxima
+
+    elif detect == "locmaxmin":
+        boundaries = LocalMaxMin(presig, N)  # Lowest local minima between selected maxima
+
+    elif detect == "locmaxminf":
+        boundaries = LocalMaxMin(presig, N, fm=ff)  # Minima on the original spectrum between maxima on regularized spectrum
+
+    else:
+        raise ValueError("Invalid detection method provided.")
+
+    return boundaries + 1  # Increment indices by 1 to account for zero-based indexing
+
+
+
+def LocalMax(ff, N):
+    """
+    Segments the input function `ff` into a maximum of `N` bands by locating
+    the N largest local maxima and calculating the middle points between them.
+
+    :param ff: The input function (signal) to segment.
+    :param N: The maximum number of bands (supports) to detect.
+
+    :returns:
+        - bound: A list of indices representing the detected boundaries between bands.
+
+    This function works by identifying local maxima in the input function `ff`,
+    selecting the `N` largest maxima, and then computing the midpoint between each
+    consecutive maximum to define the segment boundaries.
+    """
+    N = N - 1
+    locmax = np.zeros(ff.size)  # Initialize array to store local maxima
+    locmin = max(ff) * np.ones(ff.size)  # Initialize array for local minima
+
+    # Loop through the signal to find local maxima and minima
+    for i in np.arange(1, ff.size - 1):
+        if ff[i - 1] < ff[i] and ff[i] > ff[i + 1]:
+            locmax[i] = ff[i]  # Mark local maxima
+        if ff[i - 1] > ff[i] and ff[i] <= ff[i + 1]:
+            locmin[i] = ff[i]  # Mark local minima
+
+    N = min(N, locmax.size)  # Ensure N does not exceed the number of available maxima
+    # Find the indices of the N largest maxima
+    maxidxs = np.sort(locmax.argsort()[::-1][:N])
+
+    # Calculate the midpoints between consecutive maxima to define the boundaries
+    bound = np.zeros(N)
+    for i in range(N):
+        if i == 0:
+            a = 0
+        else:
+            a = maxidxs[i - 1]
+        bound[i] = (a + maxidxs[i]) / 2  # Calculate midpoint
+
+    return bound
+
+
+def LocalMaxMin(f, N, fm=0):
+    """
+    Segments the input function `f` into a maximum of `N` bands by detecting
+    the lowest local minima between the `N` largest local maxima. If `fm` is provided,
+    local maxima are computed on `f` and local minima are computed on `fm`. Otherwise,
+    both maxima and minima are computed on `f`.
+
+    This is useful when you want to compute the maxima on a regularized version of
+    your signal (f) while detecting the "true" minima on a different version (fm).
+
+    :param f: The function (signal) to segment.
+    :param N: The maximum number of bands (supports) to detect.
+    :param fm: (Optional) The function on which local minima will be computed.
+               If not provided, local minima will be computed on `f`.
+
+    :returns:
+        - bound: A list of indices representing the detected boundaries between bands.
+
+    This function detects local maxima and minima in the signal and then calculates
+    boundaries based on the N largest maxima and the lowest minima between them.
+    """
+    # Initialize array to store local maxima
+    locmax = np.zeros(f.size)
+
+    # If fm is not provided, use f for both maxima and minima detection
+    if type(fm) == int:
+        f2 = f
+    else:
+        f2 = fm
+
+    # Initialize array for local minima
+    locmin = max(f2) * np.ones(f2.size)
+
+    # Detect local minima and maxima in the signal
+    for i in np.arange(1, f.size - 1):
+        if (f[i - 1] < f[i]) and (f[i] > f[i + 1]):
+            locmax[i] = f[i]  # Mark local maxima
+        if (f2[i - 1] > f2[i]) and (f2[i] < f2[i + 1]):
+            locmin[i] = f2[i]  # Mark local minima
+
+    # Initialize the boundaries array
+    bound = np.zeros(N)
+
+    if N != -1:
+        N = N - 1
+        # Keep the N largest maxima
+        Imax = np.sort(locmax.argsort()[::-1][:N])
+
+        # Detect the lowest minima between two consecutive maxima
+        for i in range(N):
+            if i == 0:
+                a = 1
+            else:
+                a = Imax[i - 1]
+
+            # Sort minima between the current and previous maxima
+            lmin = np.sort(locmin[a:Imax[i]])
+            ind = np.argsort(locmin[a:Imax[i]])
+
+            # Find the true minimum
+            tmpp = lmin[0]
+            n = 0
+            if n < len(lmin):
+                n = 1
+                while (n < len(lmin)) and (tmpp == lmin[n]):
+                    n += 1
+
+            # Set the boundary to the midpoint of the smallest minima
+            bound[i] = a + ind[n // 2] - 1
+    else:
+        # Case when N is set to -1, meaning no limit on the number of bands
+        k = 0
+        for i in range(locmin.size):
+            if locmin[i] < max(f2):
+                bound[k] = i - 1
+                k += 1
+
+    return bound
+
+
+def EWT_Boundaries_Completion(boundaries, NT):
+    """
+    Completes the boundaries vector to ensure a total of `NT` boundaries by
+    equally splitting the last band (highest frequencies) between the final boundary
+    and π.
+
+    :param boundaries: The initial boundaries vector to be completed.
+    :param NT: The total number of boundaries desired.
+
+    :returns:
+        - boundaries: The completed boundaries vector.
+
+    This function adds additional boundaries by uniformly dividing the highest frequency
+    band (i.e., the region from the last boundary to π) into equal parts, such that the total
+    number of boundaries reaches `NT`.
+    """
+    # Calculate the number of additional boundaries needed
+    Nd = NT - len(boundaries)
+
+    # Calculate the width of each new segment to be added
+    deltaw = (np.pi - boundaries[-1]) / (Nd + 1)
+
+    # Add the new boundaries to the vector
+    for k in range(Nd):
+        boundaries = np.append(boundaries, boundaries[-1] + deltaw)
+
+    return boundaries
+
+
+def EWT_Meyer_FilterBank(boundaries, Nsig):
+    """
+    Generates the filter bank (scaling function + wavelets) corresponding to the
+    provided set of frequency segments.
+
+    :param boundaries: A vector containing the boundaries of frequency segments.
+                       Note that 0 and π should NOT be included in this vector.
+    :param Nsig: The length of the input signal.
+
+    :returns:
+        - mfb: A matrix where each column represents a filter in the Fourier domain.
+               The first column corresponds to the scaling function, and the
+               subsequent columns represent the successive wavelets.
+
+    This function generates a set of Meyer wavelets and a scaling function in the
+    Fourier domain based on the provided frequency boundaries.
+    """
+    Npic = len(boundaries)  # Number of frequency boundaries
+    # Compute gamma, which controls the transition width of the wavelets
+    gamma = 1
+    for k in range(Npic - 1):
+        r = (boundaries[k + 1] - boundaries[k]) / (boundaries[k + 1] + boundaries[k])
+        if r < gamma:
+            gamma = r
+    r = (np.pi - boundaries[Npic - 1]) / (np.pi + boundaries[Npic - 1])
+    if r < gamma:
+        gamma = r
+    gamma = (1 - 1 / Nsig) * gamma  # Ensure gamma is strictly less than the minimum
+
+    # Initialize the filter bank matrix
+    mfb = np.zeros([Nsig, Npic + 1])
+
+    # EWT_Meyer_Scaling - Generate the scaling function
+    Mi = int(np.floor(Nsig / 2))  # Half the signal length
+    w = np.fft.fftshift(np.linspace(0, 2 * np.pi - 2 * np.pi / Nsig, num=Nsig))  # Frequency grid
+    w[0:Mi] = -2 * np.pi + w[0:Mi]  # Shift the negative frequencies
+    aw = abs(w)  # Absolute frequency values
+    yms = np.zeros(Nsig)  # Initialize the scaling function
+    an = 1. / (2 * gamma * boundaries[0])
+    pbn = (1. + gamma) * boundaries[0]
+    mbn = (1. - gamma) * boundaries[0]
+
+    # Generate the scaling function based on the first boundary
+    for k in range(Nsig):
+        if aw[k] <= mbn:
+            yms[k] = 1
+        elif ((aw[k] >= mbn) and (aw[k] <= pbn)):
+            yms[k] = np.cos(np.pi * EWT_beta(an * (aw[k] - mbn)) / 2)
+
+    yms = np.fft.ifftshift(yms)  # Shift the scaling function back
+    mfb[:, 0] = yms  # Store the scaling function in the filter bank
+
+    # Generate the wavelets for the remaining boundaries
+    for k in range(Npic - 1):
+        mfb[:, k + 1] = EWT_Meyer_Wavelet(boundaries[k], boundaries[k + 1], gamma, Nsig)
+
+    # Generate the final wavelet for the last boundary segment (up to π)
+    mfb[:, Npic] = EWT_Meyer_Wavelet(boundaries[Npic - 1], np.pi, gamma, Nsig)
+
+    return mfb
+
+
+def EWT_beta(x):
+    """
+    Beta = EWT_beta(x)
+    function used in the construction of Meyer's wavelet
+    """
+    if x < 0:
+        bm = 0
+    elif x > 1:
+        bm = 1
+    else:
+        bm = (x ** 4) * (35. - 84. * x + 70. * (x ** 2) - 20. * (x ** 3))
+    return bm
+
+
+def EWT_Meyer_Wavelet(wn, wm, gamma, Nsig):
+    """
+    Generates the 1D Meyer wavelet in the Fourier domain associated with the
+    scale segment [wn, wm] with a transition ratio `gamma`.
+
+    :param wn: The lower boundary of the frequency segment.
+    :param wm: The upper boundary of the frequency segment.
+    :param gamma: The transition ratio that controls the width of the transition zones
+                  between frequency bands.
+    :param Nsig: The number of points in the signal.
+
+    :returns:
+        - ymw: The Fourier transform of the wavelet for the frequency band [wn, wm].
+
+    This function creates a Meyer wavelet in the Fourier domain with smooth transitions
+    between frequency bands defined by `wn` and `wm`.
+    """
+    # Compute the frequency grid
+    Mi = int(np.floor(Nsig / 2))  # Half the signal length
+    w = np.fft.fftshift(np.linspace(0, 2 * np.pi - 2 * np.pi / Nsig, num=Nsig))  # Frequency grid
+    w[0:Mi] = -2 * np.pi + w[0:Mi]  # Shift the negative frequencies
+    aw = abs(w)  # Absolute frequency values
+
+    # Initialize the wavelet in the Fourier domain
+    ymw = np.zeros(Nsig)
+
+    # Parameters for the Meyer wavelet transitions
+    an = 1. / (2 * gamma * wn)
+    am = 1. / (2 * gamma * wm)
+    pbn = (1. + gamma) * wn
+    mbn = (1. - gamma) * wn
+    pbm = (1. + gamma) * wm
+    mbm = (1. - gamma) * wm
+
+    # Construct the wavelet in the Fourier domain based on the segment boundaries
+    for k in range(Nsig):
+        if (aw[k] >= pbn) and (aw[k] <= mbm):  # Main passband
+            ymw[k] = 1
+        elif (aw[k] >= mbm) and (aw[k] <= pbm):  # Smooth transition in upper boundary
+            ymw[k] = np.cos(np.pi * EWT_beta(am * (aw[k] - mbm)) / 2)
+        elif (aw[k] >= mbn) and (aw[k] <= pbn):  # Smooth transition in lower boundary
+            ymw[k] = np.sin(np.pi * EWT_beta(an * (aw[k] - mbn)) / 2)
+
+    # Shift the wavelet back to the normal order
+    ymw = np.fft.ifftshift(ymw)
+
+    return ymw
+

pysdkit/utils/__init__.py

@@ -1,34 +1,35 @@
-# 傅里叶变换
-from ._fft import fft, ifft, fftshift, ifftshift
-
-# 信号的镜像拓展
-from .mirror import fmirror
-
-# 希尔伯特变换的各种函数
-from .hilbert import hilbert_transform, hilbert_real, hilbert_imaginary
-from .hilbert import plot_hilbert, plot_hilbert_complex_plane
-
-from .process import normalize_signal
-from .process import common_dtype
-from .process import not_duplicate
-
-from .process import find_zero_crossings
-from .process import get_timeline
-
-# 实现离散信号差分的算法
-from ._differ import differ
-
-# 实现一维信号平滑的函数
-from ._smooth1d import simple_moving_average, weighted_moving_average
-from ._smooth1d import gaussian_smoothing, savgol_smoothing, exponential_smoothing
-
-# 最大最小归一化
-from ._function import max_min_normalization
-# Z-score 标准化
-from ._function import z_score_normalization
-# 最大绝对值标准化
-from ._function import max_absolute_normalization
-# 对数变换
-from ._function import log_transformation
-# 小数定标标准化
-from ._function import decimal_scaling_normalization
+# Fourier Transform
+from ._fft import fft, ifft, fftshift, ifftshift  # 傅里叶变换的正变换、逆变换、频谱移动和逆移动
+
+# Signal mirroring extension
+from .mirror import fmirror  # 信号的镜像扩展
+
+# Various functions for Hilbert Transform
+from .hilbert import hilbert_transform, hilbert_real, hilbert_imaginary  # 希尔伯特变换的相关函数，包括获取实部和虚部
+from .hilbert import plot_hilbert, plot_hilbert_complex_plane  # 绘制希尔伯特变换结果的相关函数
+
+from .process import normalize_signal  # 归一化信号
+from .process import common_dtype  # 检查数据的通用数据类型
+from .process import not_duplicate  # 检查数据是否没有重复
+
+from .process import find_zero_crossings  # 查找信号的零交叉点
+from .process import get_timeline  # 获取信号的时间轴
+
+# Algorithm for discrete signal differencing
+from ._differ import differ  # 实现离散信号差分的算法
+
+# Functions for 1D signal smoothing
+from ._smooth1d import simple_moving_average, weighted_moving_average  # 实现一维信号的简单移动平均和平滑移动平均
+from ._smooth1d import gaussian_smoothing, savgol_smoothing, exponential_smoothing  # 高斯平滑、Savitzky-Golay平滑和指数平滑
+
+# Min-max normalization
+from ._function import max_min_normalization  # 最大最小归一化
+# Z-score standardization
+from ._function import z_score_normalization  # Z-score 标准化
+# Max-absolute normalization
+from ._function import max_absolute_normalization  # 最大绝对值标准化
+# Logarithmic transformation
+from ._function import log_transformation  # 对数变换
+# Decimal scaling normalization
+from ._function import decimal_scaling_normalization  # 小数定标标准化
+

pysdkit/vmd/_vmd_c.py

@@ -3,6 +3,8 @@
 Created on Sat Mar 4 11:59:21 2024
 @author: Whenxuan Wang
 @email: wwhenxuan@gmail.com
+Original paper: Dragomiretskiy, K. and Zosso, D. (2014) ‘Variational Mode Decomposition’,
+IEEE Transactions on Signal Processing, 62(3), pp. 531–544. doi: 10.1109/TSP.2013.2288675.
 """
 import numpy as np
 from typing import Optional, List
@@ -12,11 +14,7 @@ from ..plot import plot_IMFs
 
 
 class VMD(Base):
-    """
-    Variational mode decomposition, object-oriented interface.
-    Dragomiretskiy, K. and Zosso, D. (2014) ‘Variational Mode Decomposition’,
-    IEEE Transactions on Signal Processing, 62(3), pp. 531–544. doi: 10.1109/TSP.2013.2288675.
-    """
+    """Variational mode decomposition, object-oriented interface."""
 
     def __init__(self, alpha: int, K: int, tau: float, init: str = 'uniform', DC: bool = False,
                  max_iter: int = 500, tol: float = 1e-6):

pysdkit/vmd/_vmd_f.py

@@ -3,6 +3,8 @@
 Created on Sat Mar 4 11:59:21 2024
 @author: Whenxuan Wang
 @email: wwhenxuan@gmail.com
+Original paper: Dragomiretskiy, K. and Zosso, D. (2014) ‘Variational Mode Decomposition’,
+IEEE Transactions on Signal Processing, 62(3), pp. 531–544. doi: 10.1109/TSP.2013.2288675.
 """
 import numpy as np
 from ..utils import fft, ifft, fftshift, ifftshift, fmirror
@@ -12,9 +14,6 @@ def vmd(signal: np.array, alpha: int, K: int, tau: float, init: str = 'uniform',
         max_iter: int = 500, tol: float = 1e-6):
     """
     Variational mode decomposition, object-oriented interface.
-    Original paper:
-    Dragomiretskiy, K. and Zosso, D. (2014) ‘Variational Mode Decomposition’,
-    IEEE Transactions on Signal Processing, 62(3), pp. 531–544. doi: 10.1109/TSP.2013.2288675.
     :param signal: the time domain signal (1D numpy array)  to be decomposed
     :param alpha: the balancing parameter of the data-fidelity constraint
     :param K: the number of modes to be recovered

pysdkit/ewt/_ewt.py

@@ -1,449 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Tue Dec 18 11:45:32 2018
-Empirical Wavelet Transform implementation for 1D signals
-Original paper:
-Gilles, J., 2013. Empirical Wavelet Transform. IEEE Transactions on Signal Processing, 61(16), pp.3999–4010.
-Available at: http://ieeexplore.ieee.org/lpdocs/epic03/wrapper.htm?arnumber=6522142.
-Original Matlab toolbox: https://www.mathworks.com/matlabcentral/fileexchange/42141-empirical-wavelet-transforms
-
-@author: Vinícius Rezende Carvalho
-Programa de pós graduação em engenharia elétrica - PPGEE UFMG
-Universidade Federal de Minas Gerais - Belo Horizonte, Brazil
-Núcleo de Neurociências - NNC
-"""
-
-import numpy as np
-
-
-# %EWT functions
-def EWT1D(f, N=5, log=0, detect="locmax", completion=0, reg='average', lengthFilter=10, sigmaFilter=5):
-    """
-     =========================================================================
-     ewt,  mfb ,boundaries = EWT1D(f, N = 5, log = 0,detect = "locmax", completion = 0, reg = 'average', lengthFilter = 10,sigmaFilter = 5):
-
-     Perform the Empirical Wavelet Transform of f over N scales. See
-     also the documentation of EWT_Boundaries_Detect for more details about
-     the available methods and their parameters.
-
-     Inputs:
-       -f: the 1D input signal
-     Optional Inputs:
-       -log: 0 or 1 to indicate if we want to work with
-                    the log spectrum
-       -method: 'locmax','locmaxmin','locmaxminf'
-       -reg: 'none','gaussian','average'
-       -lengthFilter: width of the above filters (Gaussian or average)
-       -sigmaFilter: standard deviation of the above Gaussian filter
-       -N: maximum number of supports (modes or signal components)
-       -completion: 0 or 1 to indicate if we try to complete
-                           or not the number of modes if the detection
-                           find a lower number of mode than N
-     Outputs:
-       -ewt: contains first the low frequency component and
-             then the successives frequency subbands
-       -mfb: contains the filter bank (in the Fourier domain)
-       -boundaries: vector containing the set of boundaries corresponding
-                    to the Fourier line segmentation (normalized between
-                    0 and Pi)
-     Original MATLAB Version:
-     Author: Jerome Gilles
-     Institution: UCLA - Department of Mathematics
-     Year: 2013
-     Version: 2.0
-
-     Python Version: Vinícius Rezende Carvalho - vrcarva@ufmg.br
-     Universidade Federal de Minas Gerais - Brasil
-     Núcleo de Neurociências
-    % =========================================================================
-    """
-    # signal spectrum
-    ff = np.fft.fft(f)
-    ff = abs(ff[0:int(np.ceil(ff.size / 2))])  # one-sided magnitude
-    # extract boundaries of Fourier Segments
-    boundaries = EWT_Boundaries_Detect(ff, log, detect, N, reg, lengthFilter, sigmaFilter)
-    boundaries = boundaries * np.pi / round(ff.size)
-
-    if completion == 1 and len(boundaries) < N - 1:
-        boundaries = EWT_Boundaries_Completion(boundaries, N - 1)
-        # Filtering
-    # extend the signal by mirroring to deal with boundaries
-    ltemp = int(np.ceil(f.size / 2))  # to behave the same as matlab's round
-    fMirr = np.append(np.flip(f[0:ltemp - 1], axis=0), f)
-    fMirr = np.append(fMirr, np.flip(f[-ltemp - 1:-1], axis=0))
-    ffMirr = np.fft.fft(fMirr)
-
-    # build the corresponding filter bank
-    mfb = EWT_Meyer_FilterBank(boundaries, ffMirr.size)
-
-    # filter the signal to extract each subband
-    ewt = np.zeros(mfb.shape)
-    for k in range(mfb.shape[1]):
-        ewt[:, k] = np.real(np.fft.ifft(np.conjugate(mfb[:, k]) * ffMirr))
-    ewt = ewt[ltemp - 1:-ltemp, :]
-
-    return ewt, mfb, boundaries
-
-
-def EWT_Boundaries_Detect(ff, log, detect, N, reg, lengthFilter, sigmaFilter):
-    """This function segments f into a certain amount of supports by  using different technics:
-     - middle point between consecutive local maxima (default),
-     - lowest minima between consecutive local maxima (locmaxmin),
-     - lowest minima between consecutive local maxima of original spectrum (locmaxminf),
-
-
-     Regularized version of the spectrum can be obtained by the
-     following methods:
-     - Gaussian filtering (its parameters are filter of width
-       lengthFilter and standard deviation sigmaFilter)scalesp
-     - Average filtering (its parameters are filter of width
-       lengthFilter)
-
-     Note: the detected boundaries are given in term of indices
-
-     Inputs:
-       -f: the function to segment
-     Optional parameters:
-       -log: 0 or 1 to indicate if we want to work with
-                    the log of the ff
-       -reg: 'none','gaussian','average'
-       -lengthFilter: width of the above filters (Gaussian or average)
-       -sigmaFilter: standard deviation of the above Gaussian filter
-       -N: maximum number of supports (modes or signal components)
-       -completion: 0 or 1 to indicate if we try to complete
-                           or not the number of modes if the detection
-                           find a lower number of mode than N
-
-     Outputs:
-       -boundaries: list of detected boundaries
-
-    TODO Preprocessing steps not yet implemented
-    """
-    from scipy.ndimage.filters import gaussian_filter
-    # apply log if needed
-    if log == 1:
-        ff = np.log(ff)
-
-    # Global trend removal - TODO
-
-    # Regularization
-    if reg == 'average':
-        regFilter = np.ones(lengthFilter) / lengthFilter
-        presig = np.convolve(ff, regFilter,
-                             mode='same')  # for even lenght, numpy's convolve is shifted when compared with MATLAB's
-
-    elif reg == 'gaussian':
-        regFilter = np.zeros(lengthFilter)
-        regFilter[regFilter.size // 2] = 1  # prefer odd filter lengths - otherwise the gaussian is skewed
-        presig = np.convolve(ff, gaussian_filter(regFilter, sigmaFilter), mode='same')
-    else:
-        presig = ff
-
-    # Boundaries detection
-    if detect == "locmax":  # Mid-point between two consecutive local maxima computed on the regularized spectrum
-        boundaries = LocalMax(presig, N)
-
-    elif detect == "locmaxmin":  # extract the lowest local minima between two selected local maxima
-        boundaries = LocalMaxMin(presig, N)
-
-    elif detect == "locmaxminf":  # We extract the lowest local minima on the original spectrum between
-        # two local maxima selected on the regularized signal
-        boundaries = LocalMaxMin(presig, N, fm=ff)
-
-    # elif detect == "adaptivereg": #TODO
-
-    return boundaries + 1
-
-
-def LocalMax(ff, N):
-    """
-    ================================================================
-    bound = LocalMax(f,N)
-
-    This function segments f into a maximum of N supports by taking
-    the middle point between the N largest local maxima.
-    Note: the detected boundaries are given in term of indices
-
-    Inputs:
-      -f: the function to segment
-      -N: maximal number of bands
-
-    Outputs:
-      -bound: list of detected boundaries
-
-    Original MATLAB version:
-    Author: Jerome Gilles + Kathryn Heal
-    Institution: UCLA - Department of Mathematics
-    Year: 2013
-    Version: 1.0
-
-    Python Version: Vinícius Rezende Carvalho - vrcarva@ufmg.br
-    Universidade Federal de Minas Gerais - Brasil
-    Núcleo de Neurociências
-    %===============================================================
-    """
-    N = N - 1
-    locmax = np.zeros(ff.size)
-    locmin = max(ff) * np.ones(ff.size)
-    for i in np.arange(1, ff.size - 1):
-        if ff[i - 1] < ff[i] and ff[i] > ff[i + 1]:
-            locmax[i] = ff[i]
-        if ff[i - 1] > ff[i] and ff[i] <= ff[i + 1]:
-            locmin[i] = ff[i]
-    N = min(N, locmax.size)
-    # keep the N-th highest maxima
-    maxidxs = np.sort(locmax.argsort()[::-1][:N])
-    # middle point between consecutive maxima
-    bound = np.zeros(N)
-    for i in range(N):
-        if i == 0:
-            a = 0
-        else:
-            a = maxidxs[i - 1]
-        bound[i] = (a + maxidxs[i]) / 2
-
-    return bound
-
-
-def LocalMaxMin(f, N, fm=0):
-    """
-    ===================================================================
-     bound = LocalMaxMin(f,N,fm)
-
-     This function segments f into a maximum of N supports by detecting
-     the lowest local minima between the N largest local maxima. If the
-     input fm is provided then the local maxima are computed on f and
-     the local minima on fm otherwise both are computed on f (this is
-     useful if you want to compute the maxima on a regularized version
-     of your signal while detecting the "true" minima).
-
-     Note: the detected boundaries are given in term of indices
-
-     Inputs:
-       -f: the function to segment
-       -N: maximal number of bands
-
-     Optional input:
-       -fm: function on which the local minima will be computed
-
-     Outputs:
-       -bound: list of detected boundaries
-
-     Author: Jerome Gilles
-     Institution: UCLA - Department of Mathematics
-     Year: 2013
-     Version: 2.0
-
-     Python Version: Vinícius Rezende Carvalho - vrcarva@ufmg.br
-     Universidade Federal de Minas Gerais - Brasil
-     Núcleo de Neurociências
-    ===================================================================
-    """
-    locmax = np.zeros(f.size)
-    if type(fm) == int:
-        f2 = f
-    else:
-        f2 = fm
-    locmin = max(f2) * np.ones(f2.size)
-    # detect local minima and maxima
-    for i in np.arange(1, f.size - 1):
-        if (f[i - 1] < f[i]) and (f[i] > f[i + 1]):
-            locmax[i] = f[i]
-        if (f2[i - 1] > f2[i]) and (f2[i] < f2[i + 1]):
-            locmin[i] = f2[i]
-    # keep the N-th highest maxima and their index
-    bound = np.zeros(N)
-    if N != -1:
-        N = N - 1
-        # keep the N-th highest maxima
-        Imax = np.sort(locmax.argsort()[::-1][:N])
-        # detect the lowest minima between two consecutive maxima
-        for i in range(N):
-            if i == 0:
-                a = 1
-            else:
-                a = Imax[i - 1]
-            lmin = np.sort(locmin[a:Imax[i]])
-            ind = np.argsort(locmin[a:Imax[i]])
-            tmpp = lmin[0]
-            n = 0
-            if n < len(lmin):
-                n = 1
-                while ((n < len(lmin)) and (tmpp == lmin[n])):
-                    n = n + 1
-            bound[i] = a + ind[n // 2] - 1
-    else:
-        k = 0
-        for i in range(locmin):
-            if locmin[i] < max(f2):
-                bound[k] = i - 1
-                k = k + 1
-    return bound
-
-
-# TODO def Adaptive_Bounds_Adapt():
-
-
-def EWT_Boundaries_Completion(boundaries, NT):
-    """
-    ======================================================================
-    boundaries=EWT_Boundaries_Completion(boundaries,NT)
-
-    This function permits to complete the boundaries vector to get a
-    total of NT boundaries by equally splitting the last band (highest
-    frequencies)
-
-    Inputs:
-      -boundaries: the boundaries vector you want to complete
-      -NT: the total number of boundaries wanted
-
-    Output:
-      -boundaries: the completed boundaries vector
-
-    Author: Jerome Gilles
-    Institution: UCLA - Department of Mathematics
-    Year: 2013
-    Version: 1.0
-
-    Python Version: Vinícius Rezende Carvalho - vrcarva@ufmg.br
-    Universidade Federal de Minas Gerais - Brasil
-    Núcleo de Neurociências
-    %======================================================================
-    """
-    Nd = NT - len(boundaries)
-    deltaw = (np.pi - boundaries[-1]) / (Nd + 1)
-    for k in range(Nd):
-        boundaries = np.append(boundaries, boundaries[-1] + deltaw)
-
-
-def EWT_Meyer_FilterBank(boundaries, Nsig):
-    """
-     =========================================================================
-     function mfb=EWT_Meyer_FilterBank(boundaries,Nsig)
-
-     This function generate the filter bank (scaling function + wavelets)
-     corresponding to the provided set of frequency segments
-
-     Input parameters:
-       -boundaries: vector containing the boundaries of frequency segments (0
-                    and pi must NOT be in this vector)
-       -Nsig: signal length
-
-     Output:
-       -mfb: cell containing each filter (in the Fourier domain), the scaling
-             function comes first and then the successive wavelets
-
-     Author: Jerome Gilles
-     Institution: UCLA - Department of Mathematics
-     Year: 2012
-     Version: 1.0
-
-     Python Version: Vinícius Rezende Carvalho - vrcarva@ufmg.br
-     Universidade Federal de Minas Gerais - Brasil
-     Núcleo de Neurociências
-     =========================================================================
-     """
-    Npic = len(boundaries)
-    # compute gamma
-    gamma = 1
-    for k in range(Npic - 1):
-        r = (boundaries[k + 1] - boundaries[k]) / (boundaries[k + 1] + boundaries[k])
-        if r < gamma:
-            gamma = r
-    r = (np.pi - boundaries[Npic - 1]) / (np.pi + boundaries[Npic - 1])
-    if r < gamma:
-        gamma = r
-    gamma = (1 - 1 / Nsig) * gamma  # this ensure that gamma is chosen as strictly less than the min
-
-    mfb = np.zeros([Nsig, Npic + 1])
-
-    # EWT_Meyer_Scaling
-    Mi = int(np.floor(Nsig / 2))
-    w = np.fft.fftshift(np.linspace(0, 2 * np.pi - 2 * np.pi / Nsig, num=Nsig))
-    w[0:Mi] = -2 * np.pi + w[0:Mi]
-    aw = abs(w)
-    yms = np.zeros(Nsig)
-    an = 1. / (2 * gamma * boundaries[0])
-    pbn = (1. + gamma) * boundaries[0]
-    mbn = (1. - gamma) * boundaries[0]
-    for k in range(Nsig):
-        if aw[k] <= mbn:
-            yms[k] = 1
-        elif ((aw[k] >= mbn) and (aw[k] <= pbn)):
-            yms[k] = np.cos(np.pi * EWT_beta(an * (aw[k] - mbn)) / 2)
-    yms = np.fft.ifftshift(yms)
-    mfb[:, 0] = yms
-
-    # generate rest of the wavelets
-    for k in range(Npic - 1):
-        mfb[:, k + 1] = EWT_Meyer_Wavelet(boundaries[k], boundaries[k + 1], gamma, Nsig)
-
-    mfb[:, Npic] = EWT_Meyer_Wavelet(boundaries[Npic - 1], np.pi, gamma, Nsig)
-
-    return mfb
-
-
-def EWT_beta(x):
-    """
-    Beta = EWT_beta(x)
-    function used in the construction of Meyer's wavelet
-    """
-    if x < 0:
-        bm = 0
-    elif x > 1:
-        bm = 1
-    else:
-        bm = (x ** 4) * (35. - 84. * x + 70. * (x ** 2) - 20. * (x ** 3))
-    return bm
-
-
-def EWT_Meyer_Wavelet(wn, wm, gamma, Nsig):
-    """
-    =========================================================
-    ymw=EWT_Meyer_Wavelet(wn,wm,gamma,N)
-
-    Generate the 1D Meyer wavelet in the Fourier
-    domain associated to scale segment [wn,wm]
-    with transition ratio gamma
-
-    Input parameters:
-      -wn : lower boundary
-      -wm : upper boundary
-      -gamma : transition ratio
-      -N : number of point in the vector
-
-    Output:
-      -ymw: Fourier transform of the wavelet on the band [wn,wm]
-
-    Author: Jerome Gilles
-    Institution: UCLA - Department of Mathematics
-    Year: 2012
-    Version: 1.0
-
-    Python Version: Vinícius Rezende Carvalho - vrcarva@ufmg.br
-    Universidade Federal de Minas Gerais - Brasil
-    Núcleo de Neurociências
-    ==========================================================
-    """
-    Mi = int(np.floor(Nsig / 2))
-    w = np.fft.fftshift(np.linspace(0, 2 * np.pi - 2 * np.pi / Nsig, num=Nsig))
-    w[0:Mi] = -2 * np.pi + w[0:Mi]
-    aw = abs(w)
-    ymw = np.zeros(Nsig)
-    an = 1. / (2 * gamma * wn)
-    am = 1. / (2 * gamma * wm)
-    pbn = (1. + gamma) * wn
-    mbn = (1. - gamma) * wn
-    pbm = (1. + gamma) * wm
-    mbm = (1. - gamma) * wm
-
-    for k in range(Nsig):
-        if ((aw[k] >= pbn) and (aw[k] <= mbm)):
-            ymw[k] = 1
-        elif ((aw[k] >= mbm) and (aw[k] <= pbm)):
-            ymw[k] = np.cos(np.pi * EWT_beta(am * (aw[k] - mbm)) / 2)
-        elif ((aw[k] >= mbn) and (aw[k] <= pbn)):
-            ymw[k] = np.sin(np.pi * EWT_beta(an * (aw[k] - mbn)) / 2)
-
-    ymw = np.fft.ifftshift(ymw)
-    return ymw