A difference can be negative or positive.

For some number types, such as uint8 (unsigned 8-bit int), which can't be negative (have no sign), a negative value wraps around and the value would make no sense anymore. Other types can be signed (e.g. floats, signed ints), so a negative value can be represented correctly.

That's why cv.absdiff exists. It always gives you absolute differences, and those are okay to represent in an unsigned type.

Example with numbers: a = 4, b = 6. a-b should be -2, right?

That value, as an uint8, will wrap around to become 0xFE, or 254 in decimal. The 254 value has some relation to the true -2 difference, but it also incorporates the range of values of the data type (8 bits: 256 values), so it's really just "code".

cv.absdiff would give you the absolute of the difference (-2), which is 2.

Try norm function with NORM_L1 norm. C++ code:

double res = cv::norm(img1, img2, cv::NORM_L1);

difference * mask meaning that you are performing Matrix multiplication, in this case the height of difference must be the same as width of mask, if you want to perform an Element wise multiplication you should call difference.mul(mask)

If you subtract one image from the other it will give an image that only contains the areas where the second image has higher values than the first image.

Whereas absdiff will give the absolute difference between two images.

Yes, as far as I understood from the documentation of cv2.absdiff, it calculates the difference of pixels. to visualize i created a chessboard and shifted 1 row - that resulted in 100% difference.

import cv2
import imutils
import numpy as np


def calculate_difference_measure(img1: np.array, img2: np.array) -> float:
    diff = cv2.absdiff(img1, img2)
    thresh_diff = cv2.threshold(diff, 15, 255, cv2.THRESH_BINARY)[1]

    # Calculate the difference between the 2 images
    total_pixels = img1.shape[0] * img1.shape[1] * 1.0
    diff_on_pixels = cv2.countNonZero(thresh_diff) * 1.0
    difference_measure = diff_on_pixels / total_pixels
    print('difference_measure: {}'.format(difference_measure))
    return difference_measure


def main():
    chess1 = np.uint8(([150, 50] * 4 + [50, 150] * 4) * 4).reshape((8, 8))
    chess2 = imutils.translate(chess1.copy(), 0, 1)

    calculate_difference_measure(img1=chess1, img2=chess1)  # 0 diff
    calculate_difference_measure(img1=chess1, img2=chess2)  # 1 diff (100% different)

    chess1 = cv2.resize(chess1, (400, 400), interpolation=cv2.INTER_AREA)
    chess2 = cv2.resize(chess2, (400, 400), interpolation=cv2.INTER_AREA)
    cv2.imshow('original', chess1)
    cv2.imshow('translated', chess2)
    cv2.waitKey(0)
    return


if __name__ == '__main__':
    main()