algorithm ब्राडली अनुकूली थ्रेशोल्डिंग-भ्रमित(प्रश्न)



image-processing adaptive-threshold (1)

मेरे पास कुछ प्रश्न हैं, शायद बेवकूफ, ब्राडली द्वारा अनुकूली थ्रेशोल्डिंग के कार्यान्वयन के बारे में मैंने इसके बारे में समाचार पत्र पढ़ा है http://people.scs.carleton.ca:8008/~roth/iit-publications-iti/docs/gerh-50002.pdf और मैं थोड़ा उलझन में हूँ मुख्य रूप से इस कथन के बारे में:

if ((in[i,j]*count) ≤ (sum*(100−t)/100)) then

मान लीजिए कि हमारे पास यह इनपुट है:

            width, i
            [0] [1] [2]
           +---+---+---+
height [0] | 1 | 2 | 2 |
j          +---+---+---+
       [1] | 3 | 4 | 3 |
           +---+---+---+
       [2] | 5 | 3 | 2 |
           +---+---+---+

और हम कहते हैं कि:

s = 2
s/2 = 1
t = 15
i = 1
j = 1 (we are at the center pixel)

तो इसका मतलब है कि हमारे पास एक विंडो 3x3 है, है ना? फिर:

x1 = 0, x2 = 2, y1 = 0, y2 = 2

फिर क्या गिनती है ? अगर विंडो में पिक्सल की संख्या होती है, तो एल्गोरिदम के अनुसार 3 * 3 = 9 की बजाय 2 * 2 = 4 क्यों है? इसके अलावा, गणना के आधार पर पिक्सेल का मूल मान क्यों गुणा करता है?

कागज का कहना है कि मूल्य के आसपास के पिक्सल के औसत मूल्य की तुलना में, ऐसा क्यों नहीं है

in[i,j] <= (sum/count) * ((100 - t) / 100)

फिर?

क्या कोई मुझे यह समझाएगा? यह शायद बहुत बेवकूफ सवाल है लेकिन मैं इसे समझ नहीं सकता।


शुरू करने से पहले, आइए अपने पेपर में लिखित एल्गोरिदम के छद्मकोड को पेश करें:

procedure AdaptiveThreshold(in,out,w,h)
1: for i = 0 to w do
2:     sum ← 0
3:     for j = 0 to h do
4:         sum ← sum+in[i, j]
5:         if i = 0 then
6:             intImg[i, j] ← sum
7:         else
8:             intImg[i, j] ← intImg[i−1, j] +sum
9:         end if
10:     end for
11: end for
12: for i = 0 to w do
13:     for j = 0 to h do
14:         x1 ← i−s/2 {border checking is not shown}
15:         x2 ← i+s/2
16:         y1 ← j −s/2
17:         y2 ← j +s/2
18:         count ← (x2−x1)×(y2−y1)
19:         sum ← intImg[x2,y2]−intImg[x2,y1−1]−intImg[x1−1,y2] +intImg[x1−1,y1−1]
20:          if (in[i, j]×count) ≤ (sum×(100−t)/100) then
21:              out[i, j] ← 0
22:          else
23:              out[i, j] ← 255
24:          end if
25:     end for
26: end for

intImg इनपुट छवि का अभिन्न छवि है थ्रेसहोल्ड, intImg स्केल

मैंने सफलता के साथ इस एल्गोरिथम को लागू किया है, तो चलो अपने संदेहों के बारे में बात करते हैं।

फिर क्या count ? अगर विंडो में पिक्सल की संख्या होती है, तो एल्गोरिदम के अनुसार 3 * 3 = 9 की बजाय 2 * 2 = 4 क्यों है?

कागज में एक अंतर्निहित धारणा है कि वे इसके बारे में बात नहीं करते हैं एस के मूल्यों को अजीब होना चाहिए, और विंडिंग होना चाहिए:

x1 = i - floor(s/2)
x2 = i + floor(s/2)
y1 = j - floor(s/2)
y2 = j + floor(s/2)

निश्चित रूप से खिड़की में पिक्सल की कुल संख्या है, लेकिन आपको यह भी सुनिश्चित करने की आवश्यकता है कि आप सीमा से बाहर न जाएं क्या आपके पास 3 x 3 विंडो होना चाहिए और इसलिए s = 3 , नहीं 2. अब, यदि s = 3 , लेकिन अगर हम i = 0, j = 0 चुनते हैं, तो हमारे पास x और y मान होंगे ऋणात्मक हैं हमारे पास ऐसा नहीं हो सकता है और इसलिए इस 3 x 3 विंडो के भीतर मान्य पिक्सल की संख्या i = 0, j = 0 पर केंद्रित है i = 0, j = 0 4 है, और इतनी count = 4 छवियों की सीमा के भीतर की खिड़कियों के लिए, फिर count 9 होगी

इसके अलावा, गणना के आधार पर पिक्सेल का मूल मान क्यों गुणा करता है? कागज का कहना है कि मूल्य के आसपास के पिक्सल के औसत मूल्य से तुलना की जाती है, ऐसा क्यों नहीं है:

   in[i,j] <= (sum/count) * ((100 - t) / 100)

फिर?

जो स्थिति आप देख रहे हैं वह एल्गोरिदम की पंक्ति 20 पर है:

20: (in[i, j]×count) ≤ (sum×(100−t)/100)

कारण है कि हम in[i,j]*count एक नजर डालते हैं क्योंकि हम मानते हैं कि in[i,j] में sxs विंडो के भीतर औसत तीव्रता है इसलिए, अगर हमने एक sxs विंडो की जांच की और सभी तीव्रताएं जोड़ sxs , तो यह in[i,j] x count बराबर है एल्गोरिदम काफी सरल है मूल रूप से, हम sxs विंडो के भीतर sxs औसत तीव्रता ( in[i,j] x count ) की तुलना करते हैं और यदि यह इस sxs विंडो के भीतर वास्तविक औसत के t% से कम है ( sum x ((100-t)/100) ), तो आउटपुट का सेट काला है यदि यह बड़ा है, तो आउटपुट को सफेद पर सेट किया जाता है। हालांकि, आप वाकई में कहा है कि इसे इसके बजाय होना चाहिए:

in[i,j] <= (sum/count) * ((100 - t) / 100)

यह अनिवार्य रूप से पंक्ति 20 के समान है, लेकिन आपने count आधार पर समीकरण के दोनों ओर विभाजित किया count , इसलिए यह अभी भी एक ही अभिव्यक्ति है मैं कहूंगा कि यह स्पष्ट रूप से बताता है कि मैंने ऊपर के बारे में क्या बात की थी। count से गुणन निश्चित रूप से भ्रमित है, और इसलिए जो आपने लिखा है वह अधिक समझ में आता है।

इसलिए, आप इसे केवल एक अलग तरीके से देख रहे हैं, और यह पूरी तरह ठीक है! तो आपके प्रश्न का उत्तर देने के लिए, आपने जो कहा है वह निश्चित रूप से सही है और वास्तविक एल्गोरिदम में देखी गयी अभिव्यक्ति के बराबर है।

उम्मीद है की यह मदद करेगा!





adaptive-threshold