Note

Aller à la fin pour télécharger l’exemple de code complet.

Création de signaux#

Cet exemple se concentre sur la création d’objets signaux 1D dans Sigima.

Il existe trois méthodes principales pour créer des signaux dans Sigima :

  1. Génération de données synthétiques : utilisation de classes de paramètres intégrées pour créer des

    types de signaux standards (gaussienne, ondes sinusoïdales, distributions aléatoires, etc.)

  2. Chargement depuis des fichiers : importation de données depuis divers formats de fichiers

  3. Depuis des tableaux NumPy : création d’objets directement depuis des tableaux existants

Chaque méthode a ses cas d’usage, et Sigima fournit une interface cohérente pour travailler avec les données quelle que soit leur origine.

Pour la visualisation, nous utilisons des fonctions auxiliaires du module sigima.viz. Cela nous permet de nous concentrer sur les fonctionnalités de Sigima plutôt que sur les détails de visualisation.

Import des modules nécessaires#

Tout d’abord, nous devons importer les modules requis.

from pprint import pprint  # For pretty-printing metadata

import numpy as np

import sigima
from sigima import viz
from sigima.tests import helpers

Méthode 1 : Création de signaux à partir de paramètres synthétiques#

Sigima fournit des générateurs intégrés pour les types de signaux courants. C’est la méthode la plus pratique lorsque vous avez besoin de fonctions mathématiques standards ou de distributions aléatoires.

Les types de signaux disponibles incluent :

  • Fonctions mathématiques : gaussienne, lorentzienne, sinc, sinus, cosinus, etc.

  • Distributions aléatoires : normale, uniforme, Poisson

  • Formes d’ondes standards : carrée, en dents de scie, triangulaire

  • Fonctions spéciales : Planck (corps noir), chirp linéaire, échelon, exponentielle

# Let's consider a spectroscopy context, where we often deal with Gaussian and
# Lorentzian peaks representing absorption and emission lines.
#
# Create a Gaussian signal: this represents an absorption peak in spectroscopy.
gaussian_param = sigima.create_signal_parameters(
    sigima.SignalTypes.GAUSS,  # Type of signal to create
    title="Absorption Peak",
    size=500,  # Number of points
    xlabel="Wavelength",
    ylabel="Absorbance",
    xunit="nm",
    yunit="a.u.",
    xmin=400.0,  # Minimum x value (wavelength)
    xmax=700.0,  # Maximum x value
    a=2.5,  # Amplitude
    mu=550.0,  # Center wavelength (green light)
    sigma=25.0,  # Peak width
)
signal_synthetic = sigima.create_signal_from_param(gaussian_param)

# Create a Lorentzian signal representing a different spectral line: this represents an
# emission line in atomic emission spectroscopy.
lorentzian_param = sigima.create_signal_parameters(
    sigima.SignalTypes.LORENTZ,
    title="Emission Line",
    size=500,
    xlabel="Wavelength",
    ylabel="Intensity",
    xunit="nm",
    yunit="a.u.",
    xmin=400.0,
    xmax=700.0,
    a=1.8,  # Amplitude
    mu=480.0,  # Center wavelength (blue light)
    sigma=15.0,  # Peak width
)
signal_lorentzian = sigima.create_signal_from_param(lorentzian_param)

print("✓ Synthetic signals created")
print(f"  - {signal_synthetic.title}: {signal_synthetic.y.shape[0]} points")
print(f"  - {signal_lorentzian.title}: {signal_lorentzian.y.shape[0]} points")

# Visualize synthetic signals
viz.view_curves(
    [signal_synthetic, signal_lorentzian], title="Method 1: Synthetic Signals"
)
Qt widget 1 
✓ Synthetic signals created
  - Absorption Peak: 500 points
  - Emission Line: 500 points

Méthode 2 : Chargement de signaux depuis des fichiers#

Sigima peut lire des signaux depuis divers formats de fichiers, en détectant automatiquement le format et en extrayant les métadonnées lorsqu’elles sont disponibles.

Les formats pris en charge incluent :

  • Fichiers texte : CSV, TXT (avec détection automatique du délimiteur)

  • Formats scientifiques : HDF5 (.h5sig), MAT-Files (.mat), NumPy (.npy)

  • Spécialisés : fichiers de spectre MCA (.mca), FT-Lab (.sig)

# Load a real spectrum from a text file
# This is a paracetamol (acetaminophen) UV-Vis absorption spectrum
filename = helpers.get_test_fnames("paracetamol.txt")[0]
signal_from_file = sigima.read_signal(filename)

# Visualize signal loaded from text file
viz.view_curves(signal_from_file, title="Signal from Text File")

# Load another signal from a CSV file with multiple curves
csv_file = helpers.get_test_fnames("oscilloscope.csv")[0]
signals_from_csv = sigima.read_signals(csv_file)
# CSV files contain multiple signals; we'll show one
signal_from_csv = signals_from_csv[1]

# Visualize signal loaded from csv file
viz.view_curves(signal_from_csv, title="Signal from CSV File")

print("\n✓ Signals loaded from files")
print(f"  - {signal_from_file.title}: {signal_from_file.y.shape[0]} points")
print(f"  - {signal_from_csv.title}: {signal_from_csv.y.shape[0]} points")
Qt widget 1 Qt widget 2 
✓ Signals loaded from files
  - paracetamol.txt: 999 points
  - oscilloscope.csv 01: 100 points

Il est intéressant de noter ici que lors de l’importation de données depuis des fichiers, Sigima extrait et préserve automatiquement les métadonnées lorsque c’est possible. Cela inclut :

  • Étiquettes et unités des axes : en-têtes de colonnes des fichiers CSV, noms de variables des MAT-Files, etc.

  • Paramètres d’acquisition : en-têtes DICOM, paramètres d’instruments, horodatages

  • Coordonnées physiques : espacement des pixels, coordonnées d’origine lorsqu’elles sont stockées dans le fichier

Les métadonnées extraites sont intégrées de manière transparente dans l’objet signal ou image, les rendant disponibles pour le traitement, l’analyse et la visualisation sans configuration manuelle.

pprint(signal_from_csv.metadata)

{'CH6_D0': 0,
 'CH6_D1': 0,
 'CH6_D2': 0,
 'CH6_D3': 1,
 'CH6_D4': 1,
 'CH6_D5': 0,
 'CH6_D6': 0,
 'CH6_D7': 1,
 'source': '/home/docs/checkouts/readthedocs.org/user_builds/sigima-fr/checkouts/latest/sigima/data/tests/curve_formats/oscilloscope.csv'}

Méthode 3 : Création de signaux à partir de tableaux NumPy#

Lorsque vous avez déjà des données dans des tableaux NumPy (provenant de calculs, d’autres bibliothèques ou de sources de données personnalisées), vous pouvez les encapsuler dans des objets signaux Sigima pour bénéficier de la gestion des métadonnées et des fonctions de traitement.

# Create custom data: a damped oscillation (e.g., RLC circuit response)
t = np.linspace(0, 5, 1000)
damping = np.exp(-0.5 * t)
oscillation = np.sin(2 * np.pi * 3 * t)
y_damped = damping * oscillation

signal_from_array = sigima.create_signal(
    title="Damped Oscillation (from array)",
    x=t,
    y=y_damped,
    units=("s", "V"),
    labels=("Time", "Voltage"),
)

# Create the envelope signal: upper and lower bounds of the oscillation
# This is useful for analyzing the decay rate and quality factor
y_envelope_upper = damping
y_envelope_lower = -damping

# We'll create a signal showing the upper envelope
signal_envelope = sigima.create_signal(
    title="Decay Envelope (from array)",
    x=t,
    y=y_envelope_upper,
    units=("s", "V"),
    labels=("Time", "Amplitude"),
)

print("\n✓ Signals created from NumPy arrays")
print(f"  - {signal_from_array.title}: {signal_from_array.y.shape[0]} points")
print(f"  - {signal_envelope.title}: {signal_envelope.y.shape[0]} points")

# Visualize signals created from NumPy arrays
viz.view_curves(
    [signal_from_array, signal_envelope],
    title="Method 3: Signals from NumPy Arrays",
    object_name="signals_from_arrays",
)
Qt widget 1 
✓ Signals created from NumPy arrays
  - Damped Oscillation (from array): 1000 points
  - Decay Envelope (from array): 1000 points

Résumé#

Cet exemple a démontré les trois principales façons de créer des signaux dans Sigima :

  1. Génération synthétique : création rapide de fonctions mathématiques standards et de distributions à l’aide de classes de paramètres. Parfait pour les tests et la simulation.

  2. Chargement de fichiers : lecture de données depuis divers formats de fichiers scientifiques et courants, avec détection automatique du format et extraction des métadonnées. Essentiel pour travailler avec des données expérimentales.

  3. Conversion de tableaux NumPy : encapsulation de données de tableaux existants avec les riches métadonnées et capacités de traitement de Sigima. Idéal pour les flux de travail personnalisés et l’intégration avec d’autres bibliothèques Python.

Les trois méthodes produisent des objets Sigima équivalents qui peuvent être traités, analysés et visualisés en utilisant le même ensemble d’outils et de fonctions. Choisissez la méthode qui correspond le mieux à votre flux de travail et à votre source de données.

Galerie générée par Sphinx-Gallery