1. Fundamentos del Método
Ubmralización con Entropía Bidimensional
El método se basa en la probabilidad conjunta pij entre el nivel de gris i y el promedio del vecindario j. Se definen probabilidades acumuladas para el fondo (wf) y el objeto (wo). El objetivo es maximizar la entropía total H = Hf + Ho, calculada a partir de las regiones del histograma 2D.
Optimización con Algoritmo Genético (AG)
El AG se emplea para encontrar el par de umbrales óptimo. El flujo incluye: generación inicial de la población (vectores de dos umbrales), evaluación de cada individuo mediante la función de entropía, selección por torneo, cruce con distriubción simulada binaria, y mutación polinomial para generar descendencia. El proceso se repite hasta la convergencia.
2. Implementación del Algoritmo (MATLAB)
Cálculo de la Entropía Bidimensional
function H_total = calcularEntropia2D(Imagen, u1, u2)
[filas, cols] = size(Imagen);
hist2D = obtenerHistograma2D(Imagen, u1, u2); % Histograma conjunto
p = hist2D / (filas * cols);
prob_fondo = sum(p(1:u1, 1:u2));
prob_objeto = sum(p(u1+1:end, u2+1:end));
if prob_fondo == 0 || prob_objeto == 0
H_total = -Inf;
return;
end
H_f = -sum(sum(p(1:u1, 1:u2) .* log(p(1:u1, 1:u2) + eps)));
H_o = -sum(sum(p(u1+1:end, u2+1:end) .* log(p(u1+1:end, u2+1:end) + eps)));
H_total = H_f + H_o;
end
Programa Principal del AG
%% Configuración
tam_pob = 40; % Tamaño de la población
max_gen = 80; % Generaciones máximas
prob_cruce = 0.85; % Probabilidad de cruce
prob_mut = 0.06; % Probabilidad de mutación
rango_umbral = [0, 255]; % Rango válido de umbrales
%% Población inicial (cada fila es [u1, u2])
poblacion = randi(rango_umbral, tam_pob, 2);
%% Bucle evolutivo
for gen = 1:max_gen
% Evaluar aptitud (negativo de la entropía)
aptitud = zeros(tam_pob, 1);
for idx = 1:tam_pob
aptitud(idx) = -calcularEntropia2D(Imagen, poblacion(idx,1), poblacion(idx,2));
end
% Selección por torneo
seleccionados = seleccionTorneo(poblacion, aptitud);
% Cruce y mutación
descendencia = cruceSBX(seleccionados, prob_cruce);
descendencia = mutacionPolinomial(descendencia, prob_mut, rango_umbral);
% Actualizar población
poblacion = [seleccionados; descendencia];
end
% Extraer mejor solución
[~, pos] = min(aptitud);
umbrales_optimos = poblacion(pos, :);
3. Técnicas de Optimización
Cálculo Acelerado del Histograma 2D
function H2D = obtenerHistograma2D(Img, nu1, nu2)
tam_ventana = [5, 5];
filtro_media = fspecial('average', tam_ventana);
img_media = imfilter(Img, filtro_media, 'replicate');
% Acumular ocurrencias por parejas (gris, media)
indices = sub2ind([nu1+1, nu2+1], Img(:)+1, round(img_media(:))+1);
H2D = accumarray(indices, 1, [nu1+1, nu2+1]);
end
Mejoras en el AG
- Mutación adaptativa:
prob_mut = 0.04 + 0.08*(gen/max_gen); - Elitismo: Se conservan los mejores individuos de cada generación.
4. Aplicaciones Prácticas
Segmentación en Imágenes Médicas
% Carga de imagen médica
img_med = dicomread('resonancia.dcm');
img_gris = im2double(img_med);
% Optimización con AG
opciones_ag = optimoptions('ga', 'PopulationSize', 40, 'MaxGenerations', 80);
[umbrales, ~] = ga(@(x) -calcularEntropia2D(img_gris, x(1), x(2)), 2, ...
[], [], [], [], [0,255], [0,255], [], opciones_ag);
% Resultado de segmentación
mascara = img_gris > umbrales(1)/255;
Inspección Industrial en Tiempo Real
% Procesamiento de video
video_in = VideoReader('linea_produccion.avi');
while hasFrame(video_in)
fotograma = readFrame(video_in);
gris = im2double(rgb2gray(fotograma));
% Búsqueda rápida de umbrales
umbrales_actuales = ga(@(t) -calcularEntropia2D(gris, t(1), t(2)), 2);
segmentado = gris > umbrales_actuales(1)/255;
imshow(segmentado);
drawnow;
end
5. Ventajas del Enfoque Propuesto
- Robustez al ruido: La entropía bidimensional incorpora información contextual.
- Optimización global: El AG evita mínimos locales en el espacio de búsqueda.
- Extensibilidad: Puede adaptarse para múltiples umbrales o datos 3D.
6. Direcciones Futuras
- Extensión a volúmenes 3D (voxeles) para imágenes de tomografía.
- Integración con técnicas de aprendizaje profundo para inicializar la población.
- Imlpementación en hardware paralelo (GPU/FPGA) para aplicaciones embebidas.