一、Código de Implementación del Algoritmo

Este código implemanta el algoritmo de Criminisi para la restauración de imágenes digitales, permitiendo eliminar objetos no deseados o restaurar regiones dañadas en imágenes a color.

%% Algoritmo de Restauración Criminisi para Imágenes a Color
% Propósito: Restaurar regiones faltantes en imágenes (rayones, obstáculos)

clear; clc; close all;

%% Configuración de Parámetros
rutaImagen = 'imagen_danada.png';    % Ruta de la imagen de entrada
rutaMáscara = 'máscara.png';         % Máscara de región faltante (blanco = faltante)
tamBloque = 9;                        % Tamaño del bloque de restauración (impar)
ventanaBusqueda = 50;                 % Tamaño de ventana de búsqueda
iteracionesMax = 1000;                % Máximo de iteraciones

%% Carga de Imagen y Máscara
imagen = imread(rutaImagen);
if size(imagen,3) == 1
    imagen = cat(3,imagen,imagen,imagen);    % Convertir a RGB si es escala de grises
end
máscara = imbinarize(im2double(imread(rutaMáscara)));  % Máscara binaria

%% Inicialización de Variables
[alto,ancho,~] = size(imagen);
confianza = double(~máscara);        % Mapa de confianza (región conocida = 1)
puntosFijos = false(alto,ancho);     % Marcador de puntos fijos
puntosFrontera = identificarFrontera(máscara);  % Detectar puntos de frontera

%% Ciclo Principal de Restauración
tic;
for iter = 1:iteracionesMax
    if isempty(puntosFrontera)
        break;
    end
    
    % Seleccionar punto de mayor prioridad
    [punto, puntosFrontera] = obtenerPuntoPrioritario(imagen, máscara, confianza, puntosFrontera);
    
    % Buscar mejor bloque coincidente
    [coordenadaX, coordenadaY] = encontrarCoincidencia(imagen, máscara, punto, tamBloque, ventanaBusqueda);
    
    % Ejecutar restauración
    [imagen, máscara, confianza] = aplicarBloque(imagen, máscara, confianza, coordenadaX, coordenadaY, tamBloque);
    
    % Mostrar progreso
    fprintf('Iteración %d: Puntos restaurados %d\n', iter, size(puntosFrontera,1));
end
tiempoTotal = toc;

%% Visualización de Resultados
figure;
subplot(1,2,1);
imshow(imagen); title('Imagen Restaurada');
subplot(1,2,2);
imshow(máscara); title('Máscara de Región Faltante');

figure;
imshow(imagen); title('Resultado Final');

%% Definición de Funciones Principales
function puntosFrontera = identificarFrontera(máscara)
    % Identificar puntos de frontera de la máscara como puntos iniciales de restauración
    [filas,columnas] = find(máscara);
    puntosFrontera = [];
    for i=1:length(filas)
        % Obtener vecindad 8
        vecindad = [filas(i)+(-1:1), columnas(i)+(-1:1)];
        válidos = vecindad(all(vecindad>0 & vecindad<=size(máscara)),:);
        if any(máscara(válidos(:,1),válidos(:,2)) == 0)
            puntosFrontera = [puntosFrontera; filas(i),columnas(i)];
        end
    end
end

function [punto, puntosFrontera] = obtenerPuntoPrioritario(imagen, máscara, confianza, puntosFrontera)
    % Seleccionar el punto con mayor prioridad para restaurar
    if isempty(puntosFrontera)
        [~,idx] = max(confianza(:));
        punto = ind2sub(size(confianza),idx);
        return;
    end
    
    % Calcular término de datos (dirección del gradiente)
    [Gx,Gy] = gradient(double(rgb2gray(imagen)));
    G = cat(3,Gx,Gy);
    normales = cat(3,-Gy,Gx);  % Vector normal de línea de isofoto
    
    maxPrioridad = -inf;
    punto = [0,0];
    for i=1:size(puntosFrontera,1)
        fila = puntosFrontera(i,1);
        columna = puntosFrontera(i,2);
        
        % Calcular vector normal
        if fila==1 || fila==size(imagen,1) || columna==1 || columna==size(imagen,2)
            n = normales(:,:,1);  % Normal en el límite
        else
            n = normales(fila,columna,:);
        end
        
        % Calcular término de datos
        bloque = extraerBloque(imagen, columna, fila, tamBloque);
        bloqueConocido = extraerBloque(imagen, columna, fila, tamBloque) .* double(~máscara);
        D = 1 - ssim(bloqueConocido, bloque);
        
        % Calcular prioridad
        C = mean(confianza(max(1,fila-floor(tamBloque/2)):min(size(imagen,1),fila+floor(tamBloque/2)),...
                          max(1,columna-floor(tamBloque/2)):min(size(imagen,2),columna+floor(tamBloque/2))));
        P = C * D;
        
        if P > maxPrioridad
            maxPrioridad = P;
            punto = [fila,columna];
        end
    end
end

function [mejorX, mejorY] = encontrarCoincidencia(imagen, máscara, punto, tamBloque, ventanaBusqueda)
    % Buscar el mejor bloque coincidente dentro de la ventana de búsqueda
    [alto,ancho] = size(imagen);
    fila = punto(1); columna = punto(2);
    
    % Definir rango de búsqueda
    rangoFilaMin = max(1, fila-floor(ventanaBusqueda/2));
    rangoFilaMax = min(alto, fila+floor(ventanaBusqueda/2));
    rangoColMin = max(1, columna-floor(ventanaBusqueda/2));
    rangoColMax = min(ancho, columna+floor(ventanaBusqueda/2));
    
    minSSD = inf;
    mejorY = fila; mejorX = columna;
    
    for yy = rangoFilaMin:rangoFilaMax
        for xx = rangoColMin:rangoColMax
            if máscara(yy,xx) == 1
                continue;  % Omitir regiones faltantes
            end
            
            % Calcular SSD
            bloqueObjetivo = extraerBloque(imagen, columna, fila, tamBloque);
            bloqueCandidato = extraerBloque(imagen, xx, yy, tamBloque);
            bloqueMáscara = double(máscara(fila-floor(tamBloque/2):fila+floor(tamBloque/2),...
                                  columna-floor(tamBloque/2):columna+floor(tamBloque/2)));
            ssd = sum(sum((bloqueObjetivo - bloqueCandidato).^2 .* (1-bloqueMáscara)));
            
            if ssd < minSSD
                minSSD = ssd;
                mejorY = yy; mejorX = xx;
            end
        end
    end
end

function [imagen, máscara, confianza] = aplicarBloque(imagen, máscara, confianza, x, y, tamBloque)
    % Operación de restauración de bloque
    mitadBloque = floor(tamBloque/2);
    yMin = max(1, y-mitadBloque);
    yMax = min(size(imagen,1), y+mitadBloque);
    xMin = max(1, x-mitadBloque);
    xMax = min(size(imagen,2), x+mitadBloque);
    
    % Copiar contenido del bloque coincidente
    bloqueObjetivo = extraerBloque(imagen, y, x, tamBloque);
    bloqueMáscara = double(máscara(yMin:yMax, xMin:xMax));
    imagen(yMin:yMax, xMin:xMax,:) = imagen(yMin:yMax, xMin:xMax,:) .* (1-bloqueMáscara) + ...
                                 bloqueObjetivo .* bloqueMáscara;
    
    % Actualizar confianza
    confianza(yMin:yMax, xMin:xMax) = confianza(yMin:yMax, xMin:xMax) * 0.9;
    confianza(y,x) = 1;  % Establecer confianza del nuevo punto restaurado en 1
    
    % Actualizar máscara
    máscara(yMin:yMax, xMin:xMax) = 0;
end

function bloque = extraerBloque(imagen, x, y, tamBloque)
    % Extraer bloque de imagen
    mitad = floor(tamBloque/2);
    yMin = max(1, y-mitad);
    yMax = min(size(imagen,1), y+mitad);
    xMin = max(1, x-mitad);
    xMax = min(size(imagen,2), x+mitad);
    bloque = imagen(yMin:yMax, xMin:xMax,:);
end

二、Explicación Detallada de la Implementación

1. Flujo Principle del Algoritmo

El algoritmo de Criminisi se basa en el principio de propagaicón de estructura y textura. El proceso fundamental consiste en: primero identificar los puntos de frontera de la región dañada, luego calcular la prioridad de cada punto considerando la confianza y la estructura de la imagen, posteriormente buscar el bloque más similar en la región conocida, y finalmente copiar el contenido del bloque coincidente para completar la restauración.

2. Parámetros Clave

3. Análisis de Funciones Principales

(1) identificarFrontera()

Esta función detecta automáticamente los puntos de frontera de la máscara como puntos iniciales de restauración. El algoritmo examina si existe una región conocida en la vecindad de cada píxel de la máscara, incluyendo los 8 vecinos circundantes.

(2) obtenerPuntoPrioritario()

La prioridad se calcula mediante la fórmula fundamental:

P = C * D

Donde el término de confianza C representa el promedio de confianza de la región conocida circundante, mientras que el término de datos D corresponde al complemento de la similitud estructural (SSIM).

(3) encontrarCoincidencia()

La estrategia de coincidencia busca dentro de la ventana de búsqueda el bloque con el valor SSD mínimo. Una técnica de optimización importante es limitar el rango de búsqueda para evitar el recorrido de toda la imagen.

(4) aplicarBloque()

La estrategia de actualización implementa un decaimiento de confianza: la confianza de los bloques circundantes se multiplica por 0.9, mientras que el punto recién restaurado establece su confianza en 1.

三、Técnicas de Optimización

1. Estrategias de Aceleración

% Uso de imágenes integrales para acelerar cálculo SSD
function ssd = ssdRapido(objetivo, candidato, máscara)
    sumaObjetivo = integralImage(objetivo.^2 .* máscara);
    sumaCandidato = integralImage(candidato.^2 .* ~máscara);
    términoCruzado = integralImage(objetivo .* candidato .* máscara);
    ssd = sumaObjetivo + sumaCandidato - 2*términoCruzado;
end

2. Procesamiento de Imágenes a Color

% Procesamiento por canales (mantener consistencia de color)
for canal = 1:3
    imagen(:,:,canal) = criminisi_canal_unico(imagen(:,:,canal), máscara);
end

3. Protección de Bordes

% Agregar término de protección de bordes
máscaraBordes = edge(rgb2gray(imagen),'Canny');
confianza = confianza .* (1 + 2*máscaraBordes);

四、Comparación de Resultados Experimentales

1. Imágenes de Prueba

2. Métricas de Rendimiento

五、Ejemplos de Escenarios de Aplicación

1. Restauración de Fotografías Antiguas

% Cargar fotografía antigua
fotoAntigua = imread('foto_vieja.jpg');
% Crear máscara (marcar rayones manualmente)
máscara = crearMáscara(fotoAntigua);
% Ejecutar restauración
restaurada = criminisi(fotoAntigua, máscara);

2. Eliminación de Objetos en Video

% Leer video de entrada
video = VideoReader('entrada.mp4');
% Procesar cada fotograma
while tieneCuadro(video)
    cuadro = leerCuadro(video);
    máscara = detectarObjetoMovil(cuadro);
    restaurado = criminisi(cuadro, máscara);
    escribirCuadro(videoSalida, restaurado);
end

六、Solución de Problemas Comunes

1. Efecto de Bloques Visible

Solución: Aumentar el tamaño de la ventana de búsqueda (ventanaBusqueda=100) y utilizar coincidencia de bloques superpuestos (superposición=5).

2. Distorsión de Textura

Solución: Habilitar restauración multiescala.

% Proceso de restauración multiescala
for escala = [4,2,1]
    imagen = imresize(imagen, escala);
    máscara = imresize(máscara, escala);
    % Ejecutar restauración
    imagen = criminisi(imagen, máscara);
end
imagen = imresize(imagen, 1);

3. Velocidad de Ejecución Lenta

Plan de optimización: Utilizar aceleración GPU (requiere Parallel Computing Toolbox).

% Ejemplo de código con aceleración GPU
imagen_gpu = gpuArray(imagen);
máscara_gpu = gpuArray(máscara);
[imagen_gpu, máscara_gpu] = aplicarBloqueGPU(imagen_gpu, máscara_gpu);
imagen = gather(imagen_gpu);

七、Implementación de Funciones Extendidas

1. Restauración Interactiva

% Crear interfaz interactiva
figura = figure('MenuBar','none','ToolBar','none');
imshow(imagen); hold on;
regiónMáscara = imrect(gca);
set(regiónMáscara,'Color','yellow');

% Actualización de restauración en tiempo real
while true
    posición = getPosition(regiónMáscara);
    máscara = crearMáscaraRectangular(posición,imagen);
    restaurada = criminisi(imagen,Máscara);
    imshow(restaurada);
    drawnow;
end

2. Procesamiento por Lotes

% Procesar lote de imágenes de una carpeta
carpetaEntrada = 'imagenes/';
carpetaSalida = 'resultados/';
archivos = dir(fullfile(carpetaEntrada,'*.jpg'));
for i=1:length(archivos)
    imagen = imread(fullfile(carpetaEntrada,archivos(i).name));
    máscara = imread(fullfile(carpetaEntrada,archivos(i).name));
    restaurada = criminisi(imagen,Máscara);
    imwrite(restaurada,fullfile(carpetaSalida,archivos(i).name));
end

八、Referencias

1. Criminisi A, Pérez P, Toyama K. Object removal by exemplar-based inpainting[C]//IEEE Computer Society Conference on Computer Vision and Pattern Recognition. 2003, 2: 355-362.
2. Li B. Investigación sobre Algoritmos de Restauración de Imágenes basados en MATLAB[J]. Revista de la Universidad de Suzhou, 2015, 18(6): 2-5.
3. Zhang R. Restauración Profunda de Imágenes basada en FMM y Algoritmo Criminisi[J]. Modern Agricultural Machinery, 2020(1): 123-125.