PySDKit 0.4.11__tar.gz → 0.4.12__tar.gz

{pysdkit-0.4.11 → pysdkit-0.4.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PySDKit
-Version: 0.4.11
+Version: 0.4.12
 Summary: A Python library for signal decomposition algorithms with a unified interface.
 Home-page: https://github.com/wwhenxuan/PySDKit
 Author: whenxuan
@@ -43,6 +43,7 @@ Dynamic: summary
 ![License](https://img.shields.io/github/license/wwhenxuan/PySDKit)
 [![Python](https://img.shields.io/badge/python-3.8+-blue?logo=python)](https://www.python.org/)
 [![Downloads](https://pepy.tech/badge/pysdkit)](https://pepy.tech/project/pysdkit)
+![Visits Badge](https://badges.pufler.dev/visits/ForestsKing/D3R)
 [![codestyle](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 
 A Python library for signal decomposition algorithms 🥳

{pysdkit-0.4.11 → pysdkit-0.4.12}/PySDKit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PySDKit
-Version: 0.4.11
+Version: 0.4.12
 Summary: A Python library for signal decomposition algorithms with a unified interface.
 Home-page: https://github.com/wwhenxuan/PySDKit
 Author: whenxuan
@@ -43,6 +43,7 @@ Dynamic: summary
 ![License](https://img.shields.io/github/license/wwhenxuan/PySDKit)
 [![Python](https://img.shields.io/badge/python-3.8+-blue?logo=python)](https://www.python.org/)
 [![Downloads](https://pepy.tech/badge/pysdkit)](https://pepy.tech/project/pysdkit)
+![Visits Badge](https://badges.pufler.dev/visits/ForestsKing/D3R)
 [![codestyle](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 
 A Python library for signal decomposition algorithms 🥳

{pysdkit-0.4.11 → pysdkit-0.4.12}/PySDKit.egg-info/SOURCES.txt

@@ -9,7 +9,7 @@ pysdkit/__init__.py
 pysdkit/data/__init__.py
 pysdkit/data/_add_noise.py
 pysdkit/data/_generator.py
-pysdkit/data/image.py
+pysdkit/data/_image.py
 pysdkit/data/texture.txt
 pysdkit/emd/__init__.py
 pysdkit/emd/_find_extrema.py
@@ -51,8 +51,8 @@ pysdkit/lmd/rlmd.py
 pysdkit/plot/__init__.py
 pysdkit/plot/_fourier_spectra.py
 pysdkit/plot/_functions.py
+pysdkit/plot/_plot_images.py
 pysdkit/plot/_plot_imfs.py
-pysdkit/plot/plot_GrayScale.py
 pysdkit/ssa/__init__.py
 pysdkit/ssa/ssa.py
 pysdkit/tvf_emd/__init__.py

{pysdkit-0.4.11 → pysdkit-0.4.12}/README.md

@@ -6,6 +6,7 @@
 ![License](https://img.shields.io/github/license/wwhenxuan/PySDKit)
 [![Python](https://img.shields.io/badge/python-3.8+-blue?logo=python)](https://www.python.org/)
 [![Downloads](https://pepy.tech/badge/pysdkit)](https://pepy.tech/project/pysdkit)
+![Visits Badge](https://badges.pufler.dev/visits/ForestsKing/D3R)
 [![codestyle](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 
 A Python library for signal decomposition algorithms 🥳

{pysdkit-0.4.11 → pysdkit-0.4.12}/pysdkit/data/__init__.py

@@ -17,11 +17,23 @@ from ._generator import generate_am_signal, generate_exponential_signal
 # Generates the main test sample signal
 from ._generator import test_emd
 
+# Generator for 1D univariate
+from ._generator import test_uni_signal
+
+# Generator for 1D multivariate
+from ._generator import test_multi_signal
+
 # Functions that generate signal visualizations
-from ._generator import plot_generate_signal
+from ._generator import plot_signal
 
 # add Gaussian noise
 from ._add_noise import add_noise
 
-# 加载二维灰度图像的测试案例
-from .image import test_grayscale
+# 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 multivariate image
+from ._image import test_multi_image

{pysdkit-0.4.11 → pysdkit-0.4.12}/pysdkit/data/_add_noise.py

@@ -25,11 +25,3 @@ def add_noise(N: int, Mean: float, STD: float) -> np.ndarray:
     y = Mean + STD * y
 
     return y
-
-
-if __name__ == "__main__":
-    N = 1000
-    Mean = 0
-    STD = 1
-    noise = add_noise(N, Mean, STD)
-    print(noise)

{pysdkit-0.4.11 → pysdkit-0.4.12}/pysdkit/data/_generator.py

@@ -198,7 +198,67 @@ def generate_exponential_signal(
     return t, noisy_exp_signal
 
 
-def base_example(
+def test_uni_signal(
+    case: int = 1,
+    duration: float = 1.0,
+    sampling_rate: int = 1000,
+) -> Tuple[np.array, np.array]:
+    """
+    Select a test case for a one-dimensional univariate signal based on the input `case`
+    :param case: the test number in [1, 2, 3]
+    :param duration: Length of the signal in seconds.
+    :param sampling_rate: Number of samples per second.
+    :return: Tuple containing time array and the generated signal.
+    :return: the generated signal for univariate 1D.
+    """
+    if case == 1:
+        return test_1D_1(duration, sampling_rate)
+    elif case == 2:
+        return test_1D_2(duration, sampling_rate)
+    elif case == 3:
+        return test_1D_3(duration, sampling_rate)
+    else:
+        # 当没有这个测试实例是返回`test_emd`这个函数
+        print(f"There is no case {case}, so it will return test_emd!")
+        return test_emd(duration, sampling_rate)
+
+
+def test_1D_1(
+    duration: float = 1.0, sampling_rate: int = 1000
+) -> Tuple[np.array, np.array]:
+    """4 / np.pi * (np.sin(2 * np.pi * 10 * t) + np.sin(2 * np.pi * 30 * t) / 3 + np.sin(2 * np.pi * (50 * t + 20 * t ** 2)) / 2)
+    :param duration: Length of the signal in seconds.
+    :param sampling_rate: Number of samples per second.
+    :return: Tuple containing time array and the generated signal.
+    """
+    t = np.linspace(0, duration, int(sampling_rate * duration), endpoint=False)
+    signal = (
+        4
+        / np.pi
+        * (
+            np.sin(2 * np.pi * 10 * t)
+            + np.sin(2 * np.pi * 30 * t) / 3
+            + np.sin(2 * np.pi * (50 * t + 20 * t**2)) / 2
+        )
+    )
+    return t, signal
+
+
+def test_1D_2(
+    duration: float = 10.0, sampling_rate: int = 128
+) -> Tuple[np.array, np.array]:
+    """
+    Generate 3 * 2 ^ (-t) * sin(sin(2 * pi * t))
+    :param duration: Length of the signal in seconds.
+    :param sampling_rate: Number of samples per second.
+    :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))
+    return t, signal
+
+
+def test_1D_3(
     duration: float = 6.0,
     sampling_rate: int = 128,
     noise_level: float = 0.0,
@@ -220,18 +280,6 @@ def base_example(
     return t, noise_signal
 
 
-def fun(duration: float = 10.0, sampling_rate: int = 128) -> Tuple[np.array, np.array]:
-    """
-    Generate 3 * 2 ^ (-t) * sin(sin(2 * pi * t))
-    :param duration: Length of the signal in seconds.
-    :param sampling_rate: Number of samples per second.
-    :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))
-    return t, signal
-
-
 def test_emd(
     duration: float = 1.0,
     sampling_rate: int = 1000,
@@ -254,14 +302,156 @@ def test_emd(
     return t, noise_signal
 
 
-def plot_generate_signal(
+def test_multi_signal(
+    case: int = 1,
+    duration: float = 1.0,
+    sampling_rate: int = 1000,
+) -> Tuple[np.array, np.array]:
+    """
+    Select a test case for a 1D multivariate signal based on the input `case`
+    :param case: the test number in [1, 2, 3]
+    :param duration: Length of the signal in seconds.
+    :param sampling_rate: Number of samples per second.
+    :return: Tuple containing time array and the generated signal.
+    :return: the generated signal for multivariate 1D.
+    """
+    if case == 1:
+        return test_multi_1D_1(duration=duration, sampling_rate=sampling_rate)
+    elif case == 2:
+        return test_multi_1D_2(duration=duration, sampling_rate=sampling_rate)
+    elif case == 3:
+        return test_multi_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)
+
+
+def test_multi_1D_1(
+    duration: float = 1.0, sampling_rate: int = 1000
+) -> Tuple[np.array, np.array]:
+    """
+    Generate some simple cosine and sine function for multivariate signal decomposition test
+    :param duration: Length of the signal in seconds.
+    :param sampling_rate: Number of samples per second.
+    :return: Tuple containing time array and the multivariate signals of shape [num_vars, seq_len].
+    """
+    t = np.linspace(0, duration, int(sampling_rate * duration), endpoint=False)
+
+    # Generate the multi-channels signals
+    signal_1 = np.cos(2 * np.pi * 5 * t + np.pi / 3) + 2.5 * np.cos(
+        2 * np.pi * 36 * t + np.pi / 2
+    )
+    signal_2 = 3 * np.cos(2 * np.pi * 24 * t) + 2 * np.cos(2 * np.pi * 36 * t)
+
+    # concat all channels
+    signal = np.vstack([signal_1, signal_2])
+
+    return t, signal
+
+
+def test_multi_1D_2(
+    duration: float = 1.0, sampling_rate: int = 1000
+) -> Tuple[np.array, np.array]:
+    """
+    Generate four channels simple cosine and sine function for multivariate signal decomposition
+    :param duration: Length of the signal in seconds.
+    :param sampling_rate: Number of samples per second.
+    :return: Tuple containing time array and the multivariate signals of shape [num_vars, seq_len].
+    """
+    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 = (
+        2 * np.cos(2 * np.pi * 3 * t**2)
+        + 1.7 * np.cos(2 * np.pi * 20 * t)
+        + np.cos(2 * np.pi * 40 * t)
+        + np.random.uniform(0, 0.2, t.shape)
+    )
+
+    signal_2 = 1.5 * np.cos(2 * np.pi * 3 * t**2) + np.random.uniform(0, 0.2, t.shape)
+
+    signal_3 = (
+        2 * np.cos(2 * np.pi * 20 * t + np.pi / 3)
+        + 1.8 * np.cos(2 * np.pi * 40 * t)
+        + np.random.uniform(0, 0.2, t.shape)
+    )
+
+    signal_4 = (
+        1.8 * np.cos(2 * np.pi * 3 * t**2)
+        + 2 * np.cos(2 * np.pi * 40 * t)
+        + np.random.uniform(0, 0.2, t.shape)
+    )
+
+    # Concat all the input channels
+    signal = np.vstack([signal_1, signal_2, signal_3, signal_4])
+
+    return t, signal
+
+
+def test_multi_1D_3(
+    duration: float = 1.0,
+    sampling_rate: int = 1000,
+    noise_level: float = 0.1,
+    random_state: int = 42,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Generate some simple cosine function for multivariate signal decomposition test
+    :param duration: Length of the signal in seconds.
+    :param sampling_rate: Number of samples per second.
+    :param noise_level: Standard deviation of the Gaussian noise.
+    :param random_state: Random seed for the noise generation.
+    :return: Tuple containing time array and the multivariate signals of shape [num_vars, seq_len] with noise.
+    """
+    np.random.seed(seed=random_state)
+    t = np.linspace(0, duration, int(sampling_rate * duration), endpoint=False)
+
+    # Generate the multi-channels signals
+    f_channel1 = (
+        (10 * np.cos(2 * np.pi * 2 * t))
+        + (9 * (np.cos(2 * np.pi * 36 * t)))
+        + np.random.normal(0, noise_level, t.shape)
+    )
+
+    f_channel2 = (
+        (9 * (np.cos(2 * np.pi * 24 * t)))
+        + (8 * (np.cos(2 * np.pi * 36 * t)))
+        + np.random.normal(0, noise_level, t.shape)
+    )
+
+    f_channel3 = (
+        (8 * (np.cos(2 * np.pi * 28 * t)))
+        + (7 * (np.cos(2 * np.pi * 48 * t)))
+        + np.random.normal(0, noise_level, t.shape)
+    )
+
+    f_channel4 = (
+        (7 * (np.cos(2 * np.pi * 32 * t)))
+        + (6 * (np.cos(2 * np.pi * 36 * t)))
+        + np.random.normal(0, noise_level, t.shape)
+    )
+
+    f_channel5 = (
+        (6 * (np.cos(2 * np.pi * 19 * t)))
+        + (5 * (np.cos(2 * np.pi * 64 * t)))
+        + np.random.normal(0, noise_level, t.shape)
+    )
+
+    # concat all channels
+    f = np.vstack([f_channel1, f_channel2, f_channel3, f_channel4, f_channel5])
+
+    return t, f
+
+
+def plot_signal(
     t: np.array,
     signal: np.array,
     color: str = "royalblue",
     save: bool = False,
-    figsize: Tuple = (12, 4),
-    dpi: int = 600,
-    fontsize: int = 15,
+    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.
@@ -269,26 +459,72 @@ def plot_generate_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 figsize: Tuple representing the width and height of the figure in inches.
     :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.
     """
-    # Create a figure and a single subplot
-    fig, ax = plt.subplots(figsize=figsize)
-    # 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")
-    # Enable grid for better readability
-    ax.grid(True)
-    # Display the plot
-    plt.show()
+
+    # 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
+
+    t, signal = test_uni_signal(case=1)
+    print(signal.shape)
+
+    fig = plot_signal(t, signal)
+
+    t, signal = test_multi_signal(case=2)
+    print(signal.shape)
+
+    fig = plot_signal(t, signal, save=False)
+    plt.show()