Geekly Articles each Day
📜 ⬆️ ⬇️

Otsu object detection

Hello, dear harabrachiteli and habrakritiki. I would like to dedicate this post to such an urgent topic today as the detection of objects in images.
As one of the algorithms for such detection, we consider the choice of a threshold by the fast and efficient Otsu method .


Introduction


So let's start in order. In general, the task of detecting objects is to establish the presence in the image of an object that has some specific characteristics.

Such a characteristic may be, for example, brightness. One of the simplest and most natural ways to detect an object (or objects) is the choice of threshold by brightness, or threshold classification (thresholding). The meaning of this threshold is to separate the image into a light object (foreground) and a dark background (background). Those. an object is a collection of those pixels whose brightness exceeds the threshold ( I > T ), and the background is a collection of other pixels whose brightness is below the threshold ( I < T ).
')
Thus, the key parameter is the threshold T. How to choose it?

There are dozens of threshold selection methods. The method invented by the Japanese scientist Nobuyuki Otsu in 1979 is a fast and effective method. About him that will be discussed further.

Otsu method


Suppose there is an 8-bit image for which you want to calculate the threshold T. In the case of a 24-bit image, it is easy to overtake it into an 8-bit image using a gray cast (grayscale):
I = 0.2125 R + 0.7154 G + 0.0721 B

The Otsu's Method uses an image histogram to calculate the threshold. Let me remind you that a histogram is a set of bins, each of which characterizes the number of sampling elements hit into it. In our case, the sample is pixels of different brightness, which can take integer values ​​from 0 to 255.

An example of an image with an object:


Histogram for this image:


From the histogram, a person easily sees that there are two clearly separated classes. The essence of the Otsu method is to set the threshold between classes in such a way that each of them is as dense as possible. If expressed in mathematical language, it comes down to minimizing the intraclass variance, which is defined as the weighted sum of the variances of the two classes:


Here, w 1 and w 2 are the probabilities of the first and second classes, respectively.

In his work, Otsu shows that minimizing the intraclass dispersion is equivalent to maximizing between class variance, which is equal to:


In this formula, a 1 and a 2 are the arithmetic mean values ​​for each of the classes.

The peculiarity of this formula is that w 1 ( t + 1), w 2 ( t + 1), a 1 ( t + 1), a 2 ( t + 1) are easily expressed through previous values ​​of w 1 ( t ), w 2 ( t ), a 1 ( t ), a 2 ( t ) ( t is the current threshold). This feature allowed us to develop a fast algorithm:
  1. Calculate the histogram (one pass through an array of pixels). Further only the histogram is necessary; passes through the entire image is no longer required.
  2. Starting from the threshold t = 1, we go through the entire histogram, recalculating the variance σ b ( t ) at each step. If at some of the steps the variance is greater than the maximum, then the variance is updated and T = t .
  3. The required threshold is T.

Naturally, this is only a general description of the algorithm. In the exact implementation you can make a lot of optimizations. For example, a passage through a histogram can (and should) be done not from 1 to 254, but from minimum to maximum brightness minus one. At the end, the implementation in C ++ will be given taking into account some of these optimizations.

Here is the result of the implementation of the above algorithm:


Calculated threshold:


Real example


Besides the artificially generated example, I would also like to show the real
use method.

In my current thesis, the localization of the barcode on the image is required:


Before you use the Otsu method, you need to do preprocessing to somehow take into account the features of the structure of a one-dimensional bar code. If it is not done, the method simply will not do anything. The peculiarity of the bar code structure is that it consists of vertical stripes, and therefore has large horizontal derivatives and small vertical ones. Therefore, if we take the image as the difference between the horizontal and vertical derivatives, and then apply the averaging filter, we get this:


Not bad, huh? The barcode image is clearly visible on the image and is distinguished by a much higher brightness compared with the surrounding objects. Now we can safely apply the Otsu method:


The result was a properly localized barcode.

C ++ implementation


Well, as I promised, the implementation of the calculation of the threshold by the Otsu method in C ++ with comments:
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 .


Conclusion


So, we have examined the use of the Otsu method for detecting objects in images. The advantages of this method are:
  1. Ease of implementation.
  2. The method adapts well to various kinds of images, choosing the most optimal threshold.
  3. Fast lead time. O ( N ) operations are required, where N is the number of pixels in the image.
  4. The method has no parameters, just take it and apply it. In MatLab, this function is graythresh () with no arguments (Why did I give an example of MatLab? Simply, this tool is the de facto standard for image processing).
Disadvantages:
  1. By itself, threshold binarization is sensitive to uneven image brightness. The solution to this problem may be the introduction of local thresholds, instead of one global.

Sources

  1. Otsu, N., “A Threshold Selection Method from Gray-Level Histograms,” IEEE Transactions on Systems, Man, and Cybernetics, Vol. 9, No. 1, 1979, pp. 62-66.
  2. Wikipedia
  3. Notes of the lecturer (English)
  4. Website for people who have come up with an effective UPC barcode recognition algorithm (eng.)

Source: https://habr.com/ru/post/112079/

More articles:


All Articles