Localização de padrão zebra na imagem (detecção da linha central da franja de luz estruturada da foto)

Estou trabalhando em um projeto em que franjas são projetadas contra um assunto e uma foto é tirada. A tarefa é encontrar as linhas centrais das franjas, que representam, matematicamente, a curva 3D de interseção entre o plano da franja e a superfície do objeto.

A foto é PNG (RGB), e as tentativas anteriores usavam escala de cinza e limiar de diferença para obter uma fotografia em preto e branco, semelhante a uma zebra, a partir da qual era fácil encontrar o ponto médio de cada coluna de pixel de cada franja. O problema é que, limitando e também medindo a altura média de uma coluna discreta de pixels, estamos tendo alguma perda e quantização de precisão, o que não é de todo desejado.

Minha impressão, observando as imagens, é que as linhas de centro poderiam ser mais contínuas (mais pontos) e mais suaves (não quantizadas) se fossem detectadas diretamente a partir da imagem sem limiar (RGB ou escala de cinza), por algum método de varredura estatística (alguma inundação / convolução iterativa, qualquer que seja).

Abaixo está uma imagem de amostra real:

Qualquer sugestão seria muito apreciada!

Sugiro as seguintes etapas:

1. Encontre um limite para separar o primeiro plano do segundo plano.
2. Para cada blob na imagem binária (uma faixa de zebra), para cada x, encontre o centro ponderado (por intensidade de pixel) na ydireção.
3. Possivelmente, suavize os yvalores, para remover o ruído.
4. Conecte os (x,y)pontos ajustando algum tipo de curva. Este artigo pode ajudá-lo. Você também pode ajustar um polinômio de alto nível, embora seja pior, na minha opinião.

Aqui está um código do Matlab que mostra as etapas 1,2 e 4. Ignorei a seleção automática de limite. Em vez disso, escolhi o manual th=40:

Estas são as curvas encontradas ao encontrar a média ponderada por coluna:

Estas são as curvas após o ajuste de um polinômio:

Aqui está o código:

function Zebra()
    im = imread('http://i.stack.imgur.com/m0sy7.png');
    im = uint8(mean(im,3));

    th = 40;
    imBinary = im>th;
    imBinary = imclose(imBinary,strel('disk',2));
    % figure;imshow(imBinary);
    labels = logical(imBinary);
    props =regionprops(labels,im,'Image','Area','BoundingBox');

    figure(1);imshow(im .* uint8(imBinary));
    figure(2);imshow(im .* uint8(imBinary));

    for i=1:numel(props)
        %Ignore small ones
        if props(i).Area < 10
            continue
        end
        %Find weighted centroids
        boundingBox = props(i).BoundingBox;
        ul = boundingBox(1:2)+0.5;
        wh = boundingBox(3:4);
        clipped = im( ul(2): (ul(2)+wh(2)-1), ul(1): (ul(1)+wh(1)-1) );
        imClip = double(props(i).Image) .* double(clipped);
        rows = transpose( 1:size(imClip,1) );
        %Weighted calculation
        weightedRows  = sum(bsxfun(@times, imClip, rows),1) ./ sum(imClip,1);
        %Calculate x,y
        x = ( 1:numel(weightedRows) ) + ul(1) - 1;
        y = ( weightedRows ) + ul(2) - 1;
        figure(1);
        hold on;plot(x,y,'b','LineWidth',2);
        try %#ok<TRYNC>
            figure(2);
            [xo,yo] = FitCurveByPolynom(x,y);
            hold on;plot(xo,yo,'g','LineWidth',2);
        end
        linkaxes( cell2mat(get(get(0,'Children'),'Children')) )
    end        
end

function [xo,yo] = FitCurveByPolynom(x,y)
   p = polyfit(x,y,15); 
   yo = polyval(p,x);
   xo = x;
end

Eu não usaria a imagem RGB. As imagens coloridas geralmente são criadas colocando um "Filtro Bayer" no sensor da câmera, o que geralmente reduz a resolução que você pode obter.

Se você usar a imagem em escala de cinza, acho que os passos que você descreveu (binarizar a imagem "zebra", encontrar a linha média) são um bom começo. Como passo final, eu gostaria

• Tome cada ponto na linha média que você encontrou
• pegue os valores em cinza dos pixels na linha "zebra" acima e abaixo
• ajuste uma parábola a esses valores de cinza usando mínimos quadrados médios
• o ápice dessa parábola é uma estimativa melhorada da posição da linha média

Aqui está ainda uma solução alternativa para o seu problema, modelando sua pergunta como um 'problema de otimização de caminho'. Embora seja mais complicado do que a solução simples de montagem de binarização e curva, é mais robusta na prática.

Do nível muito alto, devemos considerar esta imagem como um gráfico, onde

1. cada pixel da imagem é um nó neste gráfico

2. cada nó está conectado a outros nós, conhecidos como vizinhos, e essa definição de conexão é frequentemente referida como a topologia deste gráfico.

3. cada nó tem um peso (recurso, custo, energia ou o que você quiser chamar), refletindo a probabilidade de que esse nó esteja em uma linha central ideal que estamos procurando.

Desde que possamos modelar essa probabilidade, seu problema de encontrar 'as linhas centrais das franjas' passa a ser o problema para encontrar caminhos ótimos locais no gráfico , que podem ser efetivamente resolvidos pela programação dinâmica, por exemplo, o algoritmo Viterbi.

Aqui estão alguns profissionais da adoção dessa abordagem:

1. todos os seus resultados serão contínuos (diferente do método do limite que pode quebrar uma linha central em pedaços)

2. muitas liberdades para construir esse gráfico, você pode selecionar diferentes recursos e topologia de gráfico.

3. seus resultados são ótimos no sentido de otimizações de caminho

4. sua solução será mais robusta contra o ruído, porque, enquanto o ruído estiver igualmente distribuído entre todos os pixels, esses caminhos ideais permanecerão estáveis.

Aqui está uma breve demonstração da idéia acima. Como não uso nenhum conhecimento prévio para especificar quais são os possíveis nós iniciais e finais, simplesmente decodifico wrt todos os nós iniciais possíveis.

Para as terminações difusas, isso é causado pelo fato de estarmos procurando caminhos ideais para todos os nós finais possíveis. Como resultado, embora para alguns nós localizados em áreas escuras, o caminho destacado ainda seja o ideal local.

Para o caminho difuso, você pode suavizá-lo após encontrá-lo ou usar alguns recursos suavizados em vez da intensidade bruta.

É possível restaurar caminhos parciais alterando os nós inicial e final.

Não será difícil remover esses caminhos ótimos locais indesejados. Como temos a probabilidade de todos os caminhos após a decodificação de viterbi, e você pode usar vários conhecimentos anteriores (por exemplo, vemos que é verdade que precisamos apenas de um caminho ideal para aqueles que compartilham a mesma fonte).

Para mais detalhes, consulte o documento.

 Wu, Y.; Zha, S.; Cao, H.; Liu, D., & Natarajan, P.  (2014, February). A Markov Chain Line Segmentation Method for Text Recognition. In IS&T/SPIE 26th Annual Symposium on Electronic Imaging (DRR), pp. 90210C-90210C.

Aqui está um pequeno pedaço de código python usando para fazer o gráfico acima.

import cv2
import numpy as np
from matplotlib import pyplot
# define your image path
image_path = ;
# read in an image
img = cv2.imread( image_path, 0 );
rgb = cv2.imread( image_path, -1 );

# some feature to reflect how likely a node is in an optimal path
img = cv2.equalizeHist( img ); # equalization
img = img - img.mean(); # substract DC
img_pmax = img.max(); # get brightest intensity
img_nmin = img.min(); # get darkest intensity
# express our preknowledge
img[ img > 0 ] *= +1.0  / img_pmax; 
img[ img = 1 :
    prev_idx = vt_path[ -1 ].astype('int');
    vt_path.append( path_buffer[ prev_idx, time ] );
    time -= 1;
vt_path.reverse();    
vt_path = np.asarray( vt_path ).T;

# plot found optimal paths for every 7 of them
pyplot.imshow( rgb, 'jet' ),
for row in range( 0, h, 7 ) :
    pyplot.hold(True), pyplot.plot( vt_path[row,:], c=np.random.rand(3,1), lw = 2 );
pyplot.xlim( ( 0, w ) );
pyplot.ylim( ( h, 0 ) );

Pensei que deveria postar minha resposta, pois é um pouco diferente de outras abordagens. Eu tentei isso no Matlab.

• soma todos os canais e cria uma imagem, para que todos os canais tenham o mesmo peso
• executar fechamento morfológico e filtragem Gaussiana nesta imagem
• para cada coluna da imagem resultante, encontre o máximo local e construa uma imagem
• encontre os componentes conectados desta imagem

Uma desvantagem que vejo aqui é que essa abordagem não terá bom desempenho em algumas orientações das faixas. Nesse caso, temos que corrigir sua orientação e aplicar este procedimento.

Aqui está o código do Matlab:

im = imread('m0sy7.png');
imsum = sum(im, 3); % sum all channels
h = fspecial('gaussian', 3);
im2 = imclose(imsum, ones(3)); % close
im2 = imfilter(im2, h); % smooth
% for each column, find regional max
mx = zeros(size(im2));
for c = 1:size(im2, 2)
    mx(:, c) = imregionalmax(im2(:, c));
end
% find connected components
ccomp = bwlabel(mx);

Por exemplo, se você usar a coluna do meio da imagem, seu perfil deverá ficar assim: (em azul é o perfil. Em verde são os máximos locais)

E a imagem que contém os máximos locais para todas as colunas fica assim:

Aqui estão os componentes conectados (embora algumas faixas estejam quebradas, a maioria delas obtém uma região contínua):