Algorytm porównywania obrazów

Zrobiłem to z porównaniem histogramu obrazu. Mój podstawowy algorytm był taki:

1. Podziel obraz na czerwony, zielony i niebieski
2. Utwórz znormalizowane histogramy dla czerwonego, zielonego i niebieskiego kanału i połącz je w wektor (r0...rn, g0...gn, b0...bn) gdzie n jest liczbą "wiadrów", 256 powinno wystarczyć
3. odjąć ten histogram od histogramu innego obrazu i obliczyć odległość

Oto jakiś kod z numpy i pil

r = numpy.asarray(im.convert( "RGB", (1,0,0,0, 1,0,0,0, 1,0,0,0) ))
g = numpy.asarray(im.convert( "RGB", (0,1,0,0, 0,1,0,0, 0,1,0,0) ))
b = numpy.asarray(im.convert( "RGB", (0,0,1,0, 0,0,1,0, 0,0,1,0) ))
hr, h_bins = numpy.histogram(r, bins=256, new=True, normed=True)
hg, h_bins = numpy.histogram(g, bins=256, new=True, normed=True)
hb, h_bins = numpy.histogram(b, bins=256, new=True, normed=True)
hist = numpy.array([hr, hg, hb]).ravel()

Jeśli masz dwa histogramy, można uzyskać odległość w ten sposób:

diff = hist1 - hist2
distance = numpy.sqrt(numpy.dot(diff, diff))

Jeśli oba obrazy są identyczne, odległość wynosi 0, im bardziej się różnią, tym większa odległość.

To działało całkiem dobrze dla zdjęć dla mnie, ale nie na grafice jak teksty i logo.

Naprawdę musisz lepiej sprecyzować pytanie, ale patrząc na te 5 obrazów, wszystkie organizmy wydają się być zorientowane w ten sam sposób. Jeśli tak jest zawsze, możesz spróbować wykonać znormalizowaną korelację krzyżową pomiędzy tymi dwoma obrazami i przyjąć wartość szczytową jako stopień podobieństwa. Nie znam znormalizowanej funkcji korelacji krzyżowej w Pythonie, ale istnieje podobna funkcja fftconvolve () i możesz wykonać kolistą korelację krzyżową yourself:

a = asarray(Image.open('c603225337.jpg').convert('L'))
b = asarray(Image.open('9b78f22f42.jpg').convert('L'))
f1 = rfftn(a)
f2 = rfftn(b)
g =  f1 * f2
c = irfftn(g)

To nie będzie działać tak, jak napisano, ponieważ obrazy mają różne rozmiary, a wyjście nie jest w ogóle ważone lub znormalizowane.

Położenie szczytowej wartości wyjścia wskazuje przesunięcie między dwoma obrazami, a wielkość szczytu wskazuje na podobieństwo. Powinien istnieć sposób na wagę/normalizację, abyś mógł odróżnić dobry mecz od słabego meczu.

To nie jest tak dobra odpowiedź, jak chcę, ponieważ nie mam wymyśliłem, jak go znormalizować, ale zaktualizuję go, jeśli to rozgryzę, i to da ci pomysł, aby się temu przyjrzeć.

Jeśli twój problem dotyczy przesuniętych pikseli, może powinieneś porównać z transformatą częstotliwości.

FFT powinno być OK (numpy ma implementację dla macierzy 2D), ale zawsze słyszę, że do tego typu zadań jest lepiej ^ _ ^

Jeśli chodzi o wydajność, jeśli wszystkie obrazy są tego samego rozmiaru, o ile dobrze pamiętam, pakiet FFTW stworzył wyspecjalizowaną funkcję dla każdego rozmiaru wejściowego FFT, dzięki czemu można uzyskać ładny wzrost wydajności ponownie używając tego samego kod... Nie wiem, czy numpy bazuje na FFTW, ale jeśli nie to może mógłbyś spróbować trochę tam zbadać.

import Image
import numpy
import sys

def main():
    img1 = Image.open(sys.argv[1])
    img2 = Image.open(sys.argv[2])

    if img1.size != img2.size or img1.getbands() != img2.getbands():
        return -1

    s = 0
    for band_index, band in enumerate(img1.getbands()):
        m1 = numpy.fft.fft2(numpy.array([p[band_index] for p in img1.getdata()]).reshape(*img1.size))
        m2 = numpy.fft.fft2(numpy.array([p[band_index] for p in img2.getdata()]).reshape(*img2.size))
        s += numpy.sum(numpy.abs(m1-m2))
    print s

if __name__ == "__main__":
    sys.exit(main())

Innym sposobem postępowania może być rozmycie obrazów, a następnie odjęcie wartości pikseli od obu obrazów. Jeśli różnica nie jest zerowa, możesz przesunąć jeden z obrazów o 1 px w każdym kierunku i porównać ponownie, jeśli różnica jest poniżej niż w poprzednim kroku można powtórzyć przesuwanie w kierunku gradientu i odejmowanie, aż różnica będzie niższa niż określony próg lub wzrośnie ponownie. Powinno to zadziałać, jeśli promień jądra rozmycia jest większy niż przesunięcie obrazów.

Możesz również wypróbować niektóre narzędzia, które są powszechnie używane w obiegu pracy z fotografią do mieszania wielu ekspozycji lub wykonywania panoram, takie jak narzędzia Pano .

Zrobiłem już jakiś kurs obróbki obrazu dawno temu i pamiętaj, że podczas dopasowywania Zwykle zaczynałem od tworzenia skali szarości obrazu, a następnie wyostrzania krawędzi obrazu, aby zobaczyć tylko krawędzie. Ty (oprogramowanie) możesz następnie przesuwać i odejmować obrazy, aż różnica będzie minimalna.

Jeśli różnica jest większa niż ustawiony treshold, obrazy nie są równe i możesz przejść do następnego. Obrazy z mniejszym treshold mogą być następnie analizowane.

I do pomyśl, że w najlepszym razie możesz radykalnie rozrzedzić możliwe mecze, ale będziesz musiał osobiście porównać możliwe Mecze, aby ustalić, że są naprawdę równe.

Naprawdę nie mogę pokazać kodu, jak to było dawno temu, i użyłem Khoros / Cantata do tego kursu.

Po pierwsze, korelacja jest bardzo intensywny procesor raczej niedokładna miara podobieństwa. Dlaczego nie po prostu przejść do sumy kwadratów, jeśli różnice między poszczególnymi pikselami?

Proste rozwiązanie, jeśli maksymalne przesunięcie jest ograniczone: Wygeneruj wszystkie możliwe przesunięte obrazy i znajdź ten, który najlepiej pasuje. Upewnij się, że obliczasz zmienną dopasowania (np. korrellację) tylko dla podzbioru pikseli, które mogą być dopasowane we wszystkich przesuniętych obrazach. Ponadto, Twoja maksymalna zmiana powinna być znacznie mniejszy niż rozmiar twoich zdjęć.

Jeśli chcesz użyć bardziej zaawansowanych technik przetwarzania obrazów, proponuję przyjrzeć się SIFT jest to bardzo potężna metoda ,która (teoretycznie) może prawidłowo dopasować elementy w obrazach niezależnie od tłumaczenia, obrotu i skali.

Myślę, że mógłbyś zrobić coś takiego:

• Oszacowanie przemieszczenia w pionie / poziomie obrazu referencyjnego w stosunku do obrazu porównawczego. a proste SAD (suma różnicy bezwzględnej) z wektorami ruchu.

• Przesuń obraz porównawczy odpowiednio

• Oblicz korelację Pearsona, którą próbowałeś wykonać

Pomiar przesunięcia nie jest trudny.

• Weź region (powiedzmy o 32x32) w obrazie porównawczym.
• Przesuń go o x pikseli w poziomie i y pikseli w pionie.
• Oblicz SAD (sumę różnicy bezwzględnej) w.R.T. oryginalny obraz
• Zrób to dla kilku wartości x i y w małym zakresie (-10, +10)
• Znajdź miejsce, w którym różnica jest minimalna
• Wybierz tę wartość jako wektor ruchu przesunięcia

Uwaga:

Jeśli SAD zbliża się bardzo wysoko dla wszystkich wartości x i y, to można i tak założyć, że obrazy są wysoko odmienny i przesunięcie pomiar nie jest konieczne.

Aby import działał poprawnie na moim Ubuntu 16.04 (stan na Kwiecień 2017), zainstalowałem Pythona 2.7 i oto one:

sudo apt-get install python-dev
sudo apt-get install libtiff5-dev libjpeg8-dev zlib1g-dev libfreetype6-dev liblcms2-dev libwebp-dev tcl8.6-dev tk8.6-dev python-tk
sudo apt-get install python-scipy
sudo pip install pillow

Potem zmieniłem import śnieżynki na te:

import scipy as sp
from scipy.ndimage import imread
from scipy.signal.signaltools import correlate2d as c2d

Jak wspaniale, że SNOWFLAKE ' s scripted pracował dla mnie 8 lat później!