12

我目前正在实施一种称为Bradley Adaptive Thresholding.

为了弄清楚如何实现这个算法，我主要关注了两个链接。我还成功地实现了另外两种阈值算法，主要是Otsu 方法和平衡直方图阈值。

这是我为了创建Bradley Adaptive Thresholding算法而一直关注的两个链接。

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

Bradley 自适应阈值 Github 示例

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

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

输入图像 输出图像

4

2 回答 2

12

您无法按照您的方式使用 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

输出

于 2015-04-07T23:28:27.787 回答
0

我试图重新实现该算法，但没有使用 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')

其中“图像”是打开图像的一个实例

对于被认为是高清的图像（如 1200x700 图像）需要几秒钟，但在示例图像上只需要几分之一秒。 结果图像

希望这可以帮助某人。

于 2018-09-20T09:42:51.190 回答