Création d’images#

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

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

Génération de données synthétiques : utilisation de classes de paramètres intégrées pour créer des
types d’images standards (gaussienne, rampe, distributions aléatoires, etc.)
Chargement depuis des fichiers : importation de données depuis divers formats de fichiers
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.

import numpy as np

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

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

Comme pour les signaux, Sigima peut générer des images synthétiques à l’aide de classes de paramètres.

Les types d’images disponibles incluent :

Distributions : normale (bruit gaussien), uniforme, Poisson
Fonctions analytiques : gaussienne 2D, rampe 2D (forme bilinéaire)
Images vierges : zéros

# Create a 2D Gaussian image
gaussian_param = sigima.create_image_parameters(
    sigima.ImageTypes.GAUSS,
    title="Synthetic 2D Gaussian",
    height=300,
    width=300,
    xlabel="X Position",
    ylabel="Y Position",
    zlabel="Intensity",
    xunit="µm",
    yunit="µm",
    zunit="counts",
    x0=0.0,  # Center x position
    y0=0.0,  # Center y position
    sigma=1.5,  # Width
    a=1000.0,  # Amplitude
)

gaussian_img = sigima.create_image_from_param(gaussian_param)

# Create a ramp image (gradient)
ramp_param = sigima.create_image_parameters(
    sigima.ImageTypes.RAMP,
    title="Synthetic 2D Ramp",
    height=200,
    width=200,
    xlabel="X Position",
    ylabel="Y Position",
    zlabel="Value",
    xunit="mm",
    yunit="mm",
    zunit="a.u.",
    x0=-5.0,
    y0=-5.0,
    a=0.5,  # X slope
    b=0.3,  # Y slope
)

ramp_img = sigima.create_image_from_param(ramp_param)

print("\n✓ Synthetic images created")
print(f"  - {gaussian_img.title}: {gaussian_img.data.shape}")
print(f"  - {ramp_img.title}: {ramp_img.data.shape}")

# Visualize synthetic images
viz.view_images_side_by_side([gaussian_img, ramp_img], title="Synthetic Images")

✓ Synthetic images created
  - Synthetic 2D Gaussian: (300, 300)
  - Synthetic 2D Ramp: (200, 200)

Méthode 2 : Chargement d’images depuis des fichiers#

Sigima prend en charge une large gamme de formats de fichiers image, à la fois courants et scientifiques.

Les formats pris en charge incluent :

Formats courants : BMP, JPEG, PNG, TIFF, JPEG 2000
Formats scientifiques : DICOM, Andor SIF, Spiricon, Dürr NDT
Formats de données : NumPy (.npy), MATLAB (.mat), HDF5 (.h5img)
Formats texte : CSV, TXT, ASC (avec prise en charge des coordonnées)

# Load an image from a JPEG file
filename = helpers.get_test_fnames("fiber.jpg")[0]
img_jpeg = sigima.read_image(filename)
img_jpeg.title = "Fiber Image (from JPEG)"

# Load an image from a NumPy file
filename = helpers.get_test_fnames("flower.npy")[0]
img_npy = sigima.read_image(filename)
img_npy.title = "Test Image (from NumPy)"

print("\n✓ Images loaded from files")
print(f"  - {img_jpeg.title}: {img_jpeg.data.shape}")
print(f"  - {img_npy.title}: {img_npy.data.shape}")

# Visualize images loaded from files
viz.view_images_side_by_side([img_jpeg, img_npy], title="Images from Files")

✓ Images loaded from files
  - Fiber Image (from JPEG): (480, 640)
  - Test Image (from NumPy): (512, 512)

Méthode 3 : Création d’images à partir de tableaux NumPy#

Convertir les tableaux NumPy existants en objets image Sigima pour ajouter des métadonnées, des systèmes de coordonnées et activer le traitement avancé.

# Create a synthetic pattern: interference fringes
size = 256
x = np.linspace(-10, 10, size)
y = np.linspace(-10, 10, size)
X, Y = np.meshgrid(x, y)

# Interference pattern
pattern = np.cos(2 * np.pi * X / 3) * np.cos(2 * np.pi * Y / 3)
pattern = ((pattern + 1) / 2 * 255).astype(np.uint8)

img_interf = sigima.create_image(
    title="Interference Pattern (from array)",
    data=pattern,
    units=("mm", "mm", "intensity"),
    labels=("X", "Y", "Signal"),
)

# Create another image: radial gradient with noise
radial = np.exp(-(X**2 + Y**2) / 20)
rng = np.random.default_rng(123)
radial = radial + rng.normal(0, 0.05, radial.shape)
radial = np.clip(radial, 0, 1)

img_radial = sigima.create_image(
    title="Radial Gradient (from array)",
    data=radial.astype(np.float32),
    units=("µm", "µm", "a.u."),
    labels=("X", "Y", "Amplitude"),
)

print("\n✓ Images created from NumPy arrays")
print(f"  - {img_interf.title}: {img_interf.data.shape}")
print(f"  - {img_radial.title}: {img_radial.data.shape}")

# Visualize images created from NumPy arrays
viz.view_images_side_by_side([img_interf, img_radial], title="Images from Arrays")

✓ Images created from NumPy arrays
  - Interference Pattern (from array): (256, 256)
  - Radial Gradient (from array): (256, 256)

Résumé#

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

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.
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.
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