blocks|key|4461802|text|使用%25prun在IPython中分析您的代码会产生如下结果：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4461803|+++ncalls++tottime++percall++cumtime++percall+filename:lineno(function)
++++50246++++2.009++++0.000++++2.009++++0.000+<ipython-input-78-b628a43d294b>:15(<listcomp>)
++++50246++++0.587++++0.000++++0.587++++0.000+<ipython-input-78-b628a43d294b>:17(<listcomp>)
++++++++1++++0.170++++0.170++++2.829++++2.829+<ipython-input-78-b628a43d294b>:5(bradley_threshold)
++++50246++++0.058++++0.000++++0.058++++0.000+{built-in+method+sum}
++++50257++++0.004++++0.000++++0.004++++0.000+{built-in+method+len}|code-block|syntax|javascript|4461804|也就是说，几乎所有的运行时间都是由Python循环(慢)和非向量化算法(慢)造成的。因此，如果您使用numpy数组重写，我希望会有很大的改进；或者，如果您不知道如何向量化您的代码，则可以使用cython。|4461805|entityMap^0|2|5|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

Profiling your code in IPython with <code>%prun</code> yields shows:

<pre><code> ncalls tottime percall cumtime percall filename:lineno(function)
 50246 2.009 0.000 2.009 0.000 &lt;ipython-input-78-b628a43d294b&gt;:15(&lt;listcomp&gt;)
 50246 0.587 0.000 0.587 0.000 &lt;ipython-input-78-b628a43d294b&gt;:17(&lt;listcomp&gt;)
 1 0.170 0.170 2.829 2.829 &lt;ipython-input-78-b628a43d294b&gt;:5(bradley_threshold)
 50246 0.058 0.000 0.058 0.000 {built-in method sum}
 50257 0.004 0.000 0.004 0.000 {built-in method len}
</code></pre>

i.e, almost all of the running time is due to Python loops (slow) and non-vectorized arithmetic (slow). So I would expect big improvements if you rewrite using numpy arrays; alternatively you could use cython if you can't work out how to vectorize your code.

blocks|key|4461981|text|好的，我来晚了一点。不管怎样，让我分享一下我的想法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4461982|你可以通过使用动态编程来计算均值来加速它，但是让scipy和numpy来做所有的脏活要容易得多，而且速度也快得多。(请注意，我在代码中使用了Python3，因此在代码中将xrange更改为range+)。|4461983|#!/usr/bin/env+python3

import+numpy+as+np
from+scipy+import+ndimage
from+PIL+import+Image
import+copy
import+time

def+faster_bradley_threshold(image,+threshold=75,+window_r=5):
++++percentage+=+threshold+/+100.
++++window_diam+=+2*window_r+%2B+1
++++#+convert+image+to+numpy+array+of+grayscale+values
++++img+=+np.array(image.convert('L')).astype(np.float)+#+float+for+mean+precision+
++++#+matrix+of+local+means+with+scipy
++++means+=+ndimage.uniform_filter(img,+window_diam)
++++#+result:+0+for+entry+less+than+percentage*mean,+255+otherwise+
++++height,+width+=+img.shape[:2]
++++result+=+np.zeros((height,width),+np.uint8)+++#+initially+all+0
++++result[img+>=+percentage+*+means]+=+255+++++++#+numpy+magic+:)
++++#+convert+back+to+PIL+image
++++return+Image.fromarray(result)

def+bradley_threshold(image,+threshold=75,+windowsize=5):
++++ws+=+windowsize
++++image2+=+copy.copy(image).convert('L')
++++w,+h+=+image.size
++++l+=+image.convert('L').load()
++++l2+=+image2.load()
++++threshold+/=+100.0
++++for+y+in+range(h):
++++++++for+x+in+range(w):
++++++++++++#find+neighboring+pixels
++++++++++++neighbors+=[(x%2Bx2,y%2By2)+for+x2+in+range(-ws,ws)+for+y2+in+range(-ws,+ws)+if+x%2Bx2>0+and+x%2Bx2<w+and+y%2By2>0+and+y%2By2<h]
++++++++++++#mean+of+all+neighboring+pixels
++++++++++++mean+=+sum([l[a,b]+for+a,b+in+neighbors])/len(neighbors)
++++++++++++if+l[x,+y]+<+threshold*mean:
++++++++++++++++l2[x,y]+=+0
++++++++++++else:
++++++++++++++++l2[x,y]+=+255
++++return+image2

if+__name__+==+'__main__':
++++img+=+Image.open('test.jpg')

++++t0+=+time.process_time()
++++threshed0+=+bradley_threshold(img)
++++print('original+approach:',+round(time.process_time()-t0,+3),+'s')
++++threshed0.show()

++++t0+=+time.process_time()
++++threshed1+=+faster_bradley_threshold(img)
++++print('w/+numpy+&+scipy+:',+round(time.process_time()-t0,+3),+'s')
++++threshed1.show()|code-block|syntax|javascript|4461984|这使得它在我的机器上运行得更快：|4461985|$+python3+bradley.py+
original+approach:+3.736+s
w/+numpy+&+scipy+:+0.003+s|4461986|注:请注意，我在scipy中使用的均值在边界上的表现与您的代码中的均值略有不同(对于均值计算窗口不再完全包含在图像中的位置)。然而，我认为这不应该是一个问题。|4461987|另一个较小的区别是，来自for循环的窗口并不完全位于像素的中心，因为xrange(-ws，ws)与ws=5的偏移量产生-5，-4-，...,3,4，并导致平均值为-0.5。这可能不是故意的。|4461988|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

OK, I am a bit late here. Let me share my thoughts on that anyway:

You could speed it up by using dynamic programming to compute the means but it much easier and faster to let scipy and numpy do all the dirty work. (Note that I use Python3 for my code, so xrange is changed to range in your code).

<pre><code>#!/usr/bin/env python3

import numpy as np
from scipy import ndimage
from PIL import Image
import copy
import time

def faster_bradley_threshold(image, threshold=75, window_r=5):
 percentage = threshold / 100.
 window_diam = 2*window_r + 1
 # convert image to numpy array of grayscale values
 img = np.array(image.convert('L')).astype(np.float) # float for mean precision 
 # matrix of local means with scipy
 means = ndimage.uniform_filter(img, window_diam)
 # result: 0 for entry less than percentage*mean, 255 otherwise 
 height, width = img.shape[:2]
 result = np.zeros((height,width), np.uint8) # initially all 0
 result[img &gt;= percentage * means] = 255 # numpy magic :)
 # convert back to PIL image
 return Image.fromarray(result)

def bradley_threshold(image, threshold=75, windowsize=5):
 ws = windowsize
 image2 = copy.copy(image).convert('L')
 w, h = image.size
 l = image.convert('L').load()
 l2 = image2.load()
 threshold /= 100.0
 for y in range(h):
 for x in range(w):
 #find neighboring pixels
 neighbors =[(x+x2,y+y2) for x2 in range(-ws,ws) for y2 in range(-ws, ws) if x+x2&gt;0 and x+x2&lt;w and y+y2&gt;0 and y+y2&lt;h]
 #mean of all neighboring pixels
 mean = sum([l[a,b] for a,b in neighbors])/len(neighbors)
 if l[x, y] &lt; threshold*mean:
 l2[x,y] = 0
 else:
 l2[x,y] = 255
 return image2

if __name__ == '__main__':
 img = Image.open('test.jpg')

 t0 = time.process_time()
 threshed0 = bradley_threshold(img)
 print('original approach:', round(time.process_time()-t0, 3), 's')
 threshed0.show()

 t0 = time.process_time()
 threshed1 = faster_bradley_threshold(img)
 print('w/ numpy &amp; scipy :', round(time.process_time()-t0, 3), 's')
 threshed1.show()
</code></pre>

That made it much faster on my machine:

<pre><code>$ python3 bradley.py 
original approach: 3.736 s
w/ numpy &amp; scipy : 0.003 s
</code></pre>

PS: Note that the mean I used from scipy behaves slightly different at the borders than the one from your code (for positions where the window for mean calculation is not fully contained in he image anymore). However, I think that shouldn't be a problem.

Another minor difference is that the window from the for-loops was not exactly centered at the pixel as the offset by xrange(-ws,ws) with ws=5 yields -5,-4-,...,3,4 and results in an average of -0.5. This probably wasn't intended.

I have the following code for image thresholding, using the Bradley-Roth image thresholding method. 

<pre><code>from PIL import Image
import copy
import time
def bradley_threshold(image, threshold=75, windowsize=5):
 ws = windowsize
 image2 = copy.copy(image).convert('L')
 w, h = image.size
 l = image.convert('L').load()
 l2 = image2.load()
 threshold /= 100.0
 for y in xrange(h):
 for x in xrange(w):
 #find neighboring pixels
 neighbors =[(x+x2,y+y2) for x2 in xrange(-ws,ws) for y2 in xrange(-ws, ws) if x+x2&gt;0 and x+x2&lt;w and y+y2&gt;0 and y+y2&lt;h]
 #mean of all neighboring pixels
 mean = sum([l[a,b] for a,b in neighbors])/len(neighbors)
 if l[x, y] &lt; threshold*mean:
 l2[x,y] = 0
 else:
 l2[x,y] = 255
 return image2

i = Image.open('test.jpg')
windowsize = 5
bradley_threshold(i, 75, windowsize).show()
</code></pre>

This works fine when <code>windowsize</code> is small and the image is small. I've been using this image for testing:

<a href="https://i.stack.imgur.com/7k36s.jpg" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/7k36s.jpg" alt="this"></a>

I'm experiencing processing times of about 5 or 6 seconds when using a window size of 5, but if I bump my window size up to 20 and the algorithm is checking 20 pixels in each direction for the mean value, i get times upwards of one minute for that image. 

If I use an image with a size like 2592x1936 with a window size of only 5, it takes nearly 10 minutes to complete. 

So, how can I improve those times? Would a numpy array be faster? Is im.getpixel faster than loading the image into pixel access mode? Are there any other tips for speed boosts? Thanks in advance.

Bradley-Roth Adaptive Thresholding Algorithm - How do I get better performance?

Python

我有以下图像阈值处理代码，使用Bradley-Roth图像阈值方法。from PIL import Imageimport copyimport timedef bradley_threshold(image, threshold=75, windowsize=5):    ws = windowsize    ima...

问Bradley-Roth自适应阈值算法-如何获得更好的性能？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Bradley-Roth自适应阈值算法-如何获得更好的性能？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Bradley-Roth自适应阈值算法-如何获得更好的性能？
EN