ओट्सू पद्धति का उपयोग करके वस्तुओं का पता लगाना

हैलो, प्रिय हैब्रेटाटेटेली और हैब्रिटिकिकी। मैं आज इस पोस्ट को ऐसे ही प्रासंगिक विषय पर समर्पित करना चाहता हूं जैसे कि छवियों में वस्तुओं का पता लगाना।

इस तरह की पहचान के लिए एक एल्गोरिदम के रूप में, हम तेज और कुशल ओट्सु विधि द्वारा एक सीमा का विकल्प मानते हैं।

परिचय

तो, चलो क्रम में शुरू करते हैं। सामान्य तौर पर, वस्तुओं का पता लगाने का कार्य उस वस्तु की छवि पर उपस्थिति स्थापित करना है जिसमें कुछ विशिष्ट विशेषताएं हैं।



इस तरह की विशेषता हो सकती है, उदाहरण के लिए, चमक। एक वस्तु (या वस्तुओं) का पता लगाने के लिए सबसे सरल और सबसे प्राकृतिक तरीकों में से एक चमक, या थ्रेशोल्ड वर्गीकरण (थ्रेसहोल्ड) के लिए एक सीमा चुनना है। ऐसी दहलीज का अर्थ छवि को एक प्रकाश वस्तु (अग्रभूमि) और एक अंधेरे पृष्ठभूमि (पृष्ठभूमि) में विभाजित करना है। यानी ऑब्जेक्ट उन पिक्सल्स का एक संग्रह होता है जिनकी चमक थ्रेशोल्ड ( I > T ) से अधिक होती है, और एक बैकग्राउंड अन्य पिक्सल्स का एक संग्रह होता है, जिनकी चमक थ्रेशोल्ड ( I < T ) से नीचे होती है।



इस प्रकार, प्रमुख पैरामीटर थ्रेशोल्ड टी है। उसे कैसे चुनें?



दर्जनों दहलीज चयन विधियां हैं। एक त्वरित और प्रभावी विधि 1979 में जापानी वैज्ञानिक नोबुयुकी ओत्सु द्वारा आविष्कार की गई विधि है। इस पर बाद में चर्चा की जाएगी।

ओट्सू विधि

चलो एक 8-बिट छवि है जिसके लिए दहलीज टी की गणना करना आवश्यक है । 24-बिट छवि के मामले में, ग्रेस्केल का उपयोग करके इसे 8-बिट में ओवरटेक करना आसान है:

I = 0.2125 R + 0.7154 G + 0.0721 B



ओट्सू की विधि थ्रेशोल्ड की गणना करने के लिए छवि हिस्टोग्राम का उपयोग करती है। आपको याद दिला दूं कि हिस्टोग्राम एक डिब्बे का एक सेट है, जिसमें से प्रत्येक नमूना तत्वों की संख्या को उसमें गिरता है। हमारे मामले में, चयन अलग-अलग चमक का पिक्सेल है, जो पूर्णांक मानों को 0 से 255 तक ले जा सकता है।



एक वस्तु के साथ उदाहरण छवि:





इस छवि के लिए हिस्टोग्राम:





हिस्टोग्राम से, एक व्यक्ति आसानी से देखता है कि दो स्पष्ट रूप से अलग-अलग वर्ग हैं। ओट्सू पद्धति का सार वर्गों के बीच दहलीज को स्थापित करना है ताकि उनमें से प्रत्येक यथासंभव "घने" हो। इसे गणितीय भाषा में रखने के लिए, यह इंट्रा-क्लास विचरण को कम करने के लिए कम करता है, जिसे दो वर्गों के भिन्नताओं के भारित योग के रूप में परिभाषित किया गया है:





यहाँ w और w ₂ क्रमशः प्रथम और द्वितीय श्रेणी की संभावनाएँ हैं।



अपने काम में, ओत्सु दर्शाता है कि इंट्रा-क्लास विचरण को कम करना इंटर-क्लास विचरण को अधिकतम करने के बराबर है, जो:





इस सूत्र में, प्रत्येक वर्ग के लिए ₁ और ₂ अंकगणितीय माध्य मान हैं।



इस सूत्र की ख़ासियत यह है कि w ₁ ( t + 1), w ₂ ( t + 1), ₁ ( t + 1), a ₂ ( t + 1) w ₁ ( t ) के पिछले मूल्यों के माध्यम से आसानी से व्यक्त किए जाते हैं, डब्ल्यू ₂ ( टी ), एक ₁ ( टी ), एक ₂ ( टी ) ( टी वर्तमान दहलीज है)। इस सुविधा ने हमें त्वरित एल्गोरिथम विकसित करने की अनुमति दी:

1. हम हिस्टोग्राम (पिक्सल की एक सरणी से होकर गुजरते हैं) की गणना करते हैं। जरूरत है कि सभी एक हिस्टोग्राम है; छवि भर के मार्ग अब आवश्यक नहीं हैं।
2. दहलीज t = 1 से शुरू होकर, हम प्रत्येक चरण पर विचरण at _b ( t ) को पुन: परिकलित करते हुए संपूर्ण हिस्टोग्राम के माध्यम से जाते हैं। यदि चरणों में से एक में विचरण अधिकतम से अधिक है, तो हम विचरण और टी = टी को अपडेट करते हैं।
3. वांछित सीमा टी है ।

स्वाभाविक रूप से, यह केवल एल्गोरिथ्म का एक सामान्य विवरण है। सटीक कार्यान्वयन में, आप बहुत सारे अनुकूलन कर सकते हैं। उदाहरण के लिए, हिस्टोग्राम के माध्यम से एक मार्ग (और किया जाना चाहिए) 1 से 254 तक नहीं, बल्कि न्यूनतम से अधिकतम चमक न्यूनतम तक। अंत में, हम इनमें से कुछ अनुकूलन को ध्यान में रखते हुए C ++ में एक कार्यान्वयन देंगे।



यह उपरोक्त एल्गोरिथ्म के कार्यान्वयन का परिणाम है:





गणना की गई सीमा:

वास्तविक उदाहरण

कृत्रिम रूप से उत्पन्न उदाहरण के अलावा, मैं असली दिखाना भी चाहूंगा

विधि का उपयोग कर।



मेरी वर्तमान थीसिस में, छवि पर बारकोड का स्थानीयकरण आवश्यक है:





ओत्सु पद्धति का उपयोग करने से पहले, आपको किसी तरह एक आयामी बारकोड की संरचनात्मक विशेषताओं को ध्यान में रखने के लिए प्रीप्रोसेसिंग करने की आवश्यकता होती है। यदि यह नहीं किया जाता है, तो विधि बस कुछ भी नहीं देगी। बारकोड की संरचना की ख़ासियत यह है कि इसमें ऊर्ध्वाधर धारियां होती हैं, और इसलिए बड़े क्षैतिज डेरिवेटिव और छोटे ऊर्ध्वाधर होते हैं। इसलिए, यदि हम छवि को क्षैतिज और ऊर्ध्वाधर डेरिवेटिव के बीच अंतर के रूप में लेते हैं, और फिर औसत फ़िल्टर लागू करते हैं, तो हमें यह मिलता है:





बुरा नहीं है, है ना? बारकोड की छवि छवि पर स्पष्ट रूप से दिखाई देती है और आसपास की वस्तुओं की तुलना में बहुत अधिक चमक के साथ बाहर खड़ी होती है। अब आप ओट्सू विधि को सुरक्षित रूप से लागू कर सकते हैं:





परिणाम एक सही ढंग से स्थानीयकृत बारकोड है।

C ++ कार्यान्वयन

खैर, जैसा कि मैंने वादा किया था, टिप्पणियों के साथ C ++ में ओट्सु विधि द्वारा थ्रेशोल्ड गणना का कार्यान्वयन:

typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .

1. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
   
   
   
   
3. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
   
   
   
   
4. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
   
   
   
   
5. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
   
   
   
   
6. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
   
   
   
   
7. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
   
   
   
   
9. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
   
   
   
   
10. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
11. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
13. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
14. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
15. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
17. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
18. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
20. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
21. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
22. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
24. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
25. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
26. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
27. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
29. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
30. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
31. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
33. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
34. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
35. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
37. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
38. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
39. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
40. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
41. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
42. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
43. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
44. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
46. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
47. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
49. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
50. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
52. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
53. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
55. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
56. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
57. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
58. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
59. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
61. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
62. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
63. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
65. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
66. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
68. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
69. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
71. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
72. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
73. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
74. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
75. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
76. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
77. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
79. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
80. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
82. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
83. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    
84. typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .
    
    
    
    

typedef unsigned char imageInt; // int otsuThreshold(imageInt *image, int size) { // NULL . , // // int min = image[0]; int max = image[0]; for ( int i = 1; i < size; i++) { int value = image[i]; if ( value < min) min = value ; if ( value > max) max = value ; } // min max, // 256 int histSize = max - min + 1; int * hist = new int [histSize]; // for ( int t = 0; t < histSize; t++) hist[t] = 0; // for ( int i = 0; i < size; i++) hist[image[i] - min]++; // : int m = 0; // m - , int n = 0; // n - for ( int t = 0; t <= max - min; t++) { m += t * hist[t]; n += hist[t]; } float maxSigma = -1; // int threshold = 0; // , maxSigma int alpha1 = 0; // 1 int beta1 = 0; // 1, // alpha2 , .. m - alpha1 // beta2 , .. n - alpha1 // t for ( int t = 0; t < max - min; t++) { alpha1 += t * hist[t]; beta1 += hist[t]; // 1. float w1 = ( float )beta1 / n; // , w2 , .. 1 - w1 // a = a1 - a2, a1, a2 - 1 2 float a = ( float )alpha1 / beta1 - ( float )(m - alpha1) / (n - beta1); // , sigma float sigma = w1 * (1 - w1) * a * a; // sigma , maxSigma if (sigma > maxSigma) { maxSigma = sigma; threshold = t; } } // , min, threshold += min; // , , :) return threshold; } * This source code was highlighted with Source Code Highlighter .

निष्कर्ष

इसलिए, हमने छवियों में वस्तुओं का पता लगाने के लिए ओट्सू पद्धति के उपयोग की जांच की। इस विधि के फायदे हैं:

1. कार्यान्वयन में आसानी।
2. विधि विभिन्न प्रकार की छवियों के लिए अच्छी तरह से पालन करती है, सबसे इष्टतम सीमा का चयन करती है।
3. तेजी से नेतृत्व समय। ओ ( एन ) संचालन की आवश्यकता होती है, जहां एन छवि में पिक्सेल की संख्या है।
4. विधि में कोई पैरामीटर नहीं है, बस इसे ले लो और लागू करें। माटलैब में, यह ग्रेथ्रेश () फ़ंक्शन है जिसमें कोई तर्क नहीं है (मैंने माटलाब का उदाहरण क्यों दिया? बस यह उपकरण छवि प्रसंस्करण के लिए वास्तविक मानक है)।

नुकसान:

1. थ्रेशोल्ड बिनाराइजेशन प्रति एसई असमान छवि चमक के प्रति संवेदनशील है। इस समस्या का समाधान एक वैश्विक के बजाय स्थानीय सीमा का परिचय हो सकता है।

सूत्रों का कहना है

1. ओत्सु, एन।, "ग्रे-लेवल हिस्टोग्राम्स से एक थ्रेसहोल्ड चयन विधि," सिस्टम, मैन और साइबरनेटिक्स, वॉल्यूम पर IEEE लेनदेन। 9, नहीं। 1, 1979, पीपी। 62-66।
2. विकिपीडिया
3. लेक्चरर द्वारा नोट्स
4. एक प्रभावी UPC बारकोड पहचान एल्गोरिथ्म के साथ आने वाले लोगों के लिए एक साइट।