OpenCV билинейная обратная выборка с нецелым масштабированием

Question

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

Я знаю, что вопрос уже задавался несколько раз, но большинство ответов, похоже, не соответствуют реализации OpenCV (например, этот ответ не верен при использовании OpenCV: https://math.stackexchange.com/questions/48903/2d-array-downsampling-and-upsampling-using-bilinear-interpolation).

Минимальная постановка задачи:

Я хочу уменьшить изображение с разрешением 4x4 до изображения с разрешением 3x3, используя билинейную интерполяцию. Я заинтересован в коэффициентах интерполяции.

Пример на python:

img = np.asarray([[ 1,  2,  3,  4],
                  [ 5,  6,  7,  8],
                  [ 9, 10, 11, 12],
                  [13, 14, 15, 16]]).astype(np.float32)

img_resized = cv2.resize(img, (3, 3), 0, 0, cv2.INTER_LINEAR).astype(np.float32)

print(img)
# [[ 1.  2.  3.  4.]
#  [ 5.  6.  7.  8.]
#  [ 9. 10. 11. 12.]
#  [13. 14. 15. 16.]]

print(img_resized)
# [[ 1.8333333  3.1666667  4.5      ]
#  [ 7.166667   8.5        9.833333 ]
#  [12.5       13.833333  15.166666 ]] 

Коэффициенты интерполяции:

После большого количества проб и ошибок я выяснил коэффициенты интерполяции, которые OpenCV использует для этого конкретного случая.

Для угловых точек изображения 3x3:

 1.8333333 = 25/36 *  1 + 5/36 *  2 + 5/36 *  5 + 1/36 *  6
 4.5000000 = 25/36 *  4 + 5/36 *  3 + 5/36 *  8 + 1/36 *  7
12.5000000 = 25/36 * 13 + 5/36 *  9 + 5/36 * 14 + 1/36 * 10
15.1666666 = 25/36 * 16 + 5/36 * 15 + 5/36 * 12 + 1/36 * 11

Для средних точек изображения 3х3:

8.5 = 1/4 * 6 + 1/4 * 7 + 1/4 * 10 + 1/4 * 11

Для оставшихся 4 точек изображения 3х3:

 3.1666667 = 5/12 *  2 + 5/12 *  3 + 1/12 *  6 + 1/12 *  7
 7.1666667 = 5/12 *  5 + 5/12 *  9 + 1/12 *  6 + 1/12 * 10
 9.8333333 = 5/12 *  8 + 5/12 * 12 + 1/12 *  7 + 1/12 * 11
13.833333  = 5/12 * 14 + 5/12 * 15 + 1/12 * 10 + 1/12 * 11

Вопрос:

Может кто-нибудь помочь мне разобраться в этих коэффициентах интерполяции? Как они рассчитываются? Я попытался прочитать исходный код функции cv :: resize (), но это мне не сильно помогло: S

Answer 1

Поиграв с различными тестовыми примерами, я думаю, что знаю ответ на вопрос, как OpenCV выбирает местоположения точек выборки. Как отметил @ChrisLuengo в комментарии, OpenCV, похоже, не применяет фильтр нижних частот перед понижающей дискретизацией, а использует только (би) линейную интерполяцию.

(возможно) Решение:

Давайте предположим, что у нас есть изображение 5x5, позиции пикселей которого представлены синими кружками на рисунке ниже. Теперь мы хотим уменьшить его до изображения 3x3 или 4x4, и нам нужно найти позиции образцов нового изображения с пониженной дискретизацией в исходной сетке изображений.

Похоже, что OpenCV использует пиксельное расстояние 1 для исходной сетки изображений и пиксельное расстояние (OLD_SIZE / NEW_SIZE), то есть здесь 5/3 и 5/4, для новой сетки изображений. Кроме того, он выравнивает обе сетки в центральной точке. Таким образом, алгоритмы детерминированной выборки OpenCV можно визуализировать следующим образом:

Визуализация от 5x5 до 3x3 :

Визуализация от 5x5 до 4x4 :

Пример кода (Python 2.7):

import numpy as np
import cv2


# 1. H_W is the height & width of the original image, using uniform H/W for this example
#    resized_H_W is the height & width of the resized image, using uniform H/W for this example

H_W = 5
resized_H_W = 4



# 2. Create original image & Get OpenCV resized image:

img = np.zeros((H_W, H_W)).astype(np.float32)

counter = 1

for i in range(0, H_W):
    for j in range(0, H_W):
        img[i, j] = counter
        counter += 1

img_resized_opencv = cv2.resize(img, (resized_H_W, resized_H_W), 0, 0, cv2.INTER_LINEAR).astype(np.float32)



# 3. Get own resized image:

img_resized_own = np.zeros((resized_H_W, resized_H_W)).astype(np.float32)

for i in range(0, resized_H_W):
    for j in range(0, resized_H_W):
        sample_x = (1.0 * H_W) / 2.0 - 0.50 + (i - (1.0 * resized_H_W - 1.0) / 2.0) * (1.0 * H_W) / (1.0 * resized_H_W)
        sample_y = (1.0 * H_W) / 2.0 - 0.50 + (j - (1.0 * resized_H_W - 1.0) / 2.0) * (1.0 * H_W) / (1.0 * resized_H_W)

        pixel_top_left  = img[int(np.floor(sample_x)), int(np.floor(sample_y))]
        pixel_top_right = img[int(np.floor(sample_x)), int(np.ceil(sample_y))]
        pixel_bot_left  = img[int(np.ceil(sample_x)),  int(np.floor(sample_y))]
        pixel_bot_right = img[int(np.ceil(sample_x)),  int(np.ceil(sample_y))]

        img_resized_own[i, j] = (1.0 - (sample_x - np.floor(sample_x))) * (1.0 - (sample_y - np.floor(sample_y))) * pixel_top_left  + \
                                (1.0 - (sample_x - np.floor(sample_x))) * (sample_y - np.floor(sample_y))         * pixel_top_right + \
                                (sample_x - np.floor(sample_x))         * (1.0 - (sample_y - np.floor(sample_y))) * pixel_bot_left  + \
                                (sample_x - np.floor(sample_x))         * (sample_y - np.floor(sample_y))         * pixel_bot_right



# 4. Print results:

print "\n"
print "Org. image: \n", img
print "\n"
print "Resized image (OpenCV): \n", img_resized_opencv
print "\n"
print "Resized image (own): \n", img_resized_own
print "\n"
print "MSE between OpenCV <-> Own: ", np.mean(np.square(img_resized_opencv - img_resized_own))
print "\n"

Отказ от ответственности:

Это только моя теория, которую я проверял с помощью ~ 10 контрольных примеров. Я не утверждаю, что это на 100% верно.