Question

我目前正致力于实施名为Bradley Adaptive Thresholding的阈值算法。

我一直在主要关注两个链接，以便弄清楚如何实现这个算法。我还成功地实现了另外两种阈值算法，主要是Otsu's Method和Balanced Histogram Thresholding。

以下是我为了创建Bradley Adaptive Thresholding算法而遵循的两个链接。

http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.420.7883&rep=rep1&type=pdf

Bradley Adaptive Thresholding Github Example

以下是Python中我的源代码部分，其中我运行算法并保存图像。我使用Python Imaging Library而没有其他工具来完成我想要做的事情。

def get_bradley_binary(inp_im):
    w, h = inp_im.size
    s, t = (w / 8, 0.15)

    int_im = Image.new('L', (w, h))
    out_im = Image.new('L', (w, h))

    for i in range(w):
        summ = 0
        for j in range(h):
            index = j * w + i

            summ += get_pixel_offs(inp_im, index)

            if i == 0:
                set_pixel_offs(int_im, index, summ)
            else:
                temp = get_pixel_offs(int_im, index - 1) + summ
                set_pixel_offs(int_im, index, temp)

    for i in range(w):
        for j in range(h):
            index = j * w + i

            x1,x2,y1,y2 = (i-s/2, i+s/2, j-s/2, j+s/2)

            x1 = 0 if x1 < 0 else x1
            x2 = w - 1 if x2 >= w else x2
            y1 = 0 if y1 < 0 else y1
            y2 = h - 1 if y2 >= h else y2

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

            a1 = get_pixel_offs(int_im, y2 * w + x2)
            a2 = get_pixel_offs(int_im, y1 * w + x2)
            a3 = get_pixel_offs(int_im, y2 * w + x1)
            a4 = get_pixel_offs(int_im, y1 * w + x1)

            summ = a1 - a2 - a3 + a4

            temp = get_pixel_offs(inp_im, index)
            if temp * count < summ * (1.0 - t):
                set_pixel_offs(out_im, index, 0)
            else:
                set_pixel_offs(out_im, index, 255)

    return out_im

以下是我的代码部分，它说明了以前没见过的这些set和get方法的实现。

def get_offs(image, x, y):
    return y * image.size[0] + x

def get_xy(image, offs):
    return (offs % image.size[0], int(offs / image.size[0]))

def set_pixel_xy(image, x, y, data):
    image.load()[x, y] = data

def set_pixel_offs(image, offs, data):
    x, y = get_xy(image, offs)
    image.load()[x, y] = data

def get_pixel_offs(image, offs):
    return image.getdata()[offs]

def get_pixel_xy(image, x, y):
    return image.getdata()[get_offs(image, x, y)]

最后，这是输入和输出图像。这些是我在为您提供的第一个链接中的原始研究论文中使用的相同图像。注意：输出图像几乎完全是白色的，可能很难看到，但无论如何我提供它以防有人真的想要它作为参考。

Input Image Output Image

Answer 1

您无法以PIL的方式创建积分图像，因为您正在打包数据的图像不能接受超过255的值。积分图像中的值变得非常大，因为它们是像素的总和上方和左方（见白皮书第3页，下方）。

它们会比255大得多，所以你需要每像素32位才能存储它们。

您可以通过在＆＃34; L＆＃34;中创建PIL图像来测试这一点。模式，然后将像素设置为1000000或一些大数字。然后，当您回读该值时，它将返回255。

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

编辑：阅读PIL文档后，如果您在＆＃34; I＆＃34;中创建积分图像，则可以使用PIL。模式而不是＆＃34; L＆＃34;模式。这应该提供每像素32位。

因此我推荐Numpy而不是PIL。

下面是使用Numpy而不是PIL重写阈值函数，我得到正确/预期的结果。请注意，我使用uint32数组创建了积分图像。我在Github上使用了与您用于翻译的完全相同的C示例：

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

output

Answer 2

我试图重新实现该算法，但没有使用1D数组并切换到2D numpy数组，以更好地与实际论文中提到的原始算法配合使用。我用它来研究使用深度学习模型的数据分析。这是实现：

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图像）上需要花费几秒钟的时间，但是在示例图像上花费的时间只有几分之一秒。 Result Image

希望这对某人有帮助。

布拉德利自适应阈值算法

2 个答案: