PySDKit 0.1__tar.gz → 0.3__tar.gz

{PySDKit-0.1 → PySDKit-0.3}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: PySDKit
-Version: 0.1
-Summary: name
+Version: 0.3
+Summary: A Python library for signal decomposition algorithms with a unified interface
 Home-page: https://github.com/wwhenxuan/PySDKit
 Author: whenxuan
 Author-email: wwhenxuan@gmail.com

{PySDKit-0.1 → PySDKit-0.3}/PySDKit.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: PySDKit
-Version: 0.1
-Summary: name
+Version: 0.3
+Summary: A Python library for signal decomposition algorithms with a unified interface
 Home-page: https://github.com/wwhenxuan/PySDKit
 Author: whenxuan
 Author-email: wwhenxuan@gmail.com

PySDKit-0.3/PySDKit.egg-info/SOURCES.txt

@@ -0,0 +1,33 @@
+README.md
+setup.py
+PySDKit.egg-info/PKG-INFO
+PySDKit.egg-info/SOURCES.txt
+PySDKit.egg-info/dependency_links.txt
+PySDKit.egg-info/requires.txt
+PySDKit.egg-info/top_level.txt
+pysdkit/__init__.py
+pysdkit/data/__init__.py
+pysdkit/data/generator.py
+pysdkit/emd/BEMD.py
+pysdkit/emd/EMD.py
+pysdkit/emd/__init__.py
+pysdkit/emd/_find_extrema.py
+pysdkit/emd/_prepare_points.py
+pysdkit/emd2d/__init__.py
+pysdkit/ewt/__init__.py
+pysdkit/mvmd/__init__.py
+pysdkit/plot/__init__.py
+pysdkit/plot/functions.py
+pysdkit/plot/imf.py
+pysdkit/plot/main.py
+pysdkit/utils/__init__.py
+pysdkit/utils/base.py
+pysdkit/utils/fft.py
+pysdkit/utils/hilbert.py
+pysdkit/utils/mirror.py
+pysdkit/utils/process.py
+pysdkit/utils/splines.py
+pysdkit/vmd/__init__.py
+pysdkit/vmd/vmd_c.py
+pysdkit/vmd/vmd_f.py
+pysdkit/vncmd/__init__.py

PySDKit-0.3/PySDKit.egg-info/top_level.txt

@@ -0,0 +1 @@
+pysdkit

PySDKit-0.3/pysdkit/__init__.py

@@ -0,0 +1,5 @@
+# 经验模态分解算法
+from .emd import EMD
+
+# 变分模态分解算法
+from .vmd import vmd, VMD

PySDKit-0.3/pysdkit/data/__init__.py

@@ -0,0 +1,10 @@
+# A series of functions for generating 1D NumPy signals
+from .generator import generate_sin_signal, generate_cos_signal
+from .generator import generate_square_wave, generate_triangle_wave, generate_sawtooth_wave
+from .generator import generate_am_signal, generate_exponential_signal
+
+# Generates the main test sample signal
+from .generator import test_emd
+
+# Functions that generate signal visualizations
+from .generator import plot_generate_signal

PySDKit-0.3/pysdkit/data/generator.py

@@ -0,0 +1,191 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Sat Mar 8 21:45:02 2024
+@author: Whenxuan Wang
+@email: wwhenxuan@gmail.com
+"""
+import numpy as np
+from scipy.signal import sawtooth
+from matplotlib import pyplot as plt
+
+from typing import Tuple
+
+
+def generate_sin_signal(duration: float = 1.0, sampling_rate: int = 1000, noise_level: float = 0.2,
+                        frequency: float = 10.0, rand_state: int = 42) -> Tuple[np.array, np.array]:
+    """
+    Generate a Cosine signal with Gaussian noise and a sinusoidal component.
+    :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 frequency: Frequency of the sinusoidal component.
+    :param rand_state: Random seed for the noise in signal.
+    :return: Array of the Cosine signal.
+    """
+    t = np.linspace(0, duration, int(sampling_rate * duration), endpoint=False)
+    signal = np.sin(2 * np.pi * frequency * t)  # Sinusoidal signal
+    np.random.seed(seed=rand_state)
+    noise = np.random.normal(0, noise_level, signal.shape)  # Gaussian noise
+    emg_signal = signal + noise  # Superimpose signal and noise
+    return t, emg_signal
+
+
+def generate_cos_signal(duration: float = 1.0, sampling_rate: int = 1000, noise_level: float = 0.2,
+                        frequency: float = 10.0, rand_state: int = 42) -> Tuple[np.array, np.array]:
+    """
+    Generate a Cosine signal with Gaussian noise and a sinusoidal component.
+    :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 frequency: Frequency of the sinusoidal component.
+    :param rand_state: Random seed for the noise in signal.
+    :return: Array of the Cosine signal.
+    """
+    t = np.linspace(0, duration, int(sampling_rate * duration), endpoint=False)
+    signal = np.cos(2 * np.pi * frequency * t)  # Sinusoidal signal
+    np.random.seed(seed=rand_state)
+    noise = np.random.normal(0, noise_level, signal.shape)  # Gaussian noise
+    emg_signal = signal + noise  # Superimpose signal and noise
+    return t, emg_signal
+
+
+def generate_square_wave(duration: float = 1.0, sampling_rate: int = 1000, noise_level: float = 0.2,
+                         frequency: float = 10.0, rand_state: int = 42) -> Tuple[np.array, np.array]:
+    """
+    Generate a square wave signal with Gaussian noise.
+    :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 frequency: Frequency of the square wave component.
+    :param rand_state: Random seed for the noise in signal.
+    :return: Tuple containing time array and the square wave signal with noise.
+    """
+    np.random.seed(rand_state)
+    t = np.linspace(0, duration, int(sampling_rate * duration), endpoint=False)
+    square_wave = np.sign(np.sin(2 * np.pi * frequency * t))  # Generate a basic square wave
+    noise = np.random.normal(0, noise_level, square_wave.shape)  # Gaussian noise
+    noisy_square_wave = square_wave + noise
+    return t, noisy_square_wave
+
+
+def generate_triangle_wave(duration: float = 1.0, sampling_rate: int = 1000, noise_level: float = 0.2,
+                           frequency: float = 10.0, rand_state: int = 42) -> Tuple[np.array, np.array]:
+    """
+    Generate a triangular wave signal with Gaussian noise.
+    :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 frequency: Frequency of the triangular wave component.
+    :param rand_state: Random seed for the noise in signal.
+    :return: Tuple containing time array and the triangular wave signal with noise.
+    """
+    np.random.seed(rand_state)  # Set random seed for reproducibility
+    t = np.linspace(0, duration, int(sampling_rate * duration), endpoint=False)
+    # Generate the triangular wave using the sawtooth function and converting it to a triangular shape
+    from scipy.signal import sawtooth
+    triangle_wave = 2 * np.abs(sawtooth(2 * np.pi * frequency * t, 0.5)) - 1
+    noise = np.random.normal(0, noise_level, triangle_wave.shape)  # Add Gaussian noise
+    noisy_triangle_wave = triangle_wave + noise  # Combine triangle wave with noise
+    return t, noisy_triangle_wave
+
+
+def generate_sawtooth_wave(duration: float = 1.0, sampling_rate: int = 1000, noise_level: float = 0.2,
+                           frequency: float = 10.0, rand_state: int = 42) -> Tuple[np.array, np.array]:
+    """
+    Generate a sawtooth wave signal with Gaussian noise.
+    :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 frequency: Frequency of the sawtooth wave component.
+    :param rand_state: Random seed for the noise in signal.
+    :return: Tuple containing time array and the sawtooth wave signal with noise.
+    """
+    np.random.seed(rand_state)  # Set the random seed for reproducibility
+    t = np.linspace(0, duration, int(sampling_rate * duration), endpoint=False)
+    saw_wave = sawtooth(2 * np.pi * frequency * t)  # Generate a pure sawtooth wave
+    noise = np.random.normal(0, noise_level, saw_wave.shape)  # Add Gaussian noise
+    noisy_saw_wave = saw_wave + noise  # Combine sawtooth wave with noise
+    return t, noisy_saw_wave
+
+
+def generate_am_signal(duration: float = 1.0, sampling_rate: int = 1000, noise_level: float = 0.1,
+                       carrier_freq: float = 100.0, modulating_freq: float = 5.0, mod_index: float = 1.0,
+                       rand_state: int = 42) -> Tuple[np.array, np.array]:
+    """
+    Generate an Amplitude Modulated (AM) signal with Gaussian noise.
+    :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 carrier_freq: Frequency of the carrier signal.
+    :param modulating_freq: Frequency of the modulating signal.
+    :param mod_index: Modulation index.
+    :param rand_state: Random seed for the noise generation.
+    :return: Tuple containing time array and the AM signal with noise.
+    """
+    np.random.seed(rand_state)  # Set the random seed for reproducibility
+    t = np.linspace(0, duration, int(sampling_rate * duration), endpoint=False)
+    # Carrier signal
+    carrier = np.cos(2 * np.pi * carrier_freq * t)
+    # Modulating signal
+    modulating_signal = np.cos(2 * np.pi * modulating_freq * t)
+    # Amplitude Modulated signal
+    am_signal = (1 + mod_index * modulating_signal) * carrier
+    # Add Gaussian noise
+    noise = np.random.normal(0, noise_level, am_signal.shape)
+    noisy_am_signal = am_signal + noise  # AM signal with noise
+    return t, noisy_am_signal
+
+
+def generate_exponential_signal(duration: float = 1.0, sampling_rate: int = 1000, noise_level: float = 0.1,
+                                decay_rate: float = 1.0, initial_amplitude: float = 1.0,
+                                rand_state: int = 42) -> Tuple[np.array, np.array]:
+    """
+    Generate an exponentially decaying signal with Gaussian noise.
+    :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 decay_rate: Exponential decay rate (larger values decay faster).
+    :param initial_amplitude: Initial amplitude of the signal.
+    :param rand_state: Random seed for the noise generation.
+    :return: Tuple containing time array and the exponentially decaying signal with noise.
+    """
+    np.random.seed(rand_state)  # Set the random seed for reproducibility
+    t = np.linspace(0, duration, int(sampling_rate * duration), endpoint=False)
+    # Exponentially decaying signal
+    exp_signal = initial_amplitude * np.exp(-decay_rate * t)
+    # Add Gaussian noise
+    noise = np.random.normal(0, noise_level, exp_signal.shape)
+    noisy_exp_signal = exp_signal + noise  # Exponential signal with noise
+    return t, noisy_exp_signal
+
+
+def test_emd(duration: float = 1.0, sampling_rate: int = 1000, noise_level: float = 0.1,
+             random_state: int = 42) -> Tuple[np.array, np.array]:
+    """
+    Generate cos(22 * pi * t ^ 2) + 6 * t ^ 2 for emd 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 cos(22 * pi * t ^ 2) + 6 * t ^ 2 signal with noise.
+    """
+    np.random.seed(seed=random_state)
+    t = np.linspace(0, duration, int(sampling_rate * duration), endpoint=False)
+    signal = np.cos(22 * np.pi * t ** 2) + 2 * t ** 2
+    noise = np.random.normal(0, noise_level, signal.shape)
+    noise_signal = signal + noise
+    return t, noise_signal
+
+
+def plot_generate_signal(t: np.array, signal: np.array, save: bool = False,
+                         figsize: Tuple = (12, 4), dpi: int = 600, fontsize: int = 15) -> plt.figure:
+    fig, ax = plt.subplots(figsize=figsize)
+    ax.plot(t, signal)
+    ax.set_xlabel('Time (seconds)', fontsize=fontsize)
+    ax.set_ylabel('Amplitude')
+    ax.grid(True)
+    plt.show()
+    # whether to save the figure
+    if save is True:
+        fig.save("generate_signal.jpg", dpi=dpi, bbox_inches='tight')
+    return fig