Как я могу оценить разницу между двумя изображениями?

простое решение:

кодировать изображение как jpeg и искать существенные изменения в размер.

я реализовал нечто подобное с миниатюрами видео, и имел большой успех и масштабируемость.

Вы можете сравнить два изображения с помощью функции пил.

import Image
import ImageChops

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

diff = ImageChops.difference(im2, im1)

объект diff-это изображение, в котором каждый пиксель является результатом вычитания значений цвета этого пикселя во втором изображении из первого изображения. Используя изображение diff, вы можете сделать несколько вещей. Самый простой из них-это

два популярных и относительно простых метода: (а) уже предложенное евклидово расстояние или (б) нормированная взаимная корреляция. Нормализованная взаимная корреляция имеет тенденцию быть заметно более устойчивой к изменениям освещения, чем простая взаимная корреляция. Википедия дает формулу для нормализованная взаимная корреляция. Существуют и более сложные методы, но они требуют гораздо больше работы.

используя 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) )

предполагая, что i1 и i2 являются 2D-массивы изображений в оттенках серого.

тривиальная вещь, чтобы попробовать:

пересчитайте оба изображения в небольшие эскизы (например, 64 x 64) и сравните эскизы пиксель за пикселем с определенным порогом. Если исходные изображения почти одинаковы, пересчитанные миниатюры будут очень похожи или даже точно такие же. Этот метод заботится о шуме, который может возникнуть особенно в условиях низкой освещенности сцены. Может быть даже лучше, если вы перейдете в оттенки серого.

Я обращаюсь конкретно к вопросу о том, как вычислить, если они "достаточно разные". Я предполагаю, что вы можете выяснить, как вычесть пиксели один за другим.

во-первых, я бы взял кучу картинок с ничего изменение и узнайте максимальную величину, которую любой пиксель изменяет только из-за изменений в захвате, шума в системе обработки изображений, артефактов сжатия JPEG и мгновенных изменений освещения. Возможно, вы найдете, что 1 или 2 бит различия следует ожидать даже тогда, когда ничто не движется.

тогда для" реального " теста вам нужен такой критерий:

• то же самое, если до p пикселей отличаются не более чем на E.

Так что, возможно, если E = 0.02, P = 1000, это будет означать (приблизительно), что он будет "другим", если какой-либо один пиксель изменится более чем на ~5 единиц (предполагая 8-битные изображения), или если более 1000 пикселей имели какие-либо ошибки вообще.

это предназначено главным образом как хороший метод "сортировки", чтобы быстро идентифицировать изображения, которые достаточно близки, чтобы не нуждаться в дальнейшем рассмотрении. Изображения, которые "терпят неудачу", могут тогда больше к более сложной/дорогой технике, которая не имела бы ложных срабатываний, если бы камера трясла бит, например, или была более устойчивой к изменениям освещения.

Я запускаю проект с открытым исходным кодом, OpenImageIO, который содержит утилиту под названием "idiff", которая сравнивает различия с порогами, подобными этому (еще более сложный, фактически.) Даже если вы не хотите использовать это программное обеспечение, вы можете посмотреть на источник, чтобы увидеть, как мы это сделали. Он используется в коммерческих целях совсем немного, и этот метод порогового значения был разработан таким образом, чтобы мы могли иметь набор тестов для рендеринга и обработки изображений с "эталонными изображениями", которые могут иметь небольшие различия от платформы к платформе или Поскольку мы сделали незначительные настройки для алгоритмов tha, поэтому мы хотели операцию "соответствие в пределах допуска".

большинство ответов, данных не будет иметь дело с уровнями освещения.

Я бы сначала нормализовал изображение до стандартного уровня освещенности, прежде чем делать сравнение.

видели алгоритм поиска похожих изображений вопрос? Проверьте это, чтобы увидеть предложения.

Я бы предложил вейвлет-преобразование ваших кадров (я написал расширение C для этого, используя преобразование Хаара); затем, сравнивая индексы самых больших (пропорционально) вейвлет-факторов между двумя изображениями, вы должны получить численное приближение подобия.

У меня была аналогичная проблема на работе, я переписывал нашу конечную точку преобразования изображения, и я хотел проверить, что новая версия производит тот же или почти тот же результат, что и старая версия. Поэтому я написал следующее:

https://github.com/nicolashahn/diffimg

который работает на изображениях одинакового размера и на уровне пикселей, измеряет разницу в значениях на каждом канале: R, G, B (, A), принимает среднюю разницу этих каналов, а затем усредняет разницу по всем пикселям и возвращает отношение.

например, с изображением 10x10 белых пикселей и тем же изображением, но один пиксель изменился на красный, разница в этом пикселе составляет 1/3 или 0,33... (RGB 0,0,0 vs 255,0,0) и у всех остальных пикселей равен 0. С 100 пикселами итого, 0,33.../100 = разница в изображении ~0.33%.

Я считаю, что это будет отлично работать для проекта OP (я понимаю, что это очень старый пост сейчас, но размещение для будущих StackOverflowers кто также хочет сравнить изображения в python).

Я извиняюсь, если это слишком поздно, чтобы ответить, но так как я делал что-то подобное, я думал, что могу как-то помочь.

возможно, с OpenCV вы могли бы использовать сопоставление шаблонов. Предполагая, что вы используете веб-камеру, как вы сказали:

1. упростить изображения (порог может быть?)
2. применить шаблон соответствия и проверить max_val с minMaxLoc

Совет: max_val (или min_val в зависимости от используемого метода) даст вам число, большое количество. Чтобы получить разницу в процентах, используйте шаблон, соответствующий одному и тому же изображению-результат будет вашим 100%.

псевдокод для примера:

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

надеюсь, что это помогает.

расстояние землеройных машин может быть именно то, что вам нужно. Это может быть abit тяжело реализовать в режиме реального времени, хотя.

насчет расчета Расстояние До Манхэттена из двух изображений. Это дает вам n * n значений. Затем вы можете сделать что-то вроде среднего значения строки, чтобы уменьшить до n значений и функции над этим, чтобы получить одно единственное значение.

Мне очень повезло с jpg-изображениями, сделанными с той же камерой на штативе (1) значительно упрощение (например, от 3000 пикселей в ширину до 100 пикселей в ширину или даже меньше) (2) сглаживание каждого массива jpg в один вектор (3) попарная корреляция последовательных изображений с помощью простого алгоритма корреляции для получения коэффициента корреляции (4) возведение в квадрат коэффициента корреляции для получения R-квадрата (т. е. доли изменчивости в одном изображении, объясненной вариацией в следующем) (5) в целом в моем приложении, если r-квадрат

Это надежный и быстрый в моей реализации (Mathematica 7)

стоит поиграть с той частью изображения, которая вас интересует, и сосредоточиться на этом, обрезав все изображения в эту небольшую область, иначе будет пропущено удаленное от камеры, но важное изменение.

Я не знаю, как использовать Python, но уверен, что он делает корреляций тоже нет?

вы можете вычислить гистограмму обоих изображений, а затем вычислить Коэффициент Бхаттачариа, это очень быстрый алгоритм, и я использовал его для обнаружения изменений выстрела в крикетном видео (в C с помощью openCV)

проверьте, как вейвлеты Хаара реализуются isk-daemon. Вы можете использовать его imgdb C++ код для расчета разницы между изображениями на лету:

isk-daemon-это сервер баз данных с открытым исходным кодом, способный добавлять поиск изображений на основе контента (визуальный) на любой веб-сайт или программное обеспечение, связанное с изображениями.

эта технология позволяет пользователям любого веб-сайта или программного обеспечения, связанного с изображениями, рисовать на виджете, какое изображение они хотят найти и иметь сайт отвечает на них самыми похожими изображениями или просто запрашивает больше похожих фотографий на каждой странице деталей изображения.

У меня была та же проблема, и я написал простой модуль python, который сравнивает два изображения одинакового размера с помощью ImageChops подушки для создания черно-белого изображения diff и суммирует значения гистограммы.

вы можете получить либо этот балл напрямую, либо процентное значение по сравнению с полной черной и белой разницей.

Он также содержит простую функцию is_equal, с возможностью подачи нечеткого порога под (и в том числе) изображение проходит как равное.

в подход не очень сложный, но, возможно, имеет смысл для других там борется с той же проблемой.

https://pypi.python.org/pypi/imgcompare/

несколько более принципиальным подходом является использование глобального дескриптора для сравнения изображений, таких как GIST или CENTRIST. Хэш-функция, как описано здесь, также обеспечивает аналогичное решение.

еще один хороший, простой способ измерить сходство между двумя изображениями:

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)

если другие заинтересованы в более мощном способе сравнения сходства изображений, я собрал учебник и web app для измерения и визуализации подобных изображений с помощью 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()

• выход:

  ложные
  Правда
  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.jpg image1\1012.jpg
  
  

• пример фото:

  • 815.формат jpg
    

  • 5.формат jpg
    

Я думаю, что вы можете просто вычислить евклидово расстояние (т. е. sqrt(сумма квадратов разностей, пиксель за пикселем)) между яркостью двух изображений и считать их равными, если это попадает под некоторый эмпирический порог. И вам лучше сделать это, обернув функцию C.