Jak mogę obliczyć różnicę między dwoma obrazami?

Proste rozwiązanie:

Zakoduj obraz jako jpeg i poszukaj znaczącej zmiany w Rozmiar pliku .

Zaimplementowałem coś podobnego z miniaturkami wideo i miałem wiele sukcesów i skalowalności.

Możesz porównać dwa obrazy za pomocą funkcji z PIL .

import Image
import ImageChops

im1 = Image.open("splash.png")
im2 = Image.open("splash2.png")

diff = ImageChops.difference(im2, im1)

Obiekt diff jest obrazem, w którym każdy piksel jest wynikiem odejmowania wartości kolorów tego piksela na drugim obrazie od pierwszego obrazu. Używając obrazu diff możesz zrobić kilka rzeczy. Najprostszą z nich jest funkcja diff.getbbox(). Pokaże Ci minimalny prostokąt, który zawiera wszystkie zmiany między dwoma obrazami.

Możesz prawdopodobnie zaimplementować przybliżenia innych rzeczy wymienione tutaj przy użyciu funkcji z PIL, jak również.

Dwie popularne i stosunkowo proste metody to: (a) odległość euklidesowa już sugerowana lub (b) znormalizowana korelacja krzyżowa. Znormalizowana korelacja krzyżowa wydaje się być zauważalnie bardziej odporna na zmiany oświetlenia niż prosta korelacja krzyżowa. Wikipedia podaje wzór na znormalizowaną korelację krzyżową . Istnieją też bardziej wyrafinowane metody, ale wymagają one nieco więcej pracy.

Używając składni numpy,

dist_euclidean = sqrt(sum((i1 - i2)^2)) / i1.size

dist_manhattan = sum(abs(i1 - i2)) / i1.size

dist_ncc = sum( (i1 - mean(i1)) * (i2 - mean(i2)) ) / (
  (i1.size - 1) * stdev(i1) * stdev(i2) )

Zakładając, że i1 i i2 są 2D tablice obrazów w skali szarości.

Trywialna rzecz do wypróbowania:

Porównuj oba obrazy do małych miniaturek (np. 64 x 64) i porównaj miniatury piksel po pikselu z określonym progiem. Jeśli oryginalne obrazy są prawie takie same, ponownie próbkowane miniatury będą bardzo podobne lub nawet dokładnie takie same. Metoda ta zajmuje się hałasem, który może wystąpić zwłaszcza w scenach przy słabym oświetleniu. Może nawet lepiej, jeśli przejdziesz do skali szarości.

Zwracam się konkretnie do pytania, jak obliczyć, czy są one "wystarczająco różne". Zakładam, że możesz wymyślić, jak odjąć piksele jeden po drugim.

Po Pierwsze, chciałbym wziąć kilka obrazów z nic zmienia się, i dowiedzieć się maksymalną ilość, że każdy piksel zmienia tylko z powodu zmian w przechwytywaniu, szum w systemie obrazowania, artefakty kompresji JPEG, i moment za moment zmiany w oświetleniu. Być może przekonasz się, że różnice 1 lub 2 bitowe są można się spodziewać, nawet gdy nic się nie rusza.

Następnie dla" prawdziwego " testu, chcesz kryterium jak to:

• to samo, jeśli do P pikseli różnią się nie więcej niż E.

Więc, być może, jeśli E = 0.02, P = 1000, to oznacza (w przybliżeniu), że będzie "inaczej", jeśli każdy pojedynczy piksel zmieni się o więcej niż ~5 jednostek (zakładając obrazy 8-bitowe), lub jeśli więcej niż 1000 pikseli ma jakiekolwiek błędy w ogóle.

Jest to przeznaczona głównie jako dobra technika "triage", aby szybko zidentyfikuj obrazy, które są wystarczająco blisko, aby nie wymagały dalszej analizy. Obrazy, które "nie" może następnie bardziej do bardziej skomplikowanej / kosztownej techniki, która nie miałaby fałszywych alarmów, gdyby aparat potrząsnął trochę, na przykład, lub był bardziej wytrzymały na zmiany oświetlenia.

Prowadzę projekt open source, OpenImageIO , który zawiera narzędzie o nazwie "idiff", które porównuje różnice z takimi progami (nawet bardziej rozbudowanymi). Nawet jeśli nie chcesz używać tego oprogramowania, może zajrzysz do źródła, żeby zobaczyć, jak to zrobiliśmy. Jest używany komercyjnie dość dużo i ta technika progowania została opracowana tak, że możemy mieć zestaw testów dla renderowania i przetwarzania obrazu oprogramowania ,z "obrazów referencyjnych", które mogą mieć małe różnice od platformy do platformy lub jak zrobiliśmy drobne poprawki do algorytmów tha, więc chcieliśmy" dopasowanie w tolerancji " operacji.

Większość udzielonych odpowiedzi Nie dotyczy poziomów oświetlenia.

Chciałbym najpierw normalizować obraz do standardowego poziomu światła przed wykonaniem porównania.

Czy widziałeś algorytm wyszukiwania podobnych obrazów pytanie? Sprawdź, aby zobaczyć sugestie.

Sugerowałbym transformację falkową Twoich ramek (napisałem do tego rozszerzenie C za pomocą transformacji Haara); następnie, porównując indeksy największych (proporcjonalnie) współczynników falkowych między dwoma obrazami, powinieneś uzyskać numeryczne przybliżenie podobieństwa.

Miałem podobny problem w pracy, przepisywałem nasz punkt końcowy transformacji obrazu i chciałem sprawdzić, czy nowa wersja produkuje to samo lub prawie to samo wyjście co stara wersja. Więc napisałem to:

Https://github.com/nicolashahn/diffimg

, który działa na obrazach o tej samej wielkości i na poziomie piksela, mierzy różnicę wartości w każdym kanale: R, G, B (, A), bierze średnią różnicę tych kanałów, a następnie uśrednia różnica w stosunku do wszystkich pikseli i Zwraca współczynnik.

Na przykład, przy obrazie 10x10 białych pikseli i tym samym obrazie, ale jeden piksel zmienił się na czerwony, różnica w tym pikselu wynosi 1/3 lub 0,33... (RGB 0,0,0 vs 255,0,0) i dla wszystkich innych pikseli wynosi 0. Razem 100 pikseli, 0,33.../ 100 = a ~ 0,33% różnicy w obrazie.

Wierzę, że to będzie działać idealnie dla projektu OP (zdaję sobie sprawę, że jest to bardzo stary post teraz, ale post dla przyszłych StackOverflowers, którzy również chcą porównać obrazy w Pythonie).

Przepraszam, jeśli jest za późno, aby odpowiedzieć, ale ponieważ robię coś podobnego, pomyślałem, że mogę się jakoś przyczynić.

Może w OpenCV przydałoby się dopasowanie szablonu. Zakładając, że używasz kamery internetowej, jak powiedziałeś:

1. Uprość obrazy (może?)
2. Zastosuj dopasowanie szablonu i sprawdź max_val za pomocą minMaxLoc

Wskazówka: max_val (lub min_val w zależności od użytej metody) da ci liczby, duże liczby. Aby uzyskać różnicę w procentach użyj dopasowania szablonu z tym samym obrazem - wynik będzie twój 100%.

Pseudo kod na przykładzie:

previous_screenshot = ...
current_screenshot = ...

# simplify both images somehow

# get the 100% corresponding value
res = matchTemplate(previous_screenshot, previous_screenshot, TM_CCOEFF)
_, hundred_p_val, _, _ = minMaxLoc(res)

# hundred_p_val is now the 100%

res = matchTemplate(previous_screenshot, current_screenshot, TM_CCOEFF)
_, max_val, _, _ = minMaxLoc(res)

difference_percentage = max_val / hundred_p_val

# the tolerance is now up to you

Odległość od Ziemi może być dokładnie tym, czego potrzebujesz. Może to być abit ciężki do wdrożenia w czasie rzeczywistym.

A co z obliczeniem odległości Manhattanu dwóch obrazów? To daje wartości n * N. Następnie możesz zrobić coś takiego jak średnia wiersza, aby zmniejszyć do wartości n i funkcji nad tym, aby uzyskać jedną pojedynczą wartość.

[[0]] mam sporo szczęścia ze zdjęciami jpg zrobionymi tym samym aparatem na statywie przez (1) znaczne uproszczenie (jak przejście z 3000 pikseli szerokości do 100 pikseli szerokości lub nawet mniej) (2) spłaszczenie każdej tablicy jpg w jeden wektor (3) parami korelujące obrazy sekwencyjne z prostym algorytmem korelacji, aby uzyskać współczynnik korelacji (4) kwadratowy współczynnik korelacji, aby uzyskać R-kwadrat (tj. ułamek zmienności w jednym obrazie wyjaśniony zmiennością w następnym) (5) ogólnie w moja aplikacja jeśli R-kwadrat

To jest solidne i szybkie w mojej implementacji (Mathematica 7)

Warto pobawić się tą częścią obrazu, którą jesteś zainteresowany i skupić się na tym, przycinając Wszystkie zdjęcia do tego małego obszaru, w przeciwnym razie pominięta zostanie odległa od kamery, ale ważna zmiana.

Nie wiem jak używać Pythona, ale jestem pewien, że też nie?

Możesz obliczyć histogram obu obrazów, a następnie obliczyć współczynnik Bhattacharyya , jest to bardzo szybki algorytm i użyłem go do wykrywania zmian ujęć w filmie krykieta (w C za pomocą openCV)

Zobacz jak Haar-daemon jest zaimplementowany przez ISK-daemon . Możesz użyć kodu Imgdb C++, aby obliczyć różnicę między obrazami w locie:

ISK-daemon jest serwerem bazodanowym typu open source, który umożliwia dodawanie obrazów opartych na treści (wizualnych)do dowolnej strony internetowej lub oprogramowania.

Ta technologia pozwala użytkownikom dowolnej strony internetowej lub oprogramowania związanego z obrazem na szkic w widżecie, który obraz chcą znaleźć i na który strona internetowa odpowiada im najbardziej podobne obrazy lub po prostu poprosić o Więcej podobnych zdjęć na każdej stronie szczegółów obrazu.

Miałem ten sam problem i napisałem prosty moduł Pythona, który porównuje dwa obrazy tej samej wielkości za pomocą ImageChops pillow ' a do utworzenia czarno-białego obrazu różnicowego i podsumowania wartości histogramu.

Możesz uzyskać ten wynik bezpośrednio lub wartość procentową w porównaniu do pełnego porównania czerń i biel.

Zawiera również prostą funkcję is_equal, z możliwością podania rozmytego progu pod (i włącznie) obrazem przechodzi jako równy.

Podejście nie jest bardzo rozbudowany, ale może jest przydatny dla innych, którzy zmagają się z tym samym problemem.

Https://pypi.python.org/pypi/imgcompare/

Nieco bardziej pryncypialnym podejściem jest użycie globalnego deskryptora do porównywania obrazów, takich jak GIST lub CENTRIST. Funkcja hash, jak opisano tutaj, również dostarcza podobnego rozwiązania.

Kolejny ładny, prosty sposób na zmierzenie podobieństwa między dwoma obrazami:

import sys
from skimage.measure import compare_ssim
from skimage.transform import resize
from scipy.ndimage import imread

# get two images - resize both to 1024 x 1024
img_a = resize(imread(sys.argv[1]), (2**10, 2**10))
img_b = resize(imread(sys.argv[2]), (2**10, 2**10))

# score: {-1:1} measure of the structural similarity between the images
score, diff = compare_ssim(img_a, img_b, full=True)
print(score)

Jeśli inni są zainteresowani bardziej wydajnym sposobem porównywania podobieństwa obrazów, przygotowałemtutorial i webapp do pomiaru i wizualizacji podobnych obrazów za pomocą Tensorflow.

import os
from PIL import Image
from PIL import ImageFile
import imagehash

#just use to the size diferent picture
def compare_image(img_file1, img_file2):
    if img_file1 == img_file2:
        return True
    fp1 = open(img_file1, 'rb')
    fp2 = open(img_file2, 'rb')

    img1 = Image.open(fp1)
    img2 = Image.open(fp2)

    ImageFile.LOAD_TRUNCATED_IMAGES = True
    b = img1 == img2

    fp1.close()
    fp2.close()

    return b





#through picturu hash to compare
def get_hash_dict(dir):
    hash_dict = {}
    image_quantity = 0
    for _, _, files in os.walk(dir):
        for i, fileName in enumerate(files):
            with open(dir + fileName, 'rb') as fp:
                hash_dict[dir + fileName] = imagehash.average_hash(Image.open(fp))
                image_quantity += 1

    return hash_dict, image_quantity

def compare_image_with_hash(image_file_name_1, image_file_name_2, max_dif=0):
    """
    max_dif: The maximum hash difference is allowed, the smaller and more accurate, the minimum is 0.
    recommend to use
    """
    ImageFile.LOAD_TRUNCATED_IMAGES = True
    hash_1 = None
    hash_2 = None
    with open(image_file_name_1, 'rb') as fp:
        hash_1 = imagehash.average_hash(Image.open(fp))
    with open(image_file_name_2, 'rb') as fp:
        hash_2 = imagehash.average_hash(Image.open(fp))
    dif = hash_1 - hash_2
    if dif < 0:
        dif = -dif
    if dif <= max_dif:
        return True
    else:
        return False


def compare_image_dir_with_hash(dir_1, dir_2, max_dif=0):
    """
    max_dif: The maximum hash difference is allowed, the smaller and more accurate, the minimum is 0.

    """
    ImageFile.LOAD_TRUNCATED_IMAGES = True
    hash_dict_1, image_quantity_1 = get_hash_dict(dir_1)
    hash_dict_2, image_quantity_2 = get_hash_dict(dir_2)

    if image_quantity_1 > image_quantity_2:
        tmp = image_quantity_1
        image_quantity_1 = image_quantity_2
        image_quantity_2 = tmp

        tmp = hash_dict_1
        hash_dict_1 = hash_dict_2
        hash_dict_2 = tmp

    result_dict = {}

    for k in hash_dict_1.keys():
        result_dict[k] = None

    for dif_i in range(0, max_dif + 1):
        have_none = False

        for k_1 in result_dict.keys():
            if result_dict.get(k_1) is None:
                have_none = True

        if not have_none:
            return result_dict

        for k_1, v_1 in hash_dict_1.items():
            for k_2, v_2 in hash_dict_2.items():
                sub = (v_1 - v_2)
                if sub < 0:
                    sub = -sub
                if sub == dif_i and result_dict.get(k_1) is None:
                    result_dict[k_1] = k_2
                    break
    return result_dict


def main():
    print(compare_image('image1\\815.jpg', 'image2\\5.jpg'))
    print(compare_image_with_hash('image1\\815.jpg', 'image2\\5.jpg', 6))
    r = compare_image_dir_with_hash('image1\\', image2\\', 10)
    for k in r.keys():
        print(k, r.get(k))


if __name__ == '__main__':
    main()

• Wyjście:

  False
  True
  image2\5.jpg image1\815.jpg
  image2\6.jpg image1\819.jpg
  image2\7.jpg image1\900.jpg
  image2\8.jpg image1\998.jpg
  image2\9.image1\1012.jpg. jpg
  
  

• Przykładowe zdjęcia:

  • 815.. jpg
    

  • 5.. jpg
    

Myślę, że można po prostu obliczyć odległość euklidesową (tj. sqrt (suma kwadratów różnic, piksel po pikselu)) pomiędzy luminancją obu obrazów i uznać je za równe, Jeśli mieści się to pod pewnym empirycznym progiem. I lepiej zrób to zawijając funkcję C.