Алгоритм адаптивного порога Брэдли

Ответ 1

Вы не можете создать интегральное изображение с PIL так, как вы это делаете, потому что изображение, в которое вы упаковываете данные, не может принимать значения свыше 255. Значения в интегральном изображении становятся очень большими, потому что они являются суммами пикселей выше и слева (см. стр. 3 вашей белой бумаги ниже).

Они вырастут намного больше, чем 255, поэтому для их хранения нужно 32 бита на пиксель.

Вы можете проверить это, создав изображение PIL в режиме "L", а затем установив пиксель на 1000000 или на большее число. Затем, когда вы прочитаете обратно значение, оно вернет 255.

>>> from PIL import Image
>>> img = Image.new('L', (100,100))
>>> img.putpixel((0,0), 100000)
>>> print(list(img.getdata())[0])
255

РЕДАКТИРОВАТЬ: После прочтения документации PIL, вы можете использовать PIL, если вы создаете свое целостное изображение в режиме "I" вместо режима "L". Это должно обеспечить 32 бита на пиксель.

По этой причине я рекомендую Numpy вместо PIL.

Ниже приведена перезапись вашей пороговой функции с использованием Numpy вместо PIL, и я получаю правильный/ожидаемый результат. Обратите внимание, что я создаю свое целостное изображение, используя массив uint32. Я использовал тот же самый пример C на Github, который вы использовали для своего перевода:

import numpy as np

def adaptive_thresh(input_img):

    h, w = input_img.shape

    S = w/8
    s2 = S/2
    T = 15.0

    #integral img
    int_img = np.zeros_like(input_img, dtype=np.uint32)
    for col in range(w):
        for row in range(h):
            int_img[row,col] = input_img[0:row,0:col].sum()

    #output img
    out_img = np.zeros_like(input_img)    

    for col in range(w):
        for row in range(h):
            #SxS region
            y0 = max(row-s2, 0)
            y1 = min(row+s2, h-1)
            x0 = max(col-s2, 0)
            x1 = min(col+s2, w-1)

            count = (y1-y0)*(x1-x0)

            sum_ = int_img[y1, x1]-int_img[y0, x1]-int_img[y1, x0]+int_img[y0, x0]

            if input_img[row, col]*count < sum_*(100.-T)/100.:
                out_img[row,col] = 0
            else:
                out_img[row,col] = 255

    return out_img

Ответ 2

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

import numpy, gc
from ctypes import *    

def adaptive_threshold(self):
    gc.collect()
    gc.disable()

    w, h = self._image.width, self._image.height
    s, t = w//8, 0.15
    summ = c_uint32(0)
    count = c_uint32(0)
    pixels = self._pixels

    int_img = numpy.ndarray(shape=(w, h), dtype=c_int64)

    for i in range(w):
        summ.value = 0
        for j in range(h):
            summ.value += sum(pixels[i, j])
            if i != 0:
                int_img[i, j] = int_img[i - 1, j] + summ.value
            else:
                int_img[i, j] = summ.value


    x1, x2, y1, y2 = c_uint16(0), c_uint16(0), c_uint16(0), c_uint16(0)
    for i in range(w):
        for j in range(h):
            x1.value = max(i - s // 2, 0)
            x2.value = min(i + s // 2, w - 1)
            y1.value = max(j - s // 2, 0)
            y2.value = min(j + s // 2, h - 1)

            count.value = (x2.value - x1.value) * (y2.value - y1.value)

            summ.value = int_img[x2.value][y2.value] - int_img[x1.value][y2.value] - \
                int_img[x2.value][y1.value] + int_img[x1.value][y1.value]

            if sum(pixels[i, j]) * count.value < summ.value * (1.0 - t):
                pixels[i, j] = 0, 0, 0
            else:
                pixels[i, j] = 255, 255, 255

    gc.enable()

Обратите внимание, что это часть класса. Он в основном имеет две переменные: _image, которая указывает на фактическое изображение, и _pixels, который является классом PixelAccess, который обеспечивает доступ к пикселям в качестве заданных значений. Я использовал деление по полу (//) вместо обычного деления (/), потому что оно гарантирует, что все значения являются целыми. Пока результаты выглядят хорошо. Я использовал типы данных C, чтобы контролировать использование памяти и сохранять значения в фиксированных позициях. Насколько я понимаю, это помогает контролировать небольшое количество данных для минимизации фрагментированных данных.

Плюс это последний квартал 2018 года. Люди до сих пор используют PIL, и, честно говоря, сейчас это делает. Это прекрасно работает для цветового пространства RGB. Если вы используете это на общих изображениях, вы можете преобразовать данные изображения в пространство RGB, используя:

Image.convert('RGB')

где "Изображение" является экземпляром открытого изображения

Для изображений, которые считаются HD-изображениями размером 1200x700, требуется несколько секунд, но на образце изображения это занимает всего несколько долей секунды. Изображение результата

Надеюсь, это кому-нибудь поможет.