PySDKit 0.4.13__tar.gz → 0.4.14__tar.gz

{pysdkit-0.4.13 → pysdkit-0.4.14}/PKG-INFO

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

{pysdkit-0.4.13 → pysdkit-0.4.14}/PySDKit.egg-info/PKG-INFO

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

{pysdkit-0.4.13 → pysdkit-0.4.14}/PySDKit.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ PySDKit.egg-info/top_level.txt
 pysdkit/__init__.py
 pysdkit/data/__init__.py
 pysdkit/data/_add_noise.py
+pysdkit/data/_cube.py
 pysdkit/data/_generator.py
 pysdkit/data/_image.py
 pysdkit/data/_time_series.py
@@ -55,10 +56,14 @@ pysdkit/plot/_fourier_spectra.py
 pysdkit/plot/_functions.py
 pysdkit/plot/_plot_images.py
 pysdkit/plot/_plot_imfs.py
+pysdkit/plot/_plot_signal.py
 pysdkit/ssa/__init__.py
 pysdkit/ssa/ssa.py
 pysdkit/tsa/__init__.py
+pysdkit/tsa/_dtw.py
 pysdkit/tsa/_moving_decomp.py
+pysdkit/tsa/mstl.py
+pysdkit/tsa/stl.py
 pysdkit/utils/_Index_of_Orthogonality.py
 pysdkit/utils/__init__.py
 pysdkit/utils/_cite.py

{pysdkit-0.4.13 → pysdkit-0.4.14}/pysdkit/data/__init__.py

@@ -14,17 +14,17 @@ from ._generator import (
 )
 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
 from ._generator import test_emd
 
 # Generator for 1D univariate
-from ._generator import test_uni_signal
+from ._generator import test_univariate_signal
 
 # Generator for 1D multivariate
-from ._generator import test_multi_signal
-
-# Functions that generate signal visualizations
-from ._generator import plot_signal
+from ._generator import test_multivariate_signal
 
 # add Gaussian noise
 from ._add_noise import add_noise
@@ -32,11 +32,14 @@ from ._add_noise import add_noise
 # Test case for loading a 2D grayscale image
 from ._image import test_grayscale
 
-# Test case for univariate image
-from ._image import test_uni_image
+# Test case for univariate 2D image
+from ._image import test_univariate_image
 
-# Test case for multivariate image
-from ._image import test_multi_image
+# Test case for multivariate 2D image
+from ._image import test_multivariate_image
 
-# Generator for 1D univariate time series data
-from ._time_series import generate_time_series
+# Test case for univariate 3D cube
+from ._cube import test_univariate_cube
+
+# Test case for multivariate 3D cube
+from ._cube import test_multivariate_cube

pysdkit-0.4.14/pysdkit/data/_cube.py

@@ -0,0 +1,276 @@
+# -*- coding: utf-8 -*-
+"""
+Created on 2025/02/11 00:19:03
+@author: Whenxuan Wang
+@email: wwhenxuan@gmail.com
+Generate 3D cube test sample
+"""
+import numpy as np
+
+from typing import Optional, Union, Tuple, List
+
+
+def get_meshgrid_3D(
+    low: Union[int, np.ndarray], high: Union[int, np.ndarray], sampling_rate: int = 30
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Generate a grid 3D cube given an input and output range
+    :param low: Minimum value of grid matrix,
+                If it is a ndarray array, its length must be 3 to indicate the range of three dimensions.
+    :param high: Maximum value of grid matrix,
+                If it is a ndarray array, its length must be 3 to indicate the range of three dimensions.
+    :param sampling_rate: The sampling rate of the grid matrix, which is the number of points in the matrix
+    :return: A grid matrix generated from a range in the form of a tuple
+    """
+    # First obtain a one-dimensional range array by specifying the ranges `low` and `high`
+    if isinstance(low, np.ndarray) and isinstance(high, np.ndarray):
+        # Both range parameters are Numpy arrays
+        X = np.linspace(low[0], high[0], sampling_rate)
+        Y = np.linspace(low[1], high[1], sampling_rate)
+        Z = np.linspace(low[2], high[2], sampling_rate)
+
+    elif isinstance(low, np.ndarray) and isinstance(high, int):
+        # `low` is a Numpy array `high` is a constant
+        X = np.linspace(low[0], high, sampling_rate)
+        Y = np.linspace(low[1], high, sampling_rate)
+        Z = np.linspace(low[2], high, sampling_rate)
+
+    elif isinstance(low, int) and isinstance(high, np.ndarray):
+        # `low` is a constant `high` is a Numpy array
+        X = np.linspace(low, high[0], sampling_rate)
+        Y = np.linspace(low, high[1], sampling_rate)
+        Z = np.linspace(low, high[2], sampling_rate)
+
+    elif isinstance(low, int) and isinstance(high, int):
+        # Both range parameters are constants
+        X = np.linspace(low, high, sampling_rate)
+        Y = np.linspace(low, high, sampling_rate)
+        Z = np.linspace(low, high, sampling_rate)
+
+    else:
+        raise TypeError("The params `low` and `high` must be int or ndarray of numpy!")
+
+    # Further generate network cube
+    x, y, z = np.meshgrid(X, Y, Z)
+
+    return x, y, z
+
+
+def test_univariate_cube(
+    case: int = 1,
+    low: Union[int, np.ndarray] = 0,
+    high: Union[int, np.ndarray] = 10,
+    sampling_rate: int = 30,
+) -> np.ndarray:
+    """
+    Generate a 3D cube data for testing 3D univariate signal decomposition algorithms
+
+    :param case: Test case, range in [1, 2, 3, 4, 5, 6]
+    :param low: Minimum value of grid matrix,
+                If it is a ndarray array, its length must be 3 to indicate the range of three dimensions.
+    :param high: Maximum value of grid matrix,
+                If it is a ndarray array, its length must be 3 to indicate the range of three dimensions.
+    :param sampling_rate: The sampling rate of the grid matrix, which is the number of points in the matrix
+    :return: Get a 3D cube data of a specified range
+    """
+    # Generate data based on the input test sample number
+    if case == 1:
+        return test_cube_1(low=low, high=high, sampling_rate=sampling_rate)
+    elif case == 2:
+        return test_cube_2(low=low, high=high, sampling_rate=sampling_rate)
+    elif case == 3:
+        return test_cube_3(low=low, high=high, sampling_rate=sampling_rate)
+    elif case == 4:
+        return test_cube_4(low=low, high=high, sampling_rate=sampling_rate)
+    elif case == 5:
+        return test_cube_5(low=low, high=high, sampling_rate=sampling_rate)
+    elif case == 6:
+        return test_cube_6(low=low, high=high, sampling_rate=sampling_rate)
+    else:
+        raise TypeError("The params `case` must be in the range of [1, 2, 3, 4, 5, 6]")
+
+
+def test_multivariate_cube(
+    case: Union[List[int], Tuple[int], np.ndarray] = None,
+    low: Union[int, np.ndarray] = 0,
+    high: Union[int, np.ndarray] = 10,
+    sampling_rate: int = 30,
+) -> np.ndarray:
+    """
+    Generate 3D cubes data for testing 3D multivariate signal decomposition algorithms
+    :param case: The test cases to use are specified by inputting a list or tuple or ndarray in the range [1, 2, 3, 4, 5, 6],
+                 The default parameter settings are [1, 2, 3].
+    :param low: Minimum value of grid matrix,
+                If it is a ndarray array, its length must be 3 to indicate the range of three dimensions.
+    :param high: Maximum value of grid matrix,
+                If it is a ndarray array, its length must be 3 to indicate the range of three dimensions.
+    :param sampling_rate: The sampling rate of the grid matrix, which is the number of points in the matrix
+    :return: Get 3D cube data of multiple different channels
+    """
+    # Default Parameters
+    if case is None:
+        case = [1, 2, 3]
+    # Make sure it is the correct data type
+    if (
+        isinstance(case, tuple)
+        or isinstance(case, list)
+        or isinstance(case, np.ndarray)
+    ):
+        # Make sure there is content
+        if len(case) >= 1:
+            cubes = np.vstack(
+                [
+                    test_univariate_cube(
+                        case=c, low=low, high=high, sampling_rate=sampling_rate
+                    )
+                    for c in case
+                ]
+            )
+            return cubes
+        else:
+            raise ValueError("The number in `case` must be greater than 1!")
+    else:
+        raise TypeError("The params `case` should be a list or tuple or ndarray!")
+
+
+def test_cube_1(
+    low: Union[int, np.ndarray], high: Union[int, np.ndarray], sampling_rate: int = 30
+) -> np.ndarray:
+    """
+    Generate a 3D cube test example 1
+    :param low: Minimum value of grid matrix
+    :param high: Maximum value of grid matrix
+    :param sampling_rate: The sampling rate of the grid matrix, which is the number of points in the matrix
+    :return: Cube generated by sine and cosine functions
+    """
+    # First generate the grid array
+    x, y, z = get_meshgrid_3D(low=low, high=high, sampling_rate=sampling_rate)
+    # Generate cubes of different frequencies
+    uc1 = np.sin(3.5 * x) + np.sin(3.5 * y) + np.sin(3.5 * z)
+    uc2 = np.sin(x) + np.sin(y) + np.sin(z)
+    ru = np.cos(x / 24) + np.cos(y / 24) + np.cos(z / 24)
+    # Fusion of different modalities
+    u = uc1 + uc2 + ru
+    # Standardize the results of the integration
+    u = (u - np.mean(u)) / np.std(u + 0.01)
+    return u
+
+
+def test_cube_2(
+    low: Union[int, np.ndarray], high: Union[int, np.ndarray], sampling_rate: int = 30
+) -> np.ndarray:
+    """
+    Generate a 3D cube test example 2
+    :param low: Minimum value of grid matrix
+    :param high: Maximum value of grid matrix
+    :param sampling_rate: The sampling rate of the grid matrix, which is the number of points in the matrix
+    :return: Cube generated by sine and cosine functions
+    """
+    # First generate the grid array
+    x, y, z = get_meshgrid_3D(low=low, high=high, sampling_rate=sampling_rate)
+    # Generate cubes of different frequencies
+    uc1 = np.sin(5 * x) + np.sin(5 * y) + np.sin(5 * z)
+    uc2 = np.sin(x) + np.sin(y) + np.sin(z)
+    ru = np.cos(x / 16) + np.cos(y / 16) + np.cos(z / 16)
+    # Fusion of different modalities
+    u = uc1 + uc2 + ru
+    # Standardize the results of the integration
+    u = (u - np.mean(u)) / np.std(u + 0.001)
+    return u
+
+
+def test_cube_3(
+    low: Union[int, np.ndarray], high: Union[int, np.ndarray], sampling_rate: int = 30
+) -> np.ndarray:
+    """
+    Generate a 3D cube test example 3
+    :param low: Minimum value of grid matrix
+    :param high: Maximum value of grid matrix
+    :param sampling_rate: The sampling rate of the grid matrix, which is the number of points in the matrix
+    :return: Cube generated by sine and cosine functions
+    """
+    # First generate the grid array
+    x, y, z = get_meshgrid_3D(low=low, high=high, sampling_rate=sampling_rate)
+    # Generate cubes of different frequencies
+    uc1 = np.sin(2 * x) + np.sin(2 * y) + np.sin(2 * z)
+    uc2 = np.sin(4 * x) + np.sin(4 * y) + np.sin(4 * z)
+    ru = np.cos(x / 24) + np.cos(y / 24) + np.cos(z / 24)
+    # Fusion of different modalities
+    u = uc1 + uc2 + ru
+    # Standardize the results of the integration
+    u = (u - np.mean(u)) / np.std(u + 0.001)
+    return u
+
+
+def test_cube_4(
+    low: Union[int, np.ndarray], high: Union[int, np.ndarray], sampling_rate: int = 30
+) -> np.ndarray:
+    """
+    Generate a 3D cube test example 4
+    :param low: Minimum value of grid matrix
+    :param high: Maximum value of grid matrix
+    :param sampling_rate: The sampling rate of the grid matrix, which is the number of points in the matrix
+    :return: Cube generated by sine and cosine functions
+    """
+    # First generate the grid array
+    x, y, z = get_meshgrid_3D(low=low, high=high, sampling_rate=sampling_rate)
+    # Generate cubes of different frequencies
+    uc1 = np.sin(2 * x**1.5) + np.sin(2 * y**1.5) + np.sin(2 * z * 1.5)
+    uc2 = np.sin(5 * x) + np.sin(5 * y) + np.sin(5 * z)
+    ru = np.cos(x / 24) + np.cos(y / 24) + np.cos(z / 24)
+    # Fusion of different modalities
+    u = uc1 + uc2 + ru
+    # Standardize the results of the integration
+    u = (u - np.mean(u)) / np.std(u + 0.001)
+    return u
+
+
+def test_cube_5(
+    low: Union[int, np.ndarray], high: Union[int, np.ndarray], sampling_rate: int = 30
+) -> np.ndarray:
+    """
+    Generate a 3D cube test example 5
+    :param low: Minimum value of grid matrix
+    :param high: Maximum value of grid matrix
+    :param sampling_rate: The sampling rate of the grid matrix, which is the number of points in the matrix
+    :return: Cube generated by sine and cosine functions
+    """
+    # First generate the grid array
+    x, y, z = get_meshgrid_3D(low=low, high=high, sampling_rate=sampling_rate)
+    # Generate cubes of different frequencies
+    uc1 = np.cos(x**2) + np.cos(y**2) + np.cos(z * 2)
+    uc2 = np.sin(5 * x) + np.sin(5 * y) + np.sin(5 * z)
+    ru = np.cos(x / 24) + np.cos(y / 24) + np.cos(z / 24)
+    # Fusion of different modalities
+    u = uc1 + uc2 + ru
+    # Standardize the results of the integration
+    u = (u - np.mean(u)) / np.std(u + 0.001)
+    return u
+
+
+def test_cube_6(
+    low: Union[int, np.ndarray], high: Union[int, np.ndarray], sampling_rate: int = 30
+) -> np.ndarray:
+    """
+    Generate a 3D cube test example 6
+    :param low: Minimum value of grid matrix
+    :param high: Maximum value of grid matrix
+    :param sampling_rate: The sampling rate of the grid matrix, which is the number of points in the matrix
+    :return: Cube generated by sine and cosine functions
+    """
+    # First generate the grid array
+    x, y, z = get_meshgrid_3D(low=low, high=high, sampling_rate=sampling_rate)
+    # Generate cubes of different frequencies
+    uc1 = np.cos(x**2) + np.cos(y**2) + np.cos(z * 2)
+    uc2 = np.sin(5 * x) + np.sin(5 * y) + np.sin(5 * z)
+    ru = np.cos(x / 24) + np.cos(y / 24) + np.cos(z / 24)
+    # Fusion of different modalities
+    u = uc1 + uc2 + ru
+    # Standardize the results of the integration
+    u = (u - np.mean(u)) / np.std(u + 0.001)
+    return u
+
+
+if __name__ == "__main__":
+    print(test_univariate_cube().shape)
+    print(test_univariate_cube())

{pysdkit-0.4.13 → pysdkit-0.4.14}/pysdkit/data/_generator.py

@@ -8,7 +8,7 @@ import numpy as np
 from scipy.signal import sawtooth
 from matplotlib import pyplot as plt
 
-from typing import Tuple
+from typing import Tuple, Optional
 
 
 def generate_sin_signal(
@@ -198,7 +198,7 @@ def generate_exponential_signal(
     return t, noisy_exp_signal
 
 
-def test_uni_signal(
+def test_univariate_signal(
     case: int = 1,
     duration: float = 1.0,
     sampling_rate: int = 1000,
@@ -254,7 +254,12 @@ def test_1D_2(
     :return: Tuple containing time array and the 3 * 2 ^ (-t) * sin(sin(2 * pi * t)) signal.
     """
     t = np.linspace(0, duration, int(sampling_rate * duration), endpoint=False)
-    signal = 3 * 2 ^ (-t) * np.sin(np.sin(2 * np.pi * t))
+    signal = (
+        3 * 2 ** (-t) * np.sin(np.sin(2 * np.pi * t))
+        + np.cos(2 * np.pi * t * 5)
+        + np.sin(2 * np.pi * (t + 2 * t**2))
+        + np.sin(2 * np.pi * t * 30)
+    )
     return t, signal
 
 
@@ -274,7 +279,13 @@ def test_1D_3(
     """
     np.random.seed(seed=random_state)
     t = np.linspace(0, duration, int(sampling_rate * duration), endpoint=False)
-    signal = 5 * np.sin(2 * np.pi * t) + 3 * np.sin(2 * np.pi * t)
+    signal = (
+        5 * np.sin(2 * np.pi * t)
+        + 3 * np.cos(2 * np.pi * t)
+        + 2 * np.cos(2 * np.pi * t**2)
+        + np.sin(2 * np.pi * t**3)
+        + np.sin(2 * np.pi * (t * 30 + t**2 * 2))
+    )
     noise = np.random.normal(0, noise_level, signal.shape)
     noise_signal = signal + noise
     return t, noise_signal
@@ -302,7 +313,7 @@ def test_emd(
     return t, noise_signal
 
 
-def test_multi_signal(
+def test_multivariate_signal(
     case: int = 1,
     duration: float = 1.0,
     sampling_rate: int = 1000,
@@ -316,18 +327,18 @@ def test_multi_signal(
     :return: the generated signal for multivariate 1D.
     """
     if case == 1:
-        return test_multi_1D_1(duration=duration, sampling_rate=sampling_rate)
+        return test_multivariate_1D_1(duration=duration, sampling_rate=sampling_rate)
     elif case == 2:
-        return test_multi_1D_2(duration=duration, sampling_rate=sampling_rate)
+        return test_multivariate_1D_2(duration=duration, sampling_rate=sampling_rate)
     elif case == 3:
-        return test_multi_1D_3(duration=duration, sampling_rate=sampling_rate)
+        return test_multivariate_1D_3(duration=duration, sampling_rate=sampling_rate)
     else:
         # When there is no such test instance, the function returns `case==1`
         print(f"There is no case {case}, so it will return case==1!")
-        return test_multi_1D_1(duration=duration, sampling_rate=sampling_rate)
+        return test_multivariate_1D_1(duration=duration, sampling_rate=sampling_rate)
 
 
-def test_multi_1D_1(
+def test_multivariate_1D_1(
     duration: float = 1.0, sampling_rate: int = 1000
 ) -> Tuple[np.array, np.array]:
     """
@@ -350,7 +361,7 @@ def test_multi_1D_1(
     return t, signal
 
 
-def test_multi_1D_2(
+def test_multivariate_1D_2(
     duration: float = 1.0, sampling_rate: int = 1000
 ) -> Tuple[np.array, np.array]:
     """
@@ -361,7 +372,6 @@ def test_multi_1D_2(
     """
     np.random.seed(seed=42)
     t = np.linspace(0, duration, int(sampling_rate * duration), endpoint=False)
-    t = np.linspace(0, duration, int(sampling_rate * duration), endpoint=False)
 
     # Generate the multi-channels signals
     signal_1 = (
@@ -391,7 +401,7 @@ def test_multi_1D_2(
     return t, signal
 
 
-def test_multi_1D_3(
+def test_multivariate_1D_3(
     duration: float = 1.0,
     sampling_rate: int = 1000,
     noise_level: float = 0.1,
@@ -445,85 +455,16 @@ def test_multi_1D_3(
     return t, f
 
 
-def plot_signal(
-    t: np.array,
-    signal: np.array,
-    color: str = "royalblue",
-    save: bool = False,
-    dpi: int = 128,
-    fontsize: int = 12,
-) -> plt.figure:
-    """
-    Plot and optionally save an amplitude modulated (AM) signal with time on the x-axis and amplitude on the y-axis.
-    :param t: Array of time points corresponding to the signal.
-    :param signal: Array containing the signal data to be plotted.
-    :param color: Color of the plot line.
-    :param save: Boolean flag to indicate whether the plot should be saved to a file.
-    :param dpi: Dots per inch (resolution) of the figure, if saved.
-    :param fontsize: Font size of the axis labels.
-    :return: The figure object containing the plot.
-    """
-
-    # Determine the number of input signals
-    n_dim = len(signal.shape)
-
-    if n_dim == 1:
-        # Create a figure and a single subplot
-        fig, ax = plt.subplots(figsize=(8, 3))
-
-        # Plot the signal against time with specified line color
-        ax.plot(t, signal, color=color)
-
-        # Set the x-axis label with specified font size
-        ax.set_xlabel("Time (seconds)", fontsize=fontsize)
-
-        # Set the y-axis label with default font size
-        ax.set_ylabel("Amplitude", fontsize=fontsize)
-
-        # Enable grid for better readability
-        ax.grid(True)
-
-    elif n_dim == 2:
-        # Determining the number of multivariate signals
-        n_vars = signal.shape[0]
-
-        # Create a figure and a single subplot
-        fig, ax = plt.subplots(nrows=n_vars, figsize=(10, 1 + 2 * n_vars), sharex=True)
-
-        for i in range(n_vars):
-            # Plot the signal against time with specified line color
-            ax[i].plot(t, signal[i, :], color=color)
-
-            # Set the y-axis label with default font size
-            ax[i].set_ylabel("Amplitude", fontsize=fontsize)
-
-            # Enable grid for better readability
-            ax[i].grid(True)
-
-        # Set the x-axis label with specified font size
-        ax[-1].set_xlabel("Time (seconds)", fontsize=fontsize)
-
-    else:
-        raise ValueError("Wrong input signal, please input the 1D signal.")
-
-    # Check if the figure needs to be saved
-    if save:
-        # Save the figure with the specified dpi and bounding box tightly around the figure
-        fig.savefig("generate_signal.jpg", dpi=dpi, bbox_inches="tight")
-
-    # Return the figure object
-    return fig
-
-
 if __name__ == "__main__":
-    from pysdkit.data import test_emd, plot_signal, test_multi_signal
+    from pysdkit.data import test_emd, test_multivariate_signal
+    from pysdkit.plot import plot_signal
 
-    t, signal = test_uni_signal(case=1)
+    t, signal = test_univariate_signal(case=1)
     print(signal.shape)
 
     fig = plot_signal(t, signal)
 
-    t, signal = test_multi_signal(case=2)
+    t, signal = test_multivariate_signal(case=2)
     print(signal.shape)
 
     fig = plot_signal(t, signal, save=False)

{pysdkit-0.4.13 → pysdkit-0.4.14}/pysdkit/data/_image.py

@@ -46,7 +46,7 @@ def test_grayscale() -> np.ndarray | None:
     return None
 
 
-def get_meshgrid(
+def get_meshgrid_2D(
     low: int = 0, high: int = 10, sampling_rate: Optional[int] = 256
 ) -> Tuple[np.ndarray, np.ndarray]:
     """
@@ -66,7 +66,7 @@ def get_meshgrid(
     return x, y
 
 
-def test_uni_image(
+def test_univariate_image(
     case: int = 1, low: int = 0, high: int = 10, sampling_rate: Optional[int] = 256
 ) -> np.ndarray:
     """
@@ -99,7 +99,7 @@ def test_uni_image(
         return test_grayscale()
 
 
-def test_multi_image(
+def test_multivariate_image(
     case: Tuple = (1, 2, 3),
     low: int = 0,
     high: int = 10,
@@ -139,7 +139,7 @@ def test_multi_image(
 
     # Get multivariate image by sampling univariate function
     images = [
-        test_uni_image(case=c, low=low, high=high, sampling_rate=sampling_rate)[
+        test_univariate_image(case=c, low=low, high=high, sampling_rate=sampling_rate)[
             np.newaxis, :, :
         ]
         for c in c_list
@@ -164,7 +164,7 @@ def test_image_1(
     :return: Generate a 2D image using sin(4x), sin(x) and cos(x/24)
     """
     # Construct the two dim grid matrix
-    x, y = get_meshgrid(low, high, sampling_rate)
+    x, y = get_meshgrid_2D(low, high, sampling_rate)
 
     # Generate a function according to the specified method
     uc1 = np.sin(4 * x) + np.sin(4 * y)
@@ -193,7 +193,7 @@ def test_image_2(
     :return: Generate a mixed image using two-dimensional sine and cosine functions
     """
     # Construct the two dim grid matrix
-    x, y = get_meshgrid(low, high, sampling_rate)
+    x, y = get_meshgrid_2D(low, high, sampling_rate)
 
     # Generate a function according to the specified method
     uc1 = np.sin(x) + np.sin(y)
@@ -222,7 +222,7 @@ def test_image_3(
     :return: Generate a mixed image using two-dimensional sine and cosine functions
     """
     # Construct the two dim grid matrix
-    x, y = get_meshgrid(low, high, sampling_rate)
+    x, y = get_meshgrid_2D(low, high, sampling_rate)
 
     # Generate a function according to the specified method
     uc1 = np.sin(x / 24) + np.sin(y / 24)
@@ -251,7 +251,7 @@ def test_image_4(
     :return: Generate a mixed image using two-dimensional sine and cosine functions
     """
     # Construct the two dim grid matrix
-    x, y = get_meshgrid(low, high, sampling_rate)
+    x, y = get_meshgrid_2D(low, high, sampling_rate)
 
     # Generate a function according to the specified method
     uc1 = np.sin(x / 60) + np.sin(y / 60)
@@ -280,7 +280,7 @@ def test_image_5(
     :return: Generate a mixed image using two-dimensional sine and cosine functions
     """
     # Construct the two dim grid matrix
-    x, y = get_meshgrid(low, high, sampling_rate)
+    x, y = get_meshgrid_2D(low, high, sampling_rate)
 
     # Generate a function according to the specified method
     uc1 = np.sin(x * 8) + np.sin(y * 8)
@@ -309,7 +309,7 @@ def test_image_6(
     :return: Generate a mixed image using two-dimensional sine and cosine functions
     """
     # Construct the two dim grid matrix
-    x, y = get_meshgrid(low, high, sampling_rate)
+    x, y = get_meshgrid_2D(low, high, sampling_rate)
 
     # Generate a function according to the specified method
     uc1 = np.cos(x**1.2 * 8) + np.sin(y**1.2 * 8)
@@ -338,7 +338,7 @@ def test_uni_image_7(
     :return: Generate a mixed image using two-dimensional sine and cosine functions
     """
     # Construct the two dim grid matrix
-    x, y = get_meshgrid(low, high, sampling_rate)
+    x, y = get_meshgrid_2D(low, high, sampling_rate)
 
     # Generate a function according to the specified method
     uc1 = np.cos(x**1.2 * 8) + np.sin(y**1.2 * 8)
@@ -361,4 +361,4 @@ if __name__ == "__main__":
     plot_grayscale_image(test_uni_image_7())
     plt.show()
 
-    print(test_multi_image().shape)
+    print(test_multivariate_image().shape)

{pysdkit-0.4.13 → pysdkit-0.4.14}/pysdkit/emd/emd.py

@@ -380,7 +380,7 @@ class EMD(object):
         self,
         signal: np.ndarray,
         time: Optional[np.ndarray] = None,
-        max_imfs: Optional[int] = 4,
+        max_imfs: Optional[int] = None,
     ) -> np.ndarray:
         """
         Signal decomposition using EMD algorithm

{pysdkit-0.4.13 → pysdkit-0.4.14}/pysdkit/emd/remd.py

@@ -525,10 +525,10 @@ class REMD(object):
 
 if __name__ == "__main__":
     from matplotlib import pyplot as plt
-    from pysdkit.data import test_emd, test_uni_signal
+    from pysdkit.data import test_emd, test_univariate_signal
     from pysdkit.plot import plot_IMFs
 
-    time, signal = test_uni_signal()
+    time, signal = test_univariate_signal()
 
     remd = REMD(max_imfs=4, ext_ratio=0.0)
 

{pysdkit-0.4.13 → pysdkit-0.4.14}/pysdkit/plot/__init__.py

@@ -17,3 +17,6 @@ from ._plot_images import plot_grayscale_image, plot_grayscale_spectrum
 # 通用的图像可视化函数
 # 可以选择是否绘制频域图谱以及是否添加颜色条
 from ._plot_images import plot_images
+
+# Functions that generate signal visualizations
+from ._plot_signal import plot_signal