Convolution et déconvolution

Cet exemple se concentre sur le floutage et l’accentuation de contours d’images en utilisant les techniques de convolution et de déconvolution fournies par Sigima. En utilisant divers noyaux, nous explorerons comment ces opérations affectent les images et comment les implémenter en utilisant les fonctions de traitement de Sigima.

L’exemple montre :

• Création d’images de test et de noyaux

• Convolution de base avec noyau gaussien

• Convolution d’identité (préservation de l’image d’origine)

• Opérations de déconvolution

• Effets des différents paramètres de noyau

• Kernels personnalisés de détection de contours et d’accentuation

Ce tutoriel utilise PlotPy pour la visualisation, fournissant des graphiques interactifs qui vous permettent d’explorer les résultats de convolution en détail.

Importation des modules nécessaires

Nous commencerons par importer tous les modules nécessaires au traitement d’image et à la visualisation.

import numpy as np
import scipy.signal

import sigima.objects
import sigima.params
import sigima.proc.image
from sigima import viz

Création d’images de test et de noyaux

Nous commençons par créer une image de test et divers noyaux de convolution.

# Set the fixed image size for this tutorial
size = 128

# Generate a test square image with a rectangle in the center
data = np.zeros((size, size), dtype=np.float64)
data[size // 5 : 2 * size // 5, size // 7 : 5 * size // 7] = 1.0
original_image = sigima.objects.create_image("Original Rectangle", data)

# Generate a Gaussian kernel
gparam = sigima.objects.Gauss2DParam.create(height=31, width=31, sigma=2.0)
nparam = sigima.params.NormalizeParam.create(method="area")
gaussian_kernel = sigima.objects.create_image_from_param(gparam)
gaussian_kernel = sigima.proc.image.normalize(gaussian_kernel, nparam)
gaussian_kernel.title = "Gaussian Kernel (σ=2.0)"

# Generate an identity kernel (impulse response)
identity_size = 15
identity_kernel = sigima.objects.create_image_from_param(
    sigima.objects.Zero2DParam.create(height=identity_size, width=identity_size)
)
identity_kernel.data[identity_size // 2, identity_size // 2] = 1.0
identity_kernel.title = "Identity Kernel"

print("✓ Test images and kernels created successfully!")
print("This example demonstrates convolution and deconvolution with Sigima.")
print(f"Original image shape: {original_image.data.shape}")
print(f"Gaussian kernel shape: {gaussian_kernel.data.shape}")
print(f"Identity kernel shape: {identity_kernel.data.shape}")

# Display the original image and kernels
viz.view_images_side_by_side(
    [original_image, gaussian_kernel, identity_kernel],
    ["Original Image", "Gaussian Kernel (σ=2.0)", "Identity Kernel"],
    title="Test Images and Kernels",
)

✓ Test images and kernels created successfully!
This example demonstrates convolution and deconvolution with Sigima.
Original image shape: (128, 128)
Gaussian kernel shape: (31, 31)
Identity kernel shape: (15, 15)

Convolution de base avec noyau gaussien

Nous allons maintenant effectuer une convolution avec le noyau gaussien et comparer le résultat avec l’implémentation de scipy pour vérifier la justesse.

# Perform convolution with Gaussian kernel
convolved_gauss = sigima.proc.image.convolution(original_image, gaussian_kernel)
convolved_gauss.title = "Convolved with Gaussian"

# Compare with scipy implementation
expected_result = scipy.signal.convolve(
    original_image.data, gaussian_kernel.data, mode="same", method="auto"
)
print("\n✓ Convolution completed!")
max_diff = np.max(np.abs(convolved_gauss.data - expected_result))
print(f"Max difference from scipy: {max_diff:.2e}")

# Visualize the convolution process
viz.view_images_side_by_side(
    [original_image, gaussian_kernel, convolved_gauss],
    ["Original Image", "Gaussian Kernel (σ=2.0)", "Convolved Result"],
    title="Gaussian Convolution Example",
)

✓ Convolution completed!
Max difference from scipy: 0.00e+00

Convolution d’identité

La convolution d’identité devrait préserver exactement l’image d’origine. Cela démontre que notre implémentation de convolution fonctionne correctement.

# Perform convolution with identity kernel
convolved_identity = sigima.proc.image.convolution(original_image, identity_kernel)
convolved_identity.title = "Convolved with Identity"

# This should be nearly identical to the original
difference = np.max(np.abs(convolved_identity.data - original_image.data))
print("\n✓ Identity convolution completed!")
print(f"Max difference from original: {difference:.2e}")

# Visualize the identity convolution
viz.view_images_side_by_side(
    [original_image, identity_kernel, convolved_identity],
    ["Original Image", "Identity Kernel", "Convolved with Identity"],
    "Identity Convolution Example",
)

✓ Identity convolution completed!
Max difference from original: 7.77e-16

Déconvolution avec noyau d’identité

La déconvolution est l’opération inverse de la convolution. Nous commencerons par un cas simple utilisant le noyau d’identité.

# Start with the convolved image and deconvolve using identity kernel
deconvolved_identity = sigima.proc.image.deconvolution(
    convolved_identity, identity_kernel
)
deconvolved_identity.title = "Deconvolved (Identity)"

# Check how well we recovered the original
recovery_error = np.max(np.abs(deconvolved_identity.data - original_image.data))
print("\n✓ Identity deconvolution completed!")
print(f"Recovery error: {recovery_error:.2e}")

# Visualize the deconvolution process
viz.view_images_side_by_side(
    [original_image, convolved_identity, deconvolved_identity],
    ["Original", "Convolved", "Deconvolved"],
    title="Identity Deconvolution Example",
)

✓ Identity deconvolution completed!
Recovery error: 1.00e-12

Déconvolution avancée avec noyau gaussien

Nous allons maintenant essayer la déconvolution avec un noyau gaussien, qui est plus difficile et démontre les limites de la déconvolution.

# Create a Gaussian kernel with smaller sigma for better deconvolution
gparam.sigma = 1.5
deconv_gaussian = sigima.proc.image.normalize(
    sigima.objects.create_image_from_param(gparam), nparam
)
deconv_gaussian.title = "Gaussian Kernel (σ=1.5)"

# Convolve the original image with this kernel
large_convolved = sigima.proc.image.convolution(original_image, deconv_gaussian)
large_convolved.title = "Convolved Image"

# Attempt deconvolution to recover the original
large_deconvolved = sigima.proc.image.deconvolution(large_convolved, deconv_gaussian)
large_deconvolved.title = "Deconvolved Result"

print("\n✓ Gaussian deconvolution completed!")
orig_min, orig_max = np.min(original_image.data), np.max(original_image.data)
deconv_min, deconv_max = np.min(large_deconvolved.data), np.max(large_deconvolved.data)
print(f"Original image range: [{orig_min:.3f}, {orig_max:.3f}]")
print(f"Deconvolved image range: [{deconv_min:.3f}, {deconv_max:.3f}]")

# Visualize the full deconvolution process
viz.view_images_side_by_side(
    [original_image, deconv_gaussian, large_convolved, large_deconvolved],
    ["Original", "Gaussian Kernel", "Convolved", "Deconvolved"],
    title="Gaussian Deconvolution Example",
)

✓ Gaussian deconvolution completed!
Original image range: [0.000, 1.000]
Deconvolved image range: [-0.039, 1.019]

Exploration des différents paramètres de noyau

Différentes valeurs de sigma dans les noyaux gaussiens produisent différents effets de flou. Comparons plusieurs valeurs de sigma côte à côte.

# Create kernels with different sigma parameters
gparam.sigma = 0.8
small_sigma = sigima.proc.image.normalize(
    sigima.objects.create_image_from_param(gparam), nparam
)
gparam.sigma = 2.0
medium_sigma = sigima.proc.image.normalize(
    sigima.objects.create_image_from_param(gparam), nparam
)
gparam.sigma = 4.0
large_sigma = sigima.proc.image.normalize(
    sigima.objects.create_image_from_param(gparam), nparam
)

# Convolve the original image with each kernel
conv_small = sigima.proc.image.convolution(original_image, small_sigma)
conv_medium = sigima.proc.image.convolution(original_image, medium_sigma)
conv_large = sigima.proc.image.convolution(original_image, large_sigma)

print("\n✓ Multiple kernel comparison completed!")

# Show the effect of different sigma values on kernels
viz.view_images_side_by_side(
    [small_sigma, medium_sigma, large_sigma],
    ["Kernel σ=0.8", "Kernel σ=2.0", "Kernel σ=4.0"],
    title="Gaussian Kernels with Different Sigma Values",
)

# Show the effect of different sigma values on convolution results
viz.view_images_side_by_side(
    [conv_small, conv_medium, conv_large],
    ["Convolved σ=0.8", "Convolved σ=2.0", "Convolved σ=4.0"],
    title="Convolution Results with Different Sigma Values",
)

✓ Multiple kernel comparison completed!

Kernels de convolution personnalisés

En plus des noyaux gaussiens, nous pouvons créer des noyaux personnalisés pour des tâches spécifiques de traitement d’image telles que la détection de contours et l’accentuation.

# Edge detection kernel (Sobel-like)
edge_data = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]], dtype=np.float64)
edge_kernel = sigima.objects.create_image("Edge Detection Kernel", edge_data)

# Sharpening kernel
sharpen_data = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]], dtype=np.float64)
sharpen_kernel = sigima.objects.create_image("Sharpening Kernel", sharpen_data)

# Apply custom kernels to the original image
edge_result = sigima.proc.image.convolution(original_image, edge_kernel)
edge_result.title = "Edge Detection"

sharpen_result = sigima.proc.image.convolution(original_image, sharpen_kernel)
sharpen_result.title = "Sharpened"

print("\n✓ Custom kernel convolutions completed!")

# Visualize custom kernels
viz.view_images_side_by_side(
    [edge_kernel, sharpen_kernel],
    ["Edge Detection Kernel", "Sharpening Kernel"],
    title="Custom Convolution Kernels",
)

# Visualize custom kernel results
viz.view_images_side_by_side(
    [original_image, edge_result, sharpen_result],
    ["Original", "Edge Detection", "Sharpened"],
    title="Custom Kernel Convolution Results",
)

✓ Custom kernel convolutions completed!

Résumé et conclusions

Ce tutoriel a démontré les concepts clés de la convolution et de la déconvolution dans le traitement d’image en utilisant Sigima.

print("\n" + "=" * 60)
print("CONVOLUTION TUTORIAL SUMMARY")
print("=" * 60)
print("✓ Created test images and various kernels")
print("✓ Demonstrated basic Gaussian convolution")
print("✓ Showed identity kernel behavior")
print("✓ Performed deconvolution operations")
print("✓ Explored different kernel parameters")
print("✓ Applied custom edge detection and sharpening kernels")
print("\nKey Takeaways:")
print("• Larger sigma values create more blurring")
print("• Identity kernels preserve the original image")
print("• Deconvolution can recover original features (with limitations)")
print("• Custom kernels enable specialized image processing effects")

# Final comparison showing the complete pipeline
dialog10 = viz.view_images_side_by_side(
    [original_image, gaussian_kernel, convolved_gauss, large_deconvolved],
    ["Original", "Gaussian Kernel", "Convolved", "Deconvolved"],
    title="Complete Convolution-Deconvolution Pipeline",
)

============================================================
CONVOLUTION TUTORIAL SUMMARY
============================================================
✓ Created test images and various kernels
✓ Demonstrated basic Gaussian convolution
✓ Showed identity kernel behavior
✓ Performed deconvolution operations
✓ Explored different kernel parameters
✓ Applied custom edge detection and sharpening kernels

Key Takeaways:
• Larger sigma values create more blurring
• Identity kernels preserve the original image
• Deconvolution can recover original features (with limitations)
• Custom kernels enable specialized image processing effects