PySDKit 0.4.17__tar.gz → 0.4.18__tar.gz

{pysdkit-0.4.17 → pysdkit-0.4.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PySDKit
-Version: 0.4.17
+Version: 0.4.18
 Summary: A Python library for signal decomposition algorithms with a unified interface.
 Home-page: https://github.com/wwhenxuan/PySDKit
 Author: whenxuan

{pysdkit-0.4.17 → pysdkit-0.4.18}/PySDKit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PySDKit
-Version: 0.4.17
+Version: 0.4.18
 Summary: A Python library for signal decomposition algorithms with a unified interface.
 Home-page: https://github.com/wwhenxuan/PySDKit
 Author: whenxuan

{pysdkit-0.4.17 → pysdkit-0.4.18}/PySDKit.egg-info/SOURCES.txt

@@ -22,6 +22,9 @@ pysdkit/_emd2d/__init__.py
 pysdkit/_emd2d/bemd.py
 pysdkit/_emd2d/bmemd.py
 pysdkit/_emd2d/emd2d.py
+pysdkit/_emd/hht/__init__.py
+pysdkit/_emd/hht/frequency.py
+pysdkit/_emd/hht/hht.py
 pysdkit/_esmd/__init__.py
 pysdkit/_esmd/esmd.py
 pysdkit/_ewt/__init__.py

{pysdkit-0.4.17 → pysdkit-0.4.18}/pysdkit/__init__.py

@@ -2,43 +2,7 @@
 A Python library for signal decomposition algorithms.
 """
 
-__version__ = "0.4.16"
-
-__all__ = [
-    "EMD",
-    "EEMD",
-    "CEEMDAN",
-    "REMD",
-    "MEMD",
-    "TVF_EMD",
-    "EFD",
-    "FAEMD",
-    "EMD2D",
-    "HVD",
-    "ITD",
-    "LMD",
-    "RLMD",
-    "SSA",
-    "vmd",
-    "VMD",
-    "ACMD",
-    "MVMD",
-    "VME",
-    "CVMD2D",
-    "VNCMD",
-    "INCMD",
-    "ewt",
-    "EWT",
-    "JMD",
-    "Moving_Decomp",
-    "data",
-    "entropy",
-    "hht",
-    "plot",
-    "tsa",
-    "utils",
-    "__version__",
-]
+__version__ = "0.4.18"
 
 # Empirical Mode Decomposition
 from ._emd import EMD
@@ -79,16 +43,16 @@ from ._lmd import LMD
 # Robust Local Mean Decomposition
 from ._lmd import RLMD
 
-# Singular Spectral Analysis (SSA) algorithm
+# Singular Spectral Analysis
 from ._ssa import SSA
 
-# Variational mode decomposition
+# Variational Mode Decomposition
 from ._vmd import vmd, VMD
 
 # Adaptive Chirp Mode Decomposition
 from ._vmd import ACMD
 
-# Multivariate Variational mode decomposition
+# Multivariate Variational Mode Decomposition
 from ._vmd import MVMD
 
 # Variational Mode Extraction, to extract a specific mode from the signal
@@ -103,7 +67,7 @@ from ._vmd2d import CVMD2D
 # Variational Nonlinear Chirp Mode Decomposition
 from ._vncmd import VNCMD
 
-# Iterative nonlinear chirp mode decomposition
+# Iterative Nonlinear Chirp Mode Decomposition
 from ._vncmd import INCMD
 
 # Empirical Wavelet Transform
@@ -112,9 +76,12 @@ from ._ewt import ewt, EWT
 # Jump Plus AM-FM Mode Decomposition
 from ._jmd import JMD
 
-# Moving Average decomposition
+# Moving Average Decomposition
 from .tsa import Moving_Decomp
 
+# Hilbert-Huang Transform
+from ._emd import HHT
+
 
 def greet():
     print(
@@ -130,3 +97,79 @@ A Python library for signal decomposition algorithms.
 https://github.com/wwhenxuan/PySDKit
 """
     )
+
+
+def print_functions():
+    """"""
+    print(
+        """
+_______________________________________________________________
+Algorithm Name                                  | Abbreviation
+_______________________________________________________________
+Empirical Mode Decomposition                    |    EMD
+Ensemble Empirical Mode Decomposition           |    EEMD     
+Complete Ensemble EMD with Adaptive Noise       |    CEEMDAN
+Robust Empirical Mode Decomposition             |    REMD
+Multivariate Empirical Mode Decomposition       |    MEMD
+Time Varying Filter based EMD                   |    TVF_EMD
+Empirical Fourier Decomposition                 |    EFD
+Fast and Adaptive Empirical Mode Decomposition  |    FAEMD
+Empirical Mode Decomposition 2D for images      |    EMD2D
+Hilbert Vibration Decomposition                 |    HVD
+Intrinsic Time-Scale Decomposition              |    ITD
+Local Mean Decomposition                        |    LMD
+Robust Local Mean Decomposition                 |    RLMD
+Singular Spectral Analysis                      |    SSA
+Variational Mode Decomposition                  |    VMD
+Multivariate Variational Mode Decomposition     |    MVMD
+Variational Mode Extraction                     |    VME
+Variational Mode Decomposition for 2D Image     |    VMD2D
+Compact VMD for 2D Image                        |    CVMD2D
+Variational Nonlinear Chirp Mode Decomposition  |    VNCMD
+Iterative Nonlinear Chirp Mode Decomposition    |    INCMD
+Empirical Wavelet Transform                     |    EWT
+Jump Plus AM-FM Mode Decomposition              |    JMD
+Moving Average Decomposition                    |    Moving
+Hilbert-Huang Transform                         |    HHT
+_______________________________________________________________
+"""
+    )
+
+
+__all__ = [
+    "EMD",
+    "EEMD",
+    "CEEMDAN",
+    "REMD",
+    "MEMD",
+    "TVF_EMD",
+    "EFD",
+    "FAEMD",
+    "EMD2D",
+    "HVD",
+    "ITD",
+    "LMD",
+    "RLMD",
+    "SSA",
+    "vmd",
+    "VMD",
+    "ACMD",
+    "MVMD",
+    "VME",
+    "CVMD2D",
+    "VNCMD",
+    "INCMD",
+    "ewt",
+    "EWT",
+    "JMD",
+    "Moving_Decomp",
+    "data",
+    "entropy",
+    "HHT",
+    "plot",
+    "tsa",
+    "utils",
+    "greet",
+    "print_functions",
+    "__version__",
+]

{pysdkit-0.4.17 → pysdkit-0.4.18}/pysdkit/_emd/__init__.py

@@ -23,3 +23,5 @@ from .memd import MEMD
 from .tvf_emd import TVF_EMD
 
 from .efd import EFD
+
+from .hht import HHT

pysdkit-0.4.18/pysdkit/_emd/hht/__init__.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+"""
+Created on 2025/02/06 10:28:59
+@author: Whenxuan Wang
+@email: wwhenxuan@gmail.com
+"""
+from .hht import HHT

pysdkit-0.4.18/pysdkit/_emd/hht/frequency.py

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+"""
+Created on 2025/02/06 10:30:01
+@author: Whenxuan Wang
+@email: wwhenxuan@gmail.com
+Hilbert-transform for demodulation
+"""
+import numpy as np
+from pysdkit.utils import fft, ifft
+
+
+def hilbert(signal: np.ndarray) -> np.ndarray:
+    """
+    Perform Hilbert transform along the last axis of input signal.
+
+    :param signal: The Hilbert transform is performed along last dimension.
+
+    :return: A complex tensor with the same shape of the input signal, representing its analytic signal.
+    """
+    signal = np.asarray(signal, dtype=np.float64)
+
+    # Get the length of input signal
+    N = signal.shape[-1]
+
+    # Perform a Fast Fourier Transform
+    Xf = fft(signal)
+
+    # Get the spectrum of the analytical signal
+    if N % 2 == 0:
+        Xf[..., 1 : N // 2] *= 2
+        Xf[..., N // 2 + 1 :] = 0
+    else:
+        Xf[..., 1 : (N + 1) // 2] *= 2
+        Xf[..., (N + 1) // 2 :] = 0
+    return ifft(Xf)
+
+
+def get_envelope_frequency(signal: np.ndarray, fs: float, ret_analytic: bool = False):
+    """
+    Compute the envelope and instantaneous frequency function of the given signal using Hilbert transform.
+    The transformation is done along the last axis.
+
+    Parameters:
+    -------------
+    x : array_like
+        Signal data. The last dimension of `x` is considered the temporal dimension.
+    fs : float
+        Sampling frequency in Hz.
+    ret_analytic : bool, optional
+        Whether to return the analytic signal. (Default: False)
+
+    Returns:
+    -------------
+    (envelope, freq)             if `ret_analytic` is False
+    (envelope, freq, analytic)   if `ret_analytic` is True
+
+    envelope : ndarray
+        The envelope function with the same shape as `x`.
+    freq : ndarray
+        The instantaneous frequency function in Hz with the same shape as `x`.
+    analytic : ndarray
+        The analytic (complex) signal with the same shape as `x`.
+    :param signal: Signal data. The last dimension is considered the temporal dimension.
+    :param fs: Sampling frequency in Hz.
+    :param ret_analytic: Whether to return the analytic signal. (Default: False)
+
+    :return: (envelope, freq) if `ret_analytic` is False
+             (envelope, freq, analytic)   if `ret_analytic` is True
+             - envelope : ndarray, the envelope function with the same shape as `x`.
+    freq : ndarray
+        The instantaneous frequency function in Hz with the same shape as `x`.
+    analytic : ndarray
+        The analytic (complex) signal with the same shape as `x`.
+    """
+    signal = np.asarray(signal, dtype=np.float64)
+    analytic = hilbert(signal)  # Scipy's hilbert returns analytic signal
+
+    envelope = np.abs(analytic)
+
+    # Compute sub (discrete derivative with edge extension)
+    sub = np.empty_like(analytic)
+    diff = np.diff(analytic, axis=-1)
+    sub[..., :-1] = diff
+    # Handle last element (repeat last difference)
+    sub[..., -1] = (
+        analytic[..., -1] - analytic[..., -2] if analytic.shape[-1] >= 2 else 0.0
+    )
+
+    # Compute add (discrete sum with edge extension)
+    add = np.empty_like(analytic)
+    summed = analytic[..., 1:] + analytic[..., :-1]
+    add[..., :-1] = summed
+    # Handle last element (2 * last value)
+    add[..., -1] = 2 * analytic[..., -1]
+
+    # Calculate instantaneous frequency (handle division safely)
+    with np.errstate(divide="ignore", invalid="ignore"):
+        freq = 2 * fs * np.imag(sub / add)
+    freq[np.isinf(freq)] = 0  # Replace infs
+    freq /= 2 * np.pi  # Convert to Hz
+
+    if ret_analytic:
+        return envelope, freq, analytic
+    else:
+        return envelope, freq

pysdkit-0.4.18/pysdkit/_emd/hht/hht.py

@@ -0,0 +1,251 @@
+# -*- coding: utf-8 -*-
+"""
+Created on 2025/02/06 10:29:05
+@author: Whenxuan Wang
+@email: wwhenxuan@gmail.com
+"""
+import numpy as np
+from matplotlib import pyplot as plt
+
+from typing import Optional, Tuple, Any
+
+from pysdkit.plot import plot_IMFs, plot_HilbertSpectrum
+from pysdkit.utils import (
+    hilbert_real,
+    hilbert_imaginary,
+    hilbert_transform,
+    hilbert_spectrum,
+)
+from pysdkit._emd import EMD, REMD, EEMD, CEEMDAN
+from pysdkit._emd.hht.frequency import get_envelope_frequency
+
+
+class HHT(object):
+    """Perform Hilbert-Huang transform on the input signal"""
+
+    def __init__(
+        self,
+        algorithm: Optional[str] = "EMD",
+        max_imfs: Optional[int] = -1,
+    ) -> None:
+        """
+        :param algorithm: Type of Empirical Mode Decomposition algorithm used, (EMD, REMD, CEEMDAN)
+        :param max_imfs: maximum number of the IMFs to be decomposed.
+        """
+        self.algorithm = algorithm
+        self.max_imfs = max_imfs
+
+        self.emd = self._get_emd()
+
+        # Store original signal and sampling frequency
+        self.signal, self.fs = None, None
+        # Storing decomposition results
+        self.imfs, self.imfs_env, self.imfs_freq = None, None, None
+
+    def __call__(
+        self,
+        signal: np.ndarray,
+        fs: Optional[float] = None,
+        return_all: Optional[bool] = False,
+    ) -> np.ndarray | Tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Perform Hilbert-Huang transform on the signal `x`, and return the amplitude and
+        instantaneous frequency function of each intrinsic mode.
+
+        :param signal: the input signal of Numpy 1D array.
+        :param fs: Sampling frequencies in Hz.
+        :param return_all: Whether to return all results
+
+        :return: The intrinsic mode function and other information obtained by Hilbert-Huang transform
+        """
+        return self.fit_transform(signal, fs, return_all=return_all)
+
+    def __str__(self) -> str:
+        """Get the full name and abbreviation of the algorithm"""
+        return "Hilbert-Huang Transform (HHT)"
+
+    def _get_emd(self) -> EMD | REMD | EEMD | CEEMDAN:
+        """选择对应的经验模态分解算法"""
+        if self.algorithm == "EMD":
+            return EMD(max_imfs=self.max_imfs)
+        elif self.algorithm == "REMD":
+            return REMD(max_imfs=self.max_imfs)
+        elif self.algorithm == "EEMD":
+            return EEMD(self.max_imfs)
+        elif self.algorithm == "CEEMDAN":
+            return CEEMDAN(self.max_imfs)
+        else:
+            raise ValueError("algorithm must be EMD, REMD, EEMD or CEEMDAN!")
+
+    def save_decompsition(
+        self,
+        signal: np.ndarray,
+        fs: float,
+        imfs: np.ndarray,
+        imfs_env: np.ndarray,
+        imfs_freq: np.ndarray,
+    ) -> None:
+        """
+        Record the results of this Hilbert-Huang transform
+
+        :param imfs: The intrinsic mode functions obtained by decomposing the signal.
+        :param signal: Input Numpy signal.
+        :param fs: Sampling frequency of the input signal.
+        :param imfs_env: Envelope spectrum of the intrinsic mode function.
+        :param imfs_freq: Frequency of the intrinsic mode function.
+
+        :return: None
+        """
+        self.signal = signal
+        self.fs = fs
+        self.imfs = imfs
+        self.imfs_freq = imfs_freq
+        self.imfs_env = imfs_env
+
+    def fit_transform(
+        self,
+        signal: np.ndarray,
+        fs: Optional[float] = None,
+        return_all: Optional[bool] = False,
+    ) -> np.ndarray | Tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Perform Hilbert-Huang transform on the signal `x`, and return the amplitude and
+        instantaneous frequency function of each intrinsic mode.
+
+        :param signal: the input signal of Numpy 1D array.
+        :param fs: Sampling frequencies in Hz.
+        :param return_all: Whether to return all results
+
+        :return: The intrinsic mode function and other information obtained by Hilbert-Huang transform
+        """
+        # Using the empirical mode decomposition algorithm to obtain the intrinsic mode function
+        imfs = self.emd.fit_transform(signal)
+        # Analyze the envelope spectrum frequency characteristics of each mode
+        imfs_env, imfs_freq = get_envelope_frequency(imfs, fs=fs)
+
+        # Save the result of this Hilbert-Huang transform
+        self.save_decompsition(
+            signal=signal, fs=fs, imfs=imfs, imfs_env=imfs_env, imfs_freq=imfs_freq
+        )
+
+        if return_all is True:
+            return imfs, imfs_env, imfs_freq
+        return imfs
+
+    def plot_IMFs(
+        self, signal: Optional[np.ndarray] = None, imfs: Optional[np.ndarray] = None
+    ) -> plt.Figure:
+        """
+        Visualize the decomposition results.
+
+        :param signal: The NumPy signal to be visualized.
+        :param imfs: The intrinsic mode functions obtained by decomposing the signal to be visualized.
+
+        :return: Pyplot drawing Figure object in Matplotlib
+        """
+
+        # Get the original signal and the decomposed result
+        signal = signal if signal is not None else self.signal
+        imfs = imfs if imfs is not None else self.imfs
+
+        # Handling exception information
+        if signal is None:
+            raise ValueError(
+                "Please input the result after Hilbert-Huang transform or execute the `fit_transform` method once to record the decomposition result!"
+            )
+
+        # Visualize the decomposed intrinsic mode functions
+        figure = plot_IMFs(signal, imfs, return_figure=True)
+
+        return figure
+
+    def hilbert_spectrum(
+        self,
+        imfs_env: Optional[np.ndarray] = None,
+        imfs_freq: Optional[np.ndarray] = None,
+        fs: Optional[float] = None,
+        freq_lim: Optional[tuple[float, float]] = None,
+        freq_res: Optional[float] = None,
+        time_scale: int = 1,
+    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """
+         Compute the Hilbert spectrum H(t, f) using numpy.
+
+        :param imfs_env: The envelope functions of all IMFs.
+        :param imfs_freq: The instantaneous frequency functions.
+        :param fs: Sampling frequency in Hz.
+        :param freq_lim: Frequency range (min, max). Defaults to (0, fs/2).
+        :param time_scale: Frequency resolution. Defaults to (freq_max - freq_min)/200.
+        :param freq_res: Temporal scaling factor (Default: 1).
+
+        :return: (spectrum, time_axis, freq_axis)
+                 - spectrum : ndarray, shape (..., time_bins, freq_bins), Hilbert spectrum matrix
+                 - time_axis : ndarray, 1D, Time axis labels
+                 - freq_axis : ndarray, 1D, Frequency axis labels
+        """
+        # Read the results saved during the decomposition process
+        imfs_env = imfs_env if imfs_env is not None else self.imfs_env
+        imfs_freq = imfs_freq if imfs_freq is not None else self.imfs_freq
+        fs = fs if fs is not None else self.fs
+
+        # Compute the Hilbert spectrum
+        spectrum, t, f = hilbert_spectrum(
+            imfs_env=imfs_env,
+            imfs_freq=imfs_freq,
+            fs=fs,
+            freq_lim=freq_lim,
+            time_scale=time_scale,
+            freq_res=freq_res,
+        )
+        return spectrum, t, f
+
+    def plot_spectrum(
+        self,
+        imfs_env: Optional[np.ndarray] = None,
+        imfs_freq: Optional[np.ndarray] = None,
+        fs: Optional[float] = None,
+        freq_lim: Optional[tuple[float, float]] = None,
+        freq_res: Optional[float] = None,
+        time_scale: int = 1,
+    ) -> tuple[list[Any] | Any, list[Any]] | list[Any] | Any:
+        """
+        Obtaining and visualizing the Hilbert spectrum.
+
+        :param imfs_env: The envelope functions of all IMFs.
+        :param imfs_freq: The instantaneous frequency functions.
+        :param fs: Sampling frequency in Hz.
+        :param freq_lim: Frequency range (min, max). Defaults to (0, fs/2).
+        :param freq_res: Frequency resolution. Defaults to (freq_max - freq_min)/200.
+        :param time_scale: Temporal scaling factor (Default: 1).
+
+        :return: The plotting results.
+        """
+        # Read the results saved during the decomposition process
+        imfs_env = imfs_env if imfs_env is not None else self.imfs_env
+        imfs_freq = imfs_freq if imfs_freq is not None else self.imfs_freq
+
+        # Get the Hilbert spectrum
+        spectrum, t, f = self.hilbert_spectrum(
+            imfs_env=imfs_env,
+            imfs_freq=imfs_freq,
+            fs=fs,
+            freq_lim=freq_lim,
+            time_scale=time_scale,
+            freq_res=freq_res,
+        )
+        return plot_HilbertSpectrum(spectrum, t, f)
+
+
+if __name__ == "__main__":
+    from pysdkit.data import test_hht
+
+    t, s = test_hht()
+    fs = 1000
+
+    hht = HHT(max_imfs=4)
+
+    imfs, imfs_env, imfs_freq = hht.fit_transform(s, fs=fs, return_all=True)
+    plot_IMFs(s, imfs)
+    hht.hilbert_spectrum()
+    hht.plot_spectrum(imfs_env=imfs_env, imfs_freq=imfs_freq)
+    plt.show()

{pysdkit-0.4.17 → pysdkit-0.4.18}/pysdkit/_vncmd/incmd.py

@@ -6,6 +6,7 @@ Created on 2025/02/12 12:31:39
 """
 import numpy as np
 from scipy import linalg
+
 try:
     from scipy.integrate import cumulative_trapezoid
 except ImportError:

{pysdkit-0.4.17 → pysdkit-0.4.18}/pysdkit/_vncmd/vncmd.py

@@ -9,6 +9,7 @@ MATLAB code source https://www.mathworks.com/matlabcentral/fileexchange/64292-va
 import numpy as np
 from numpy.linalg import solve, norm
 from scipy.sparse import diags, eye
+
 try:
     from scipy.integrate import cumulative_trapezoid
 except ImportError:
@@ -199,10 +200,12 @@ class VNCMD(Base):
         # Initialize the variables defined above through loops
         for i in range(K):
             sinm[i, :] = np.sin(
-                2 * np.pi * cumulative_trapezoid(eIF[i, :], t, initial=0), dtype=self.DTYPE
+                2 * np.pi * cumulative_trapezoid(eIF[i, :], t, initial=0),
+                dtype=self.DTYPE,
             )
             cosm[i, :] = np.cos(
-                2 * np.pi * cumulative_trapezoid(eIF[i, :], t, initial=0), dtype=self.DTYPE
+                2 * np.pi * cumulative_trapezoid(eIF[i, :], t, initial=0),
+                dtype=self.DTYPE,
             )
 
             Bm = diags(

{pysdkit-0.4.17 → pysdkit-0.4.18}/pysdkit/data/__init__.py

@@ -17,9 +17,12 @@ from ._generator import generate_am_signal, generate_exponential_signal
 # Generator for 1D univariate time series data
 from ._time_series import generate_time_series
 
-# Generates the main test sample signal
+# Generate the main test sample signal
 from ._generator import test_emd
 
+# Generate the test function for HHT
+from ._generator import test_hht
+
 # Generator for 1D univariate
 from ._generator import test_univariate_signal
 

{pysdkit-0.4.17 → pysdkit-0.4.18}/pysdkit/data/_generator.py

@@ -5,7 +5,7 @@ Created on Sat Mar 8 21:45:02 2024
 @email: wwhenxuan@gmail.com
 """
 import numpy as np
-from scipy.signal import sawtooth
+from scipy.signal import sawtooth, chirp
 from matplotlib import pyplot as plt
 
 from typing import Tuple, Optional
@@ -338,6 +338,24 @@ def test_emd(
     return t, noise_signal
 
 
+def test_hht(duration: float = 2.0, sampling_rate: int = 1000):
+    """
+    Generate data generation function to verify Hilbert-Huang transform.
+
+    :param duration: Length of the signal in seconds.
+    :param sampling_rate: Number of samples per second.
+
+    :return: Tuple of time array and signal for hht testing.
+    """
+    # Generate a sequence of time-stamped samples
+    time = np.arange(sampling_rate * duration) / sampling_rate
+    # Generate the signal to be decomposed
+    signal = chirp(time, 5, 0.8, 10, method="quadratic", phi=100) * np.exp(
+        -4 * (time - 1) ** 2
+    ) + chirp(time, 40, 1.2, 50, method="linear") * np.exp(-4 * (time - 1) ** 2)
+    return time, signal
+
+
 def test_multivariate_signal(
     case: int = 1,
     duration: float = 1.0,

{pysdkit-0.4.17 → pysdkit-0.4.18}/pysdkit/plot/__init__.py

@@ -5,17 +5,19 @@ Created on Sat Mar 4 21:31:05 2024
 @email: wwhenxuan@gmail.com
 Some auxiliary function modules for data visualization in the PySDKit library
 """
-# 在二维平面上可视化原输入信号和分解得到的本征模态函数
+# Visualize the original input signal and the decomposed IMFs on a 2D plane
 from ._plot_imfs import plot_IMFs
 
-# 单独绘制分解得到的每个本征模态函数的频谱
+# Plot the spectrum of each decomposed IMF separately
 from ._fourier_spectra import plot_IMFs_amplitude_spectra
 
-# 用于可视化二维灰度图
+# Plotting the Hilbert spectrum
+from ._fourier_spectra import plot_HilbertSpectrum
+
+# Used to visualize two-dimensional grayscale images
 from ._plot_images import plot_grayscale_image, plot_grayscale_spectrum
 
-# 通用的图像可视化函数
-# 可以选择是否绘制频域图谱以及是否添加颜色条
+# General image visualization functions
 from ._plot_images import plot_images
 
 # Functions that generate signal visualizations