क्यों scikit छवि में local_binary_pattern समारोह विभिन्न पैटर्न के लिए समान मान प्रदान करता है

Question

मैं scikit छवि पैकेज में local_binary_pattern समारोह का उपयोग कर रहा हूँ। यहाँ

import numpy as np 
from skimage.feature import local_binary_pattern 

image = np.array([[150, 137, 137, 146, 146, 148], 
        [145, 144, 144, 144, 142, 144], 
        [149, 144, 144, 143, 153, 147], 
        [145, 144, 147, 150, 145, 150], 
        [146, 146, 139, 148, 144, 148], 
        [129, 139, 142, 150, 146, 140]]).astype(np.uint8) 

lbp = local_binary_pattern(image, 8, 1, "uniform") 

print "image =" 
print image 
print "lbp =" 
print lbp 

और उत्पादन

image = 
[[150 137 137 146 146 148] 
[145 144 144 144 142 144] 
[149 144 144 143 153 147] 
[145 144 147 150 145 150] 
[146 146 139 148 144 148] 
[129 139 142 150 146 140]] 
lbp = 
[[ 0. 5. 5. 1. 9. 0.] 
[ 9. 6. 9. 9. 8. 9.] 
[ 0. 8. 6. 8. 0. 3.] 
[ 9. 7. 1. 0. 7. 0.] 
[ 1. 1. 8. 9. 7. 1.] 
[ 3. 4. 9. 0. 2. 3.]] 

मुझे क्या confuses है कि कुछ ही मान है: मैं त्रिज्या 1. यहाँ के भीतर 8 पड़ोसियों के रोटेशन अपरिवर्तनीय वर्दी LBP गणना करने के लिए चाहते हैं मेरी अजगर कोड है lbp में समान वर्दी पैटर्न के अनुरूप नहीं है। उदाहरण के लिए, lbp[1,1] और lbp[2,2] दोनों 6. लेकिन image[1,1] की LBP

1 0 0 
1 x 1 
1 1 1 

image[2,2] की LBP

1 1 1 
1 x 0 
1 1 1 

जहां lbp में मूल्यों पर आधारित है, मैं local_binary_pattern फ़ंक्शन का उपयोग करता 'अधिक से अधिक मान या पड़ोसियों के साथ तुलना करने के लिए 'बराबर'।

image[1,1] और image[2,2] के एलबीपी दोनों समान हैं। लेकिन यह कैसे image[1,1] और image[2,2] ही LBP मूल्य हो सकता था?

Answer 1

रोटेशन-अपरिवर्तनीय LBP सीधे पड़ोसियों के पिक्सेल मूल्यों का उपयोग नहीं करता है, बल्कि मूल्यों एक चक्र (रोटेशन निश्चरता के लिए) पर अंतर्वेशित। देखें https://github.com/scikit-image/scikit-image/blob/master/skimage/feature/_texture.pyx#L156

इसके अलावा मूल LBP कागज http://vision.stanford.edu/teaching/cs231b_spring1415/papers/lbp.pdf, जो उल्लेख देख "पड़ोसियों जो वास्तव में पिक्सल के केंद्र में गिर नहीं है के ग्रे मूल्यों प्रक्षेप द्वारा अनुमान है।"

Answer 2

LBP वर्णनकर्ता के रोटेशन के खिलाफ मजबूती बढ़ाने के लिए वर्ग पड़ोस एक परिपत्र से परिवर्तित कर दिया गया है। आठ पिक्सल द्वारा गठित एक परिपत्र पड़ोस में विकर्ण पर चार पड़ोसियों पिक्सेल केन्द्रों से मेल नहीं खाती। उन पड़ोसियों की तीव्रता मान आमतौर पर बिलीनेर इंटरपोलेशन के माध्यम से गणना की जाती है। निम्नलिखित चित्र ग्राफिकल रूप से बताते हैं कि आपकी नमूना छवि में कुछ एलबीपी पैटर्न एलबीपी _8,1 पैटर्न के लिए अलग हैं। आपके उत्तर के लिए बहुत बहुत

कोड

w_cen = (1-1/np.sqrt(2))**2 # Weights 
w_diag = (1/np.sqrt(2))**2 
w_orto = (1-1/np.sqrt(2))*(1/np.sqrt(2)) 

def bilinear_interpoplation(i_cen, i_diag, i_hor, i_ver): 
    return i_cen*w_cen + i_diag*w_diag + i_hor*w_orto + i_ver*w_orto 

def circular_neighbourhood(x): 
    [I7, I6, I5] = x[0, :] 
    [I0, Ic, I4] = x[1, :] 
    [I1, I2, I3] = x[2, :] 
    I7i = bilinear_interpolation(Ic, I7, I0, I6) 
    I5i = bilinear_interpolation(Ic, I5, I4, I6) 
    I3i = bilinear_interpolation(Ic, I3, I4, I2) 
    I1i = bilinear_interpolation(Ic, I1, I0, I2) 
    interpolated = np.array([[I7i, I6, I5i], 
          [ I0, Ic, I4], 
          [I1i, I2, I3i]]) 
    return interpolated 

def binary_pattern(x): 
    return np.where(x >= x[1, 1], 1, 0) 

def display_lbps(patch): 
    interpolated = circular_neighbourhood(patch) 
    print('Patch =') 
    print(patch) 
    print('LBP of patch =') 
    print(binary_pattern(patch)) 
    print('Interpolated patch =') 
    print(interpolated) 
    print('LBP of interpolated patch =') 
    print(binary_pattern(interpolated)) 

display_lbps(image[0:3, 0:3]) 
display_lbps(image[1:4, 1:4])