Bradley uyarlamalı eşikleme algoritması

Question

Şu anda Bradley Adaptive Thresholding adlı bir eşikleme algoritması uygulamak için çalışıyorum.

Bu algoritmayı nasıl uygulayacağımı öğrenmek için başlıca iki bağlantıyı takip ediyorum. Ayrıca, diğer iki eşikleme algoritmasını, özellikle, Otsu's Method ve Balanced Histogram Thresholding'u başarıyla uygulayabildim.

Bradley Adaptive Thresholding algoritmasını oluşturmak için takip ettiğim iki bağlantı. Ben algoritması çalışan ve görüntüyü tasarruf yaşıyorum İşte burada

Bradley Adaptive Thresholding Github Example

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

Python benim kaynak kodunun bölümdür. Ne yapmak istediğimi gerçekleştirmek için Python Imaging Library ve başka hiçbir araç kullanıyorum. İşte

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 

bu setin uygulanmasını göstermektedir ve daha önce görmedim yöntemleri olsun benim kod bölümüdür.

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

Son olarak, giriş ve çıkış görüntüleri. Bunlar, size sağladığım ilk bağlantıdaki orijinal araştırma makalesinde kullanılanla aynı görüntülerdir. Not: Çıktı görüntüsü neredeyse tamamen beyazdır ve görmesi zor olabilir, ancak birisinin gerçekten referans almak istemesi durumunda bunu sağladım.

Answer 1

Sen PIL ile Verileri içine paketliyorsun görüntü çok büyük olsun 255 üzerinde ayrılmaz görüntüdeki değerleri değerleri kabul edemez çünkü bunu yapıyor yolunu ayrılmaz bir görüntü oluşturamıyor

çünkü bunlar yukarıdaki piksellerin ve solların toplamıdır (beyaz kağıdın 3. sayfasına bakın). 255'ten çok daha fazla büyüyecekler, böylece onları saklamak için piksel başına 32 bit gerekir.

Bunu, "L" modunda bir PIL görüntüsü oluşturarak ve ardından bir piksele 1000000 veya bazı büyük sayılara ayarlayarak bunu test edebilirsiniz. Sonra değerini geri okuduğunda, bu 255.

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

EDIT döndürür: Eğer "L "Ben" modunda ayrılmaz bir görüntü oluşturmak yerine eğer PIL belgeleri okuduktan sonra, PIL kullanmak mümkün olabilir "modu. Bu, piksel başına 32 bit sağlamalıdır.

Bu nedenle, PIL yerine Numpy'yi öneririm.

Aşağıda, PIL yerine Numpy kullanarak eşik değerinizin yeniden yazımı var ve doğru/beklenen sonucu elde ediyorum. Bir uint32 dizisini kullanarak tümleşik görüntü oluşturduğuma dikkat edin.

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