Implementacja wykrywacza naroży Harris

Question

Wprowadzam wykrywacz narożny Harris do celów edukacyjnych, ale utknąłem w części odpowiedzi Harris. Zasadniczo co robie, jest

1. Oblicz gradienty natężenia obrazu, w kierunku X i kierunku Y
wyjście
2. Plama z (1)
3. Oblicz Harris odpowiedzi na wyjście (2)
4. Zmniejsz nie-maksymy na wyjściu (3) w otoczeniu 3x3 i wyjściu progowym

1 i 2 wydają się działać poprawnie; jednak otrzymuję bardzo małe wartości jako odpowiedź Harrisa i żaden punkt nie osiąga progu. Wejście to standardowa fotografia plenerowa.

[...] 
[Ix, Iy] = intensityGradients(img); 
g = fspecial('gaussian'); 
Ix = imfilter(Ix, g); 
Iy = imfilter(Iy, g); 
H = harrisResponse(Ix, Iy); 
[...] 

function K = harrisResponse(Ix, Iy) 
    max = 0; 
    [sy, sx] = size(Ix); 
    K = zeros(sy, sx); 
    for i = 1:sx, 
     for j = 1:sy, 
      H = [Ix(j,i) * Ix(j,i), Ix(j,i) * Iy(j,i) 
       Ix(j,i) * Iy(j,i), Iy(j,i) * Iy(j,i)]; 
      K(j,i) = det(H)/trace(H); 
      if K(j,i) > max, 
       max = K(j,i); 
      end 
     end 
    end 
    max 
end 

Dla przykładowego obrazu maks. Kończy się 6,4163e-018, co wydaje się zbyt niskie.

Answer 1

Narożnik w wykrywaniu narożników Harrisa definiowany jest jako "piksel najwyższej wartości w regionie" (zwykle 3X3 lub 5x5), więc komentarz o braku punktu osiągającego "próg" wydaje mi się dziwny. Po prostu zbieraj wszystkie piksele, które mają wyższą wartość niż wszystkie inne piksele w otaczającej je okolicy 5x5.

Poza tym: nie jestem w 100% pewien, ale myślę, że powinno być:

K(j,i) = det(H) - lambda*(trace(H)^2) Gdzie lambda jest stałą dodatnią, która działa w Twoim przypadku (i Harris zaproponował wartość wynosi 0,04).

W ogólnym jedynym rozsądnym momencie filtrować wejście jest przed tym momencie:

[Ix, Iy] = intensityGradients(img);

Filtrowanie Ix2, Iy2 i Ixy nie ma sensu do mnie.

więcej, myślę, że przykładowy kod jest niewłaściwy tutaj (czy funkcja harrisResponse mają dwa lub trzy zmienne wejściowe):

H = harrisResponse(Ix2, Ixy, Iy2); 
[...] 

function K = harrisResponse(Ix, Iy) 

Answer 2

Proponowana realizacja jest strasznie niewydajne. Pozwala start po obliczeniu gradientów (które mogą być również zoptymalizowane)

A = Ix.^2; 
B = Iy.^2; 
C = (Ix.*Iy).^4; 
lambda = 0.04; 

H = (A.*B - C) - lambda*(A+B).^2; 

% if you really need max: 
max(H(:)) 

żadnych pętli wymagany, ponieważ Matlab znosi pętle.

Answer 3

Jest to funkcja dostępna w Przyborniku systemu Computer Vision pod numerem detectHarrisFeatures.

Answer 4

zasadzie detekcji rogu Harris będzie mieć 5 etapów:

1. Gradient obliczeń
2. Gaussa wygładzania
3. Harris miara obliczenie
4. dla maksymalnego tłumienia
5. Progowanie

Jeśli wdrażasz w MATLAB, będzie łatwo zrozumieć algorytm i uzyskać wyniki.

Poniższy kod MATLAB może pomóc w rozwiązywaniu wątpliwości:

% Step 1: Compute derivatives of image 
Ix = conv2(im, dx, 'same'); 
Iy = conv2(im, dy, 'same'); 

% Step 2: Smooth space image derivatives (gaussian filtering) 
Ix2 = conv2(Ix .^ 2, g, 'same'); 
Iy2 = conv2(Iy .^ 2, g, 'same'); 
Ixy = conv2(Ix .* Iy, g, 'same'); 

% Step 3: Harris corner measure 
harris = (Ix2 .* Iy2 - Ixy .^ 2) ./ (Ix2 + Iy2); 

% Step 4: Find local maxima (non maximum suppression) 
mx = ordfilt2(harris, size .^ 2, ones(size)); 

% Step 5: Thresholding 
harris = (harris == mx) & (harris > threshold); 

Answer 5

Rozwiązanie że realizowane z pytona, to działa na mnie Mam nadzieję, że znajdziesz to, czego szukasz

import numpy as np 
import matplotlib.pyplot as plt 
from PIL.Image import * 
from scipy import ndimage 

def imap1(im): 
    print('testing the picture . . .') 
    a = Image.getpixel(im, (0, 0)) 
    if type(a) == int: 
     return im 
    else: 
     c, l = im.size 
     imarr = np.asarray(im) 
     neim = np.zeros((l, c)) 
     for i in range(l): 
      for j in range(c): 
       t = imarr[i, j] 
       ts = sum(t)/len(t) 
       neim[i, j] = ts 
     return neim 

def Harris(im): 
    neim = imap1(im) 
    imarr = np.asarray(neim, dtype=np.float64) 
    ix = ndimage.sobel(imarr, 0) 
    iy = ndimage.sobel(imarr, 1) 
    ix2 = ix * ix 
    iy2 = iy * iy 
    ixy = ix * iy 
    ix2 = ndimage.gaussian_filter(ix2, sigma=2) 
    iy2 = ndimage.gaussian_filter(iy2, sigma=2) 
    ixy = ndimage.gaussian_filter(ixy, sigma=2) 
    c, l = imarr.shape 
    result = np.zeros((c, l)) 
    r = np.zeros((c, l)) 
    rmax = 0 
    for i in range(c): 
     print('loking for corner . . .') 
     for j in range(l): 
      print('test ',j) 
      m = np.array([[ix2[i, j], ixy[i, j]], [ixy[i, j], iy2[i, j]]], dtype=np.float64) 
      r[i, j] = np.linalg.det(m) - 0.04 * (np.power(np.trace(m), 2)) 
      if r[i, j] > rmax: 
       rmax = r[i, j] 
    for i in range(c - 1): 
     print(". .") 
     for j in range(l - 1): 
      print('loking') 
      if r[i, j] > 0.01 * rmax and r[i, j] > r[i-1, j-1] and r[i, j] > r[i-1, j+1]\ 
            and r[i, j] > r[i+1, j-1] and r[i, j] > r[i+1, j+1]: 
       result[i, j] = 1 

    pc, pr = np.where(result == 1) 
    plt.plot(pr, pc, 'r+') 
    plt.savefig('harris_test.png') 
    plt.imshow(im, 'gray') 
    plt.show() 
    # plt.imsave('harris_test.png', im, 'gray') 

im = open('chess.png') 
Harris(im)