Algoritmos Fundamentales para el Desenfoque de Imágenes

1. Filtrado de Wiener con PSF Conocido

El método requiere la función de difusión del punto (PSF) para la restauración.

% Carga de la imagen afectada por desenfoque
imagen_borrosa = imread('imagen_borrosa.jpg');
imagen_gris = rgb2gray(imagen_borrosa);
datos_imagen = im2double(imagen_gris);

% Configuración del PSF para desenfoque por movimiento
longitud_desenfoque = 28;
angulo_desenfoque = 14;
psf_motion = fspecial('motion', longitud_desenfoque, angulo_desenfoque);

% Ajuste del parámetro de ruido para la deconvolución
nivel_ruido = 0.001;
imagen_restaurada = deconvwnr(datos_imagen, psf_motion, nivel_ruido);

% Visualización comparativa
figure;
subplot(1,2,1); imshow(imagen_gris); title('Imagen Borrosa Original');
subplot(1,2,2); imshow(imagen_restaurada); title('Resultado del Filtro de Wiener');

Parámetros esenciales:

• nivel_ruido: Estimación de la potencia del ruido, requiere ajuste experimental.
• psf_motion: PSF específico según el tipo de desenfoque (ej. movimiento, gaussiano).

2. Deconvolución Ciega para PSF Desconocido

Estima simultáneamente la imagen limpia y el PSF mediante iteraciones.

% Inicialización del PSF como matriz uniforme
psf_inicial = ones(size(psf_motion)) / numel(psf_motion);

% Ejecución de la deconvolución ciega
iteraciones = 10;
[imagen_limpia, psf_estimado] = deconvblind(datos_imagen, psf_inicial, iteraciones);

% Exposición del PSF estimado
figure;
subplot(1,2,1); imshow(psf_inicial); title('PSF Inicial');
subplot(1,2,2); imshow(psf_estimado); title('PSF Estimado por Deconvolución Ciega');

Estrategias de mejora:

• Aplicar edgetaper antes de la deconvolución para minimizar artefactos de anillado.
• Utilizar restricciones de optimización mediante multiplicadores de Lagrange.

3. Enfoque Basado en la Teoría Retinex

Emplea Retinex de escala única para separar ilumincaión y reflectancia.

function componente_reflexion = retinex_escala_unica(imagen, sigma)
    % Estimación de la iluminación con filtro gaussiano
    iluminacion = imgaussfilt(imagen, sigma);
    % Conversión al dominio logarítmico para el procesamiento
    log_imagen = log(imagen + 0.01);
    log_iluminacion = log(iluminacion + 0.01);
    % Cálculo de la reflectancia
    componente_reflexion = exp(log_imagen - log_iluminacion);
end

% Implementación multi-escala de Retinex
valores_sigma = [15, 80, 250];
factores_ponderacion = [0.3, 0.3, 0.4];
imagen_retinex_multi = zeros(size(datos_imagen));
for indice = 1:numel(valores_sigma)
    imagen_retinex_multi = imagen_retinex_multi + factores_ponderacion(indice) * retinex_escala_unica(datos_imagen, valores_sigma(indice));
end
imagen_retinex_multi = mat2gray(imagen_retinex_multi);

Recomendaciones para los parámetros σ:

• σ=15: Favorecce la recuperación de texturas finas.
• σ=250: Mitiga variaciones de iluminación severas.

Técnicas para Desenfoque por Movimiento

Modelado y Simulación del Efecto

% Generación de un PSF de desenfoque lineal
longitud_mov = 30;
angulo_mov = 45;
psf_movimiento = fspecial('motion', longitud_mov, angulo_mov);

% Adición de ruido gaussiano a la imagen borrosa
imagen_corrompida = imnoise(imfilter(datos_imagen, psf_movimiento, 'conv'), 'gaussian', 0, 0.001);

Restauración con Filtrado de Wiener Adaptativo

% Cálculo del ruido residual para parametrizar el filtro
varianza_ruido = var(imagen_corrompida(:) - datos_imagen(:));
factor_k = varianza_ruido / var(datos_imagen(:));
imagen_recuperada = deconvwnr(imagen_corrompida, psf_movimiento, factor_k);

Aplicaciones Prácticas

Mejora de Imáganes de Matrículas Vehiculares

% Lectura y preprocesamiento por ecualización de histograma
imagen_matricula = imread('matricula_desenfocada.jpg');
imagen_ecualizada = histeq(imagen_matricula);

% Aplicación de desenfoque gaussiano mediante filtro de Wiener
kernel_gaussiano = fspecial('gaussian', [5 5], 1);
resultado_matricula = deconvwnr(imagen_ecualizada, kernel_gaussiano, 0.001);

Procesamiento de Imágenes Médicas

% Carga de imagen radiográfica
imagen_rayos_x = imread('radiografia.png');

% Aplicación de Retinex multi-escala para realce
imagen_realzada = multiScaleRetinex(imagen_rayos_x, [15, 80, 250]);

% Filtrado de postproceso con media no local
imagen_final = nlmfilt(imagen_realzada);

Nota: La función multiScaleRetinex debe definirse utilizando la implementación de Retinex multi-escala mostrada anteriormente.

Resolución de Problemas Habituales

Determinación del Ángulo en Desenfoque por Movimiento

% Análisis de frecuencia para identificar la dirección del movimiento
transformada_fourier = fftshift(fft2(datos_imagen));
fase_espectral = angle(transformada_fourier(:,:,1));
angulo_estimado = rad2deg(fase_espectral);

Estimación Automática del PSF Basada en Espectro

% Extracción de características frecuenciales del PSF
[Pxx, Pyy] = freqz2(psf_motion);
espectro_imagen = fft2(datos_imagen);
estimacion_k = sqrt(Pxx .* conj(espectro_imagen(:,:,1)).^2 + Pyy .* conj(espectro_imagen(:,:,2)).^2);