稀疏滤波的python代码

以下是稀疏滤波的Python代码：

import numpy as np
from scipy import sparse

def sparse_filter(image, kernel):
    """
    Applies sparse filtering to an image using a given kernel.
    
    Parameters:
    image (ndarray): The image to be filtered, as a 2D numpy array.
    kernel (ndarray or sparse matrix): The kernel to be applied to the image.
    
    Returns:
    filtered_image (ndarray): The filtered image, as a 2D numpy array.
    """
    # Ensure kernel is a sparse matrix
    if not isinstance(kernel, sparse.spmatrix):
        kernel = sparse.csr_matrix(kernel)
        
    # Define sizes of image and kernel
    m, n = image.shape
    k, l = kernel.shape
    
    # Pad image with zeros to handle edges of the image
    padded_image = np.pad(image, (k//2, l//2), mode='constant')
    
    # Define sparse matrix to store filter coefficients
    A = sparse.lil_matrix((m*n, m*n))
    
    # Loop through each pixel in the image
    for i in range(m):
        for j in range(n):
            # Define indices of kernel centered at current pixel
            k_min, k_max = i, i + k
            l_min, l_max = j, j + l
            
            # Extract submatrix from padded image centered at current pixel
            sub_image = padded_image[k_min:k_max, l_min:l_max]
            
            # Flatten submatrix and kernel into column vectors
            sub_image_flat = sub_image.flatten()
            kernel_flat = kernel.flatten()
            
            # Calculate filter coefficient for current pixel
            coeff = np.dot(kernel_flat, sub_image_flat)
            
            # Add coefficient to diagonal of sparse matrix
            index = i*n + j
            A[index,index] = coeff
    
    # Apply filter to image
    filtered_image = A.dot(image.flatten())
    filtered_image = filtered_image.reshape(m, n)
    
    return filtered_image

使用示例：

import matplotlib.pyplot as plt
from skimage import data
from scipy import ndimage

# Load an image
image = data.camera()

# Define a Gaussian kernel
sigma = 2
size = int(sigma*6) + 1
kernel = ndimage.gaussian_filter(np.eye(size), sigma)

# Apply sparse filtering to image
filtered_image = sparse_filter(image, kernel)

# Display the original and filtered images side by side
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5))
ax1.imshow(image, cmap='gray')
ax1.set_title('Original Image')
ax2.imshow(filtered_image, cmap='gray')
ax2.set_title('Filtered Image')
plt.show()