두 이미지 간의 차이를 어떻게 정량화할 수 있나요?

https://stackoverflow.com/questions/189943

06-07-2019
|

문제

제가 하고 싶은 일은 다음과 같습니다.

정기적으로 웹캠으로 사진을 찍고 있어요.일종의 시간 경과 같은 것입니다.그러나 실제로 아무것도 변하지 않았다면 즉 그림은 거의 외모 마찬가지로 최신 스냅샷을 저장하고 싶지 않습니다.

차이를 정량화하는 방법이 있을 것으로 생각되며 경험적으로 임계값을 결정해야 합니다.

완벽함보다는 단순함을 추구합니다.나는 파이썬을 사용하고 있습니다.

해결책

일반적인 생각

옵션 1:두 이미지를 배열로 로드합니다(scipy.misc.imread) 요소별(픽셀별) 차이를 계산합니다.차이의 표준을 계산합니다.

옵션 2:두 이미지를 모두 로드합니다.히스토그램과 같이 각각에 대한 일부 특징 벡터를 계산합니다.이미지가 아닌 특징 벡터 사이의 거리를 계산합니다.

그러나 먼저 내려야 할 몇 가지 결정이 있습니다.

질문

먼저 다음 질문에 답해야 합니다.

같은 모양과 크기의 이미지인가요?

그렇지 않은 경우 크기를 조정하거나 잘라야 할 수도 있습니다.PIL 라이브러리는 Python에서 이를 수행하는 데 도움이 됩니다.

동일한 설정, 동일한 장치로 촬영한 경우 아마도 동일할 것입니다.
이미지가 잘 정렬되어 있나요?

그렇지 않은 경우 먼저 상호 상관을 실행하여 최상의 정렬을 찾을 수 있습니다.SciPy에는 이를 수행하는 기능이 있습니다.

카메라와 장면이 정지되어 있으면 이미지가 잘 정렬될 가능성이 높습니다.
이미지의 노출은 항상 동일합니까?(명도/대비가 동일한가요?)

그렇지 않다면 원할 수도 있습니다. 정상화하다 이미지.

하지만 조심하세요. 어떤 상황에서는 이것이 좋은 것보다 나쁜 것이 더 많을 수도 있습니다.예를 들어, 어두운 배경에 있는 하나의 밝은 픽셀은 정규화된 이미지를 매우 다르게 만듭니다.
색상 정보가 중요한가요?

색상 변화를 확인하려면 회색조 이미지에서처럼 스칼라 값이 아닌 점당 색상 값의 벡터를 사용하면 됩니다.이러한 코드를 작성할 때는 더 많은 주의가 필요합니다.
이미지에 뚜렷한 가장자리가 있습니까?이사할 가능성이 있나요?

그렇다면 가장자리 감지 알고리즘을 먼저 적용할 수 있습니다(예:Sobel 또는 Prewitt 변환으로 기울기를 계산하고 일부 임계값을 적용한 다음 첫 번째 이미지의 가장자리를 두 번째 이미지의 가장자리와 비교합니다.
이미지에 노이즈가 있나요?

모든 센서는 어느 정도의 노이즈로 이미지를 오염시킵니다.저가형 센서는 노이즈가 더 많습니다.이미지를 비교하기 전에 약간의 노이즈 감소를 적용할 수 있습니다.Blur는 여기서 가장 간단한(그러나 최고는 아님) 접근 방식입니다.
어떤 변화를 알아차리고 싶나요?

이는 이미지 간의 차이에 사용할 표준 선택에 영향을 미칠 수 있습니다.

맨해튼 표준(절대값의 합) 또는 0 표준(0이 아닌 요소 수)을 사용하여 이미지가 얼마나 변경되었는지 측정해 보세요.전자는 이미지가 얼마나 떨어져 있는지 알려주고 후자는 픽셀 수가 얼마나 다른지 알려줍니다.

예

귀하의 이미지가 잘 정렬되어 있고 크기와 모양이 동일하며 노출이 다를 수 있다고 가정합니다.단순화를 위해 컬러(RGB) 이미지라도 회색조로 변환합니다.

다음 가져오기가 필요합니다.

import sys

from scipy.misc import imread
from scipy.linalg import norm
from scipy import sum, average

주요 기능, 두 개의 이미지 읽기, 회색조로 변환, 결과 비교 및 인쇄:

def main():
    file1, file2 = sys.argv[1:1+2]
    # read images as 2D arrays (convert to grayscale for simplicity)
    img1 = to_grayscale(imread(file1).astype(float))
    img2 = to_grayscale(imread(file2).astype(float))
    # compare
    n_m, n_0 = compare_images(img1, img2)
    print "Manhattan norm:", n_m, "/ per pixel:", n_m/img1.size
    print "Zero norm:", n_0, "/ per pixel:", n_0*1.0/img1.size

비교하는 방법. img1 그리고 img2 여기에 2D SciPy 배열이 있습니다.

def compare_images(img1, img2):
    # normalize to compensate for exposure difference, this may be unnecessary
    # consider disabling it
    img1 = normalize(img1)
    img2 = normalize(img2)
    # calculate the difference and its norms
    diff = img1 - img2  # elementwise for scipy arrays
    m_norm = sum(abs(diff))  # Manhattan norm
    z_norm = norm(diff.ravel(), 0)  # Zero norm
    return (m_norm, z_norm)

파일이 컬러 이미지인 경우 imread 3D 배열, 평균 RGB 채널(마지막 배열 축)을 반환하여 강도를 얻습니다.회색조 이미지(예: .pgm):

def to_grayscale(arr):
    "If arr is a color image (3D array), convert it to grayscale (2D array)."
    if len(arr.shape) == 3:
        return average(arr, -1)  # average over the last axis (color channels)
    else:
        return arr

정규화는 간단합니다. [0,255] 대신 [0,1]로 정규화하도록 선택할 수 있습니다. arr 여기서는 SciPy 배열이므로 모든 작업은 요소별로 수행됩니다.

def normalize(arr):
    rng = arr.max()-arr.min()
    amin = arr.min()
    return (arr-amin)*255/rng

실행 main 기능:

if __name__ == "__main__":
    main()

이제 이 모든 것을 스크립트에 넣고 두 개의 이미지에 대해 실행할 수 있습니다.이미지 자체를 비교하면 차이가 없습니다.

$ python compare.py one.jpg one.jpg
Manhattan norm: 0.0 / per pixel: 0.0
Zero norm: 0 / per pixel: 0.0

이미지를 흐리게 하고 원본과 비교하면 약간의 차이가 있습니다.

$ python compare.py one.jpg one-blurred.jpg 
Manhattan norm: 92605183.67 / per pixel: 13.4210411116
Zero norm: 6900000 / per pixel: 1.0

추신전체 비교.py 스크립트.

업데이트:관련 기술

질문은 프레임이 거의 동일할 가능성이 높고 특이한 것을 찾는 비디오 시퀀스에 관한 것이므로 관련성이 있을 수 있는 몇 가지 대체 접근 방식을 언급하고 싶습니다.

배경 빼기 및 분할(전경 개체 감지)
희박한 광학 흐름(움직임을 감지하기 위해)
이미지 대신 히스토그램이나 다른 통계 비교

"OpenCV 학습" 책 9장(이미지 부분 및 분할)과 10장(추적 및 동작)을 살펴보는 것이 좋습니다.전자는 배경 빼기 방법을 사용하도록 가르치고 후자는 광학 흐름 방법에 대한 일부 정보를 제공합니다.모든 메소드는 OpenCV 라이브러리에서 구현됩니다.Python을 사용하는 경우 OpenCV ≥ 2.3을 사용하는 것이 좋습니다. cv2 파이썬 모듈.

배경 빼기의 가장 간단한 버전:

배경의 모든 픽셀에 대한 평균값 μ와 표준편차 σ를 학습합니다.
현재 픽셀 값을 (μ-2σ,μ+2σ) 또는 (μ-σ,μ+σ) 범위와 비교합니다.

고급 버전에서는 모든 픽셀의 시계열을 고려하고 비정적 장면(예: 움직이는 나무나 풀)을 처리합니다.

광학 흐름의 개념은 두 개 이상의 프레임을 가져와 모든 픽셀(밀도 광학 흐름) 또는 그 중 일부(희소 광학 흐름)에 속도 벡터를 할당하는 것입니다.희소 광학 흐름을 추정하려면 다음을 사용할 수 있습니다. 루카스-카나데 방법 (OpenCV에서도 구현됩니다.)분명히 흐름이 많으면(속도 필드의 최대 값에 대한 평균이 높음) 프레임에서 무언가가 움직이고 있으며 후속 이미지가 더 다릅니다.

히스토그램을 비교하면 연속 프레임 간의 갑작스러운 변화를 감지하는 데 도움이 될 수 있습니다.이 접근 방식은 다음에서 사용되었습니다. Courbon 외, 2010:

연속 프레임의 유사성. 연속된 두 프레임 사이의 거리가 측정됩니다.너무 높으면 두 번째 프레임이 손상되어 이미지가 제거된다는 의미입니다.그만큼 쿨백-라이블러 거리, 또는 상호 엔트로피는 두 프레임의 히스토그램에 표시됩니다.

$d(p,q) = \sum_i p(i) \log (p(i)/q(i))$

어디 피 그리고 큐 프레임의 히스토그램이 사용됩니다.임계값은 0.2로 고정되어 있습니다.

다른 팁

간단한 해결책 :

이미지를 a로 인코딩합니다 JPEG 그리고 상당한 변화를 찾으십시오 파일 크기.

나는 비디오 썸네일과 비슷한 것을 구현했으며 많은 성공과 확장 성이있었습니다.

함수를 사용하여 두 이미지를 비교할 수 있습니다 필.

import Image
import ImageChops

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

diff = ImageChops.difference(im2, im1)

diff 객체는 모든 픽셀이 첫 번째 이미지에서 두 번째 이미지에서 해당 픽셀의 색상 값을 뺄 때의 결과 인 이미지입니다. Diff 이미지를 사용하면 몇 가지 작업을 수행 할 수 있습니다. 가장 간단한 것은입니다 diff.getbbox() 기능. 두 이미지 사이의 모든 변경 사항이 포함 된 최소 사각형을 알려줍니다.

PIL의 기능을 사용하여 여기에 언급 된 다른 것들의 근사치를 구현할 수 있습니다.

인기가 높고 비교적 간단한 두 가지 방법은 다음과 같습니다. (a) 유클리드 거리는 이미 제안한 것입니다. 또는 (b) 정규화 된 교차 상관. 정규화 된 교차 상관은 단순한 상호 상관보다 조명 변화에 눈에 띄게 강력한 경향이 있습니다. Wikipedia는 다음을위한 공식을 제공합니다 정규화 된 교차 상관. 더 정교한 방법도 존재하지만 훨씬 더 많은 작업이 필요합니다.

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 알고리즘이므로 "공차 내에서 일치"작업을 원했습니다.

주어진 대부분의 답변은 조명 레벨을 다루지 않습니다.

비교를하기 전에 먼저 이미지를 표준 조명 수준으로 정규화합니다.

두 이미지 사이의 유사성을 측정하는 또 다른 멋진 간단한 방법 :

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)

다른 사람들이 이미지 유사성을 비교하는보다 강력한 방법에 관심이 있다면 지도 시간 그리고 웹 앱 텐서 플로우를 사용하여 유사한 이미지를 측정하고 시각화하기 위해.

나는 직장에서 비슷한 문제가 있었고, 우리의 이미지 변환 엔드 포인트를 다시 작성하고 있었고 새 버전이 이전 버전과 동일하거나 거의 동일한 출력을 생성하고 있는지 확인하고 싶었습니다. 그래서 나는 이것을 썼다 :

https://github.com/nicolashahn/diffimg

동일한 크기의 이미지에서 작동하고 픽셀 당 수준에서 각 채널의 값 차이를 측정합니다 : r, g, b (, a)는 해당 채널의 평균 차이를 취한 다음 평균적 차이를 가져옵니다. 모든 픽셀 및 비율을 반환합니다.

예를 들어, 흰색 픽셀의 10x10 이미지와 동일한 이미지가 있지만 하나의 픽셀이 빨간색으로 바뀌었고, 그 픽셀의 차이는 1/3 또는 0.33입니다 ... (RGB 0,0,0 vs 255,0,0 ) 그리고 다른 모든 픽셀에서 0은 0입니다. 총 100 픽셀, 0.33 .../100 = A ~ 0.33% 이미지 차이.

나는 이것이 OP의 프로젝트에 완벽하게 작용할 것이라고 믿는다 (나는 이것이 지금 매우 오래된 게시물이지만 Python에서 이미지를 비교하려는 미래의 stackoverflowers를위한 게시).

당신은 봤어 유사한 이미지를 찾기위한 알고리즘 의문? 제안을 확인하려면 확인하십시오.

나는 당신의 프레임의 웨이블릿 변환을 제안합니다 (HAAR 변환을 사용하여 C 확장을 작성했습니다). 그런 다음 두 그림 사이의 가장 큰 (비례 적으로) 웨이블릿 요소의 인덱스를 비교하면 수치 적 유사성 근사가 있어야합니다.

답장하기에는 너무 늦었다면 사과하지만 비슷한 일을 해왔으므로 어떻게 든 기여할 수 있다고 생각했습니다.

OpenCV를 사용하면 템플릿 매칭을 사용할 수 있습니다. 당신이 말한대로 웹캠을 사용하고 있다고 가정합니다.

이미지를 단순화하십시오 (임계 값 어쩌면?)
템플릿 매칭을 적용하고 minmaxloc으로 max_val을 확인하십시오

팁 : 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

도움이되기를 바랍니다.

지구 이동 거리 정확히 필요한 것일 수 있습니다. 그것은 수 있습니다 약간 그래도 실시간으로 구현하는 것은 무겁습니다.

계산하는 것은 어떻습니까 맨해튼 거리 두 이미지 중. 그것은 당신에게 n*n 값을 제공합니다. 그런 다음 N 값으로 줄이기 위해 행 평균과 같은 작업을 수행하고 하나의 단일 값을 얻기 위해 그 기능을 수행 할 수 있습니다.

나는 (1) 크게 단순화하는 (3000 픽셀에서 너비로 100 픽셀로, 더 적은 픽셀로가는 것과 같이) (2) 각 JPG 어레이를 단일로 단일로 단순화하는 (1) 크게 단순화하는 JPG 이미지로 많은 운이 좋았습니다. 벡터 (3) 순차적 이미지와 단순한 상관 알고리즘과 상관 관계 계수를 얻기 위해 쌍 정리 이미지를 상관시키는 (4) R-Square를 얻기위한 상관 계수 (4) 제곱 상관 계수 (즉, 다음 이미지의 변동에 대한 변동의 분율) (5) 일반적으로 내 애플리케이션에서 내 응용 분야 r-square <0.9 인 경우 두 이미지가 다르고 그 사이에 어떤 일이 일어 났다고 말합니다.

이것은 내 구현에서 강력하고 빠릅니다 (Mathematica 7)

당신이 관심있는 이미지의 일부를 가지고 놀고, 모든 이미지를 그 작은 영역으로 자르면, 그렇지 않으면 카메라에서 멀리 떨어진 곳에서 멀리 떨어져 있지만 중요한 변화는 놓칠 것입니다.

파이썬을 사용하는 방법을 모르겠지만 상관 관계도 있다고 확신합니다.

두 이미지의 히스토그램을 계산 한 다음 Bhattacharyya 계수, 이것은 매우 빠른 알고리즘이며 크리켓 비디오의 샷 변경을 감지하는 데 사용했습니다 (OpenCV를 사용하여 C)

Haar Wavelets가 어떻게 구현되는지 확인하십시오 Isk-daemon. IMGDB C ++ 코드를 사용하여 즉시 이미지의 차이를 계산할 수 있습니다.

ISK-Daemon은 이미지 관련 웹 사이트 또는 소프트웨어에 컨텐츠 기반 (Visual) 이미지 검색을 추가 할 수있는 오픈 소스 데이터베이스 서버입니다.

이 기술을 사용하면 이미지 관련 웹 사이트 또는 소프트웨어의 사용자가 이미지를 찾아서 가장 유사한 이미지에 답장하고 각 이미지 세부 사항 페이지에서 더 유사한 사진을 요청하는 위젯에서 스케치 할 수 있습니다.

나는 같은 문제를 겪었고 Black/White Diff 이미지를 만들기 위해 Pillow의 ImageChop을 사용하여 동일한 크기의 두 개의 이미지를 비교하는 간단한 파이썬 모듈을 작성하고 히스토그램 값을 요약합니다.

이 점수를 직접 얻거나 전체 검은 색 대 백색 차이에 비해 백분율 값을 얻을 수 있습니다.

또한 단순한 IS_Equal 함수가 포함되어 있으며 이미지가 동일하게 전달되는 퍼지 임계 값을 제공 할 수 있습니다.

접근 방식은 매우 정교하지는 않지만 같은 문제로 어려움을 겪고있는 다른 사람들에게는 사용될 수 있습니다.

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

다소 원칙적인 접근 방식은 글로벌 디스크립터를 사용하여 GIST 또는 Centrist와 같은 이미지를 비교하는 것입니다. 설명 된대로 해시 함수 여기, 또한 유사한 솔루션도 제공합니다.

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 함수를 감싸는 것이 좋습니다.

두 이미지가 어떻게 생겼는지/얼마나 보이는지 평가하기위한 많은 지표가 있습니다.

나는 그것이 기술적 인 문제 외에 과학적 문제라고 생각하기 때문에 여기서 어떤 코드도 들어 가지 않을 것입니다.

일반적으로 문제는 이미지에 대한 인간의 인식과 관련이 있으므로 각 알고리즘에는 인간 시각 시스템 특성이 지원됩니다.

고전적인 접근 방식은 다음과 같습니다.

가시 차이 예측 변수 : 이미지 충실도 평가를위한 알고리즘 (https://www.spiedigitallibrary.org/conference-proceedings-of-spie/1666/0000/visible-differences-predictor-- an-algorithm-forthe-assessment-of/10.1117/12.135952.short?sso=1)

이미지 품질 평가 : 오류 가시성에서 구조적 유사성에 이르기까지 (http://www.cns.nyu.edu/pub/lcv/wang03-reprint.pdf)

FSIM : 이미지 품질 평가를위한 기능 유사성 지수 (https://www4.comp.polyu.edu.hk/~cslzhang/iqa/tip_iqa_fsim.pdf)

그중에서도 SSIM (이미지 품질 평가 : 오류 가시성에서 구조적 유사성에 이르기까지)은 계산하기가 가장 쉽고 계산하기가 쉽고 오버 헤드도 작습니다. "그라디언트 유사성을 기반으로 한 이미지 품질 평가"(https://www.semanticscholar.org/paper/image-quality-assessment--on-gradient-liu-lin/2b819bef80c02d5d4cb56f27b202535e119df988).

더 많은 다른 접근법이 있습니다. Google Scholar를보고 "시각적 차이", "이미지 품질 평가"등과 같은 것을 검색하십시오.

라이센스 : CC-BY-SA ~와 함께 속성

제휴하지 않습니다 StackOverflow