布拉德利自适应阈值算法

Question

我目前正在实现一种称为Bradley自适应阈值算法的阈值化算法。

我主要参考了两个链接来学习如何实现这个算法。我也成功地实现了另外两个阈值化算法，分别是Otsu's Method和Balanced Histogram Thresholding。

以下是我一直在参考的两个链接，用于创建Bradley自适应阈值算法。

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)]

最后，这里是输入和输出图像。这些是在我提供的第一个链接中使用的与原始研究论文相同的图像。注意：输出图像几乎完全是白色的，可能很难看清楚，但为了参考，我仍然提供了它。

- BigBerger

---

什么没有起作用，产生适当的输出图像？你有任何非视觉测试吗？ - Ashalynd

是的，正确的输出图像生成不起作用了。我使用了研究论文中用于测试的完全相同的图像，但输出图像完全是白色的，与研究论文的输出图像看起来完全不同。至于非视觉测试，我不确定你的意思是什么。 - BigBerger

Answer 1

您不能使用PIL按照您当前的方式创建积分图像，因为您正在将数据打包到的图像无法接受超过255的值。积分图像中的值变得非常大，因为它们是左上方像素之和（请参见下面第3页的白皮书）。

他们将比255大得多，因此您需要每个像素32位来存储它们。

您可以通过在“L”模式下创建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文档之后，如果您在"I"模式下创建积分图像而不是"L"模式，则可以使用PIL。这应该提供每个像素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

- derricw

---

花了我一些时间才接受这个答案，因为我一直很忙，但是没错！我没有意识到他们正在添加超过255的值，而积分图只是数据的抽象表示，非常感谢你！ - BigBerger

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')

其中'Image'是一个打开图像的实例

对于像1200x700这样被认为是高清晰度的图像，需要几秒钟的时间，但在示例图像上只需要几分之一秒。 结果图像

希望这能帮助到某些人。

- Simanto Rahman