पायथन

Question

में एक गाऊशियन फ़िल्टर कैसे प्राप्त करें मैं आकार 5x5 का गाऊशियन फ़िल्टर बनाने के लिए अजगर का उपयोग कर रहा हूं। मैंने इस पोस्ट को here देखा जहां वे एक समान चीज़ के बारे में बात करते थे लेकिन मुझे मैटलैब फ़ंक्शन fspecial('gaussian', f_wid, sigma) पर समकक्ष पायथन कोड प्राप्त करने का सटीक तरीका नहीं मिला है क्या ऐसा करने का कोई और तरीका है? मैं निम्नलिखित कोड का उपयोग कर की कोशिश की:

size = 2 
sizey = None 
size = int(size) 
if not sizey: 
    sizey = size 
else: 
    sizey = int(sizey) 
x, y = scipy.mgrid[-size: size + 1, -sizey: sizey + 1] 
g = scipy.exp(- (x ** 2/float(size) + y ** 2/float(sizey))) 
print g/np.sqrt(2 * np.pi) 

उत्पादन प्राप्त है

[[ 0.00730688 0.03274718 0.05399097 0.03274718 0.00730688] 
[ 0.03274718 0.14676266 0.24197072 0.14676266 0.03274718] 
[ 0.05399097 0.24197072 0.39894228 0.24197072 0.05399097] 
[ 0.03274718 0.14676266 0.24197072 0.14676266 0.03274718] 
[ 0.00730688 0.03274718 0.05399097 0.03274718 0.00730688]] 

क्या मैं चाहता हूँ कुछ इस तरह है: अगर तुम सच में हो रही के बारे में परवाह सामान्य शब्दों में

0.0029690 0.0133062 0.0219382 0.0133062 0.0029690 
    0.0133062 0.0596343 0.0983203 0.0596343 0.0133062 
    0.0219382 0.0983203 0.1621028 0.0983203 0.0219382 
    0.0133062 0.0596343 0.0983203 0.0596343 0.0133062 
    0.0029690 0.0133062 0.0219382 0.0133062 0.0029690 

Answer 1

MATLAB के समान सटीक परिणाम, इसे प्राप्त करने का सबसे आसान तरीका अक्सर MATLAB फ़ंक्शन के स्रोत पर सीधे देखकर होता है।

इस मामले में, edit fspecial:

... 
    case 'gaussian' % Gaussian filter 

    siz = (p2-1)/2; 
    std = p3; 

    [x,y] = meshgrid(-siz(2):siz(2),-siz(1):siz(1)); 
    arg = -(x.*x + y.*y)/(2*std*std); 

    h  = exp(arg); 
    h(h<eps*max(h(:))) = 0; 

    sumh = sum(h(:)); 
    if sumh ~= 0, 
     h = h/sumh; 
    end; 
... 

सुंदर सरल, हाँ?

import numpy as np 

def matlab_style_gauss2D(shape=(3,3),sigma=0.5): 
    """ 
    2D gaussian mask - should give the same result as MATLAB's 
    fspecial('gaussian',[shape],[sigma]) 
    """ 
    m,n = [(ss-1.)/2. for ss in shape] 
    y,x = np.ogrid[-m:m+1,-n:n+1] 
    h = np.exp(-(x*x + y*y)/(2.*sigma*sigma)) 
    h[ h < np.finfo(h.dtype).eps*h.max() ] = 0 
    sumh = h.sum() 
    if sumh != 0: 
     h /= sumh 
    return h 

यह मेरे लिए fspecial रूप में एक ही जवाब देता है गोलाई त्रुटि के भीतर:: यह < 10mins अजगर को बंदरगाह के लिए काम करते हैं यह है

>> fspecial('gaussian',5,1) 

0.002969  0.013306  0.021938  0.013306  0.002969 
0.013306  0.059634  0.09832  0.059634  0.013306 
0.021938  0.09832  0.1621  0.09832  0.021938 
0.013306  0.059634  0.09832  0.059634  0.013306 
0.002969  0.013306  0.021938  0.013306  0.002969 

: matlab_style_gauss2D((5,5),1) 

array([[ 0.002969, 0.013306, 0.021938, 0.013306, 0.002969], 
     [ 0.013306, 0.059634, 0.09832 , 0.059634, 0.013306], 
     [ 0.021938, 0.09832 , 0.162103, 0.09832 , 0.021938], 
     [ 0.013306, 0.059634, 0.09832 , 0.059634, 0.013306], 
     [ 0.002969, 0.013306, 0.021938, 0.013306, 0.002969]]) 

Answer 2

इस समारोह इसी तरह की सुविधा को लागू करता है matlab में fspecial को

http://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.get_window.html scipy आयात सिग्नल से

>>>signal.get_window(('gaussian',2),3) 
>>>array([ 0.8824969, 1.  , 0.8824969]) 

यह फ़ंक्शन केवल 1 डी कर्नेल

मुझे लगता है कि आप गॉसियन मुखौटा उत्पन्न करने के लिए कोड को लागू कर सकते हैं और साथ ही अन्य ने भी बताया है।

Answer 3

मैं इस समस्या के लिए इसी तरह के समाधान पाया:

def fspecial_gauss(size, sigma): 

    """Function to mimic the 'fspecial' gaussian MATLAB function 
    """ 

    x, y = numpy.mgrid[-size//2 + 1:size//2 + 1, -size//2 + 1:size//2 + 1] 
    g = numpy.exp(-((x**2 + y**2)/(2.0*sigma**2))) 
    return g/g.sum() 

Answer 4

हाय मुझे लगता है कि समस्या यह है कि एक गाऊसी फिल्टर के लिए सामान्य कारक आप कितने आयाम इस्तेमाल किया पर निर्भर करता है। तो फ़िल्टर इस
जैसा दिखता है जो आप याद करते हैं सामान्यीकरण कारक का वर्ग है! और सटीकता की गणना करने के कारण पूरे मैट्रिक्स को पुनर्निर्मित करने की आवश्यकता है! 1 का योग करने के लिए सामान्यीकृत बिना

def gaussian_filter(shape =(5,5), sigma=1): 
    x, y = [edge /2 for edge in shape] 
    grid = np.array([[((i**2+j**2)/(2.0*sigma**2)) for i in xrange(-x, x+1)] for j in xrange(-y, y+1)]) 
    g_filter = np.exp(-grid)/(2*np.pi*sigma**2) 
    g_filter /= np.sum(g_filter) 
    return g_filter 
print gaussian_filter() 

उत्पादन: कोड यहाँ जुड़ा हुआ है

[[ 0.00291502 0.01306423 0.02153928 0.01306423 0.00291502] 
[ 0.01306423 0.05854983 0.09653235 0.05854983 0.01306423] 
[ 0.02153928 0.09653235 0.15915494 0.09653235 0.02153928] 
[ 0.01306423 0.05854983 0.09653235 0.05854983 0.01306423] 
[ 0.00291502 0.01306423 0.02153928 0.01306423 0.00291502]] 

उत्पादन एनपी से विभाजित।योग (g_filter):

def gen_gaussian_kernel(shape, mean, var): 
    coors = [range(shape[d]) for d in range(len(shape))] 
    k = np.zeros(shape=shape) 
    cartesian_product = [[]] 
    for coor in coors: 
     cartesian_product = [x + [y] for x in cartesian_product for y in coor] 
    for c in cartesian_product: 
     s = 0 
     for cc, m in zip(c,mean): 
      s += (cc - m)**2 
     k[tuple(c)] = exp(-s/(2*var)) 
    return k 

इस समारोह दिए गए आकार, केंद्र, और विचरण के साथ आप एक unnormalized गाऊसी खिड़कियों दे देंगे:

[[ 0.00296902 0.01330621 0.02193823 0.01330621 0.00296902] 
[ 0.01330621 0.0596343 0.09832033 0.0596343 0.01330621] 
[ 0.02193823 0.09832033 0.16210282 0.09832033 0.02193823] 
[ 0.01330621 0.0596343 0.09832033 0.0596343 0.01330621] 
[ 0.00296902 0.01330621 0.02193823 0.01330621 0.00296902]] 

Answer 5

यहाँ

एक nd-गाऊसी खिड़की जनरेटर प्रदान करना है। उदाहरण के लिए : gen_gaussian_kernel (आकार = (3,3,3), मतलब = (1,1,1), वर = 1.0) output->

[[[ 0.22313016 0.36787944 0.22313016] 
    [ 0.36787944 0.60653066 0.36787944] 
    [ 0.22313016 0.36787944 0.22313016]] 

[[ 0.36787944 0.60653066 0.36787944] 
    [ 0.60653066 1.   0.60653066] 
    [ 0.36787944 0.60653066 0.36787944]] 

[[ 0.22313016 0.36787944 0.22313016] 
    [ 0.36787944 0.60653066 0.36787944] 
    [ 0.22313016 0.36787944 0.22313016]]] 

Answer 6

आप यह भी कोशिश कर सकते (के उत्पाद के रूप में 2 स्वतंत्र -1 डी गाऊसी यादृच्छिक चर) प्राप्त करने के लिए एक 2D गाऊसी कर्नेल:

from numpy import pi, exp, sqrt 
s, k = 1, 2 # generate a (2k+1)x(2k+1) gaussian kernel with mean=0 and sigma = s 
probs = [exp(-z*z/(2*s*s))/sqrt(2*pi*s*s) for z in range(-k,k+1)] 
kernel = np.outer(probs, probs) 
print kernel 

#[[ 0.00291502 0.00792386 0.02153928 0.00792386 0.00291502] 
#[ 0.00792386 0.02153928 0.05854983 0.02153928 0.00792386] 
#[ 0.02153928 0.05854983 0.15915494 0.05854983 0.02153928] 
#[ 0.00792386 0.02153928 0.05854983 0.02153928 0.00792386] 
#[ 0.00291502 0.00792386 0.02153928 0.00792386 0.00291502]] 

import matplotlib.pylab as plt 
plt.imshow(kernel) 
plt.colorbar() 
plt.show()