# Miscellaneous Image Transformations 图像处理

## 枚举

}
enum cv::DistanceTransformLabelTypes {
cv::DIST_LABEL_CCOMP = 0,
cv::DIST_LABEL_PIXEL = 1
}
distanceTransform algorithm flags 更多...
}
Mask size for distance transform. 更多...
enum cv::DistanceTypes {
cv::DIST_USER = -1,
cv::DIST_L1 = 1,
cv::DIST_L2 = 2,
cv::DIST_C = 3,
cv::DIST_L12 = 4,
cv::DIST_FAIR = 5,
cv::DIST_WELSCH = 6,
cv::DIST_HUBER = 7
}
enum cv::FloodFillFlags {
cv::FLOODFILL_FIXED_RANGE = 1 << 16,
}
floodfill algorithm flags 更多...
enum cv::GrabCutClasses {
cv::GC_BGD = 0,
cv::GC_FGD = 1,
cv::GC_PR_BGD = 2,
cv::GC_PR_FGD = 3
}
class of the pixel in GrabCut algorithm 更多...
enum cv::GrabCutModes {
cv::GC_INIT_WITH_RECT = 0,
cv::GC_EVAL = 2,
cv::GC_EVAL_FREEZE_MODEL = 3
}
GrabCut algorithm flags. 更多...
enum cv::ThresholdTypes {
cv::THRESH_BINARY = 0,
cv::THRESH_BINARY_INV = 1,
cv::THRESH_TRUNC = 2,
cv::THRESH_TOZERO = 3,
cv::THRESH_TOZERO_INV = 4,
cv::THRESH_OTSU = 8,
cv::THRESH_TRIANGLE = 16
}

## 函数

void cv::adaptiveThreshold ( InputArray src, OutputArray dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C)
Applies an adaptive threshold to an array. 更多...
void cv::blendLinear ( InputArray src1, InputArray src2, InputArray weights1, InputArray weights2, OutputArray dst)
void cv::distanceTransform ( InputArray src, OutputArray dst, OutputArray labels, int distanceType, int maskSize, int labelType= DIST_LABEL_CCOMP )
Calculates the distance to the closest zero pixel for each pixel of the source image. 更多...
void cv::distanceTransform ( InputArray src, OutputArray dst, int distanceType, int maskSize, int dstType= CV_32F )
int cv::floodFill ( InputOutputArray image, Point seedPoint, Scalar newVal, Rect *rect=0, Scalar loDiff= Scalar (), Scalar upDiff= Scalar (), int flags=4)
int cv::floodFill ( InputOutputArray image, InputOutputArray mask, Point seedPoint, Scalar newVal, Rect *rect=0, Scalar loDiff= Scalar (), Scalar upDiff= Scalar (), int flags=4)
Fills a connected component with the given color. 更多...
void cv::grabCut ( InputArray img, InputOutputArray mask, Rect rect, InputOutputArray bgdModel, InputOutputArray fgdModel, int iterCount, int mode= GC_EVAL )
Runs the GrabCut algorithm. 更多...
void cv::integral ( InputArray src, OutputArray sum , int sdepth=-1)
void cv::integral ( InputArray src, OutputArray sum , OutputArray sqsum, int sdepth=-1, int sqdepth=-1)
void cv::integral ( InputArray src, OutputArray sum , OutputArray sqsum, OutputArray tilted, int sdepth=-1, int sqdepth=-1)
Calculates the integral of an image. 更多...
double cv::threshold ( InputArray src, OutputArray dst, double thresh, double maxval, int type)
Applies a fixed-level threshold to each array element. 更多...
void cv::watershed ( InputArray image, InputOutputArray markers)
Performs a marker-based image segmentation using the watershed algorithm. 更多...

## 枚举类型文档编制

 #include < opencv2/imgproc.hpp > 

the threshold value $$T(x,y)$$ is a mean of the $$\texttt{blockSize} \times \texttt{blockSize}$$ neighborhood of $$(x, y)$$ minus C

the threshold value $$T(x, y)$$ is a weighted sum (cross-correlation with a Gaussian window) of the $$\texttt{blockSize} \times \texttt{blockSize}$$ neighborhood of $$(x, y)$$ minus C . The default sigma (standard deviation) is used for the specified blockSize . See getGaussianKernel

## ◆ DistanceTransformLabelTypes

 enum cv::DistanceTransformLabelTypes

 #include < opencv2/imgproc.hpp > 

distanceTransform algorithm flags

DIST_LABEL_CCOMP
Python: cv.DIST_LABEL_CCOMP

each connected component of zeros in src (as well as all the non-zero pixels closest to the connected component) will be assigned the same label

DIST_LABEL_PIXEL
Python: cv.DIST_LABEL_PIXEL

each zero pixel (and all the non-zero pixels closest to it) gets its own label.

 #include < opencv2/imgproc.hpp > 

## ◆ DistanceTypes

 enum cv::DistanceTypes

 #include < opencv2/imgproc.hpp > 

Distance types for Distance Transform and M-estimators

distanceTransform , fitLine

DIST_USER
Python: cv.DIST_USER

User defined distance.

DIST_L1
Python: cv.DIST_L1

distance = |x1-x2| + |y1-y2|

DIST_L2
Python: cv.DIST_L2

the simple euclidean distance

DIST_C
Python: cv.DIST_C

distance = max(|x1-x2|,|y1-y2|)

DIST_L12
Python: cv.DIST_L12

L1-L2 metric: distance = 2(sqrt(1+x*x/2) - 1))

DIST_FAIR
Python: cv.DIST_FAIR

distance = c^2(|x|/c-log(1+|x|/c)), c = 1.3998

DIST_WELSCH
Python: cv.DIST_WELSCH

distance = c^2/2(1-exp(-(x/c)^2)), c = 2.9846

DIST_HUBER
Python: cv.DIST_HUBER

distance = |x|<c ? x^2/2 : c(|x|-c/2), c=1.345

## ◆ FloodFillFlags

 enum cv::FloodFillFlags

 #include < opencv2/imgproc.hpp > 

floodfill algorithm flags

FLOODFILL_FIXED_RANGE
Python: cv.FLOODFILL_FIXED_RANGE

If set, the difference between the current pixel and seed pixel is considered. Otherwise, the difference between neighbor pixels is considered (that is, the range is floating).

If set, the function does not change the image ( newVal is ignored), and only fills the mask with the value specified in bits 8-16 of flags as described above. This option only make sense in function variants that have the mask parameter.

## ◆ GrabCutClasses

 enum cv::GrabCutClasses

 #include < opencv2/imgproc.hpp > 

class of the pixel in GrabCut algorithm

GC_BGD
Python: cv.GC_BGD

an obvious background pixels

GC_FGD
Python: cv.GC_FGD

an obvious foreground (object) pixel

GC_PR_BGD
Python: cv.GC_PR_BGD

a possible background pixel

GC_PR_FGD
Python: cv.GC_PR_FGD

a possible foreground pixel

## ◆ GrabCutModes

 enum cv::GrabCutModes

 #include < opencv2/imgproc.hpp > 

GrabCut algorithm flags.

GC_INIT_WITH_RECT
Python: cv.GC_INIT_WITH_RECT

The function initializes the state and the mask using the provided rectangle. After that it runs iterCount iterations of the algorithm.

The function initializes the state using the provided mask. Note that GC_INIT_WITH_RECT and GC_INIT_WITH_MASK can be combined. Then, all the pixels outside of the ROI are automatically initialized with GC_BGD .

GC_EVAL
Python: cv.GC_EVAL

The value means that the algorithm should just resume.

GC_EVAL_FREEZE_MODEL
Python: cv.GC_EVAL_FREEZE_MODEL

The value means that the algorithm should just run the grabCut algorithm (a single iteration) with the fixed model

## ◆ ThresholdTypes

 enum cv::ThresholdTypes

 #include < opencv2/imgproc.hpp > 

type of the threshold operation

threshold types

THRESH_BINARY
Python: cv.THRESH_BINARY

$\texttt{dst} (x,y) = \fork{\texttt{maxval}}{if $$\texttt{src}(x,y) > \texttt{thresh}$$}{0}{otherwise}$

THRESH_BINARY_INV
Python: cv.THRESH_BINARY_INV

$\texttt{dst} (x,y) = \fork{0}{if $$\texttt{src}(x,y) > \texttt{thresh}$$}{\texttt{maxval}}{otherwise}$

THRESH_TRUNC
Python: cv.THRESH_TRUNC

$\texttt{dst} (x,y) = \fork{\texttt{threshold}}{if $$\texttt{src}(x,y) > \texttt{thresh}$$}{\texttt{src}(x,y)}{otherwise}$

THRESH_TOZERO
Python: cv.THRESH_TOZERO

$\texttt{dst} (x,y) = \fork{\texttt{src}(x,y)}{if $$\texttt{src}(x,y) > \texttt{thresh}$$}{0}{otherwise}$

THRESH_TOZERO_INV
Python: cv.THRESH_TOZERO_INV

$\texttt{dst} (x,y) = \fork{0}{if $$\texttt{src}(x,y) > \texttt{thresh}$$}{\texttt{src}(x,y)}{otherwise}$

THRESH_OTSU
Python: cv.THRESH_OTSU

flag, use Otsu algorithm to choose the optimal threshold value

THRESH_TRIANGLE
Python: cv.THRESH_TRIANGLE

flag, use Triangle algorithm to choose the optimal threshold value

## 函数文档编制

 void cv::adaptiveThreshold ( InputArray src , OutputArray dst , double maxValue , int adaptiveMethod , int thresholdType , int blockSize , double C )
Python:

 #include < opencv2/imgproc.hpp > 

Applies an adaptive threshold to an array.

The function transforms a grayscale image to a binary image according to the formulae:

• THRESH_BINARY

$dst(x,y) = \fork{\texttt{maxValue}}{if $$src(x,y) > T(x,y)$$}{0}{otherwise}$

• THRESH_BINARY_INV

$dst(x,y) = \fork{0}{if $$src(x,y) > T(x,y)$$}{\texttt{maxValue}}{otherwise}$

where $$T(x,y)$$ is a threshold calculated individually for each pixel (see adaptiveMethod parameter).

The function can process the image in-place.

 src Source 8-bit single-channel image. dst Destination image of the same size and the same type as src. maxValue Non-zero value assigned to the pixels for which the condition is satisfied adaptiveMethod Adaptive thresholding algorithm to use, see AdaptiveThresholdTypes 。 BORDER_REPLICATE | BORDER_ISOLATED is used to process boundaries. thresholdType Thresholding type that must be either THRESH_BINARY or THRESH_BINARY_INV ，见 ThresholdTypes . blockSize Size of a pixel neighborhood that is used to calculate a threshold value for the pixel: 3, 5, 7, and so on. C Constant subtracted from the mean or weighted mean (see the details below). Normally, it is positive but may be zero or negative as well.

threshold , blur , GaussianBlur

## ◆ blendLinear()

 void cv::blendLinear ( InputArray src1 , InputArray src2 , InputArray weights1 , InputArray weights2 , OutputArray dst )

 #include < opencv2/imgproc.hpp > 

Performs linear blending of two images:

$\texttt{dst}(i,j) = \texttt{weights1}(i,j)*\texttt{src1}(i,j) + \texttt{weights2}(i,j)*\texttt{src2}(i,j)$

 src1 It has a type of CV_8UC(n) or CV_32FC(n) , where n is a positive integer. src2 It has the same type and size as src1. weights1 It has a type of CV_32FC1 and the same size with src1. weights2 It has a type of CV_32FC1 and the same size with src1. dst It is created if it does not have the same size and type with src1.

## ◆ distanceTransform() [1/2]

 void cv::distanceTransform ( InputArray src , OutputArray dst , OutputArray labels , int distanceType , int maskSize , int labelType =  DIST_LABEL_CCOMP  )
Python:
dst = cv.distanceTransform( src, distanceType, maskSize[, dst[, dstType]] )
dst, labels = cv.distanceTransformWithLabels( src, distanceType, maskSize[, dst[, labels[, labelType]]] )

 #include < opencv2/imgproc.hpp > 

Calculates the distance to the closest zero pixel for each pixel of the source image.

When maskSize == DIST_MASK_PRECISE and distanceType == DIST_L2 , the function runs the algorithm described in [65] . This algorithm is parallelized with the TBB library.

In other cases, the algorithm [22] is used. This means that for a pixel the function finds the shortest path to the nearest zero pixel consisting of basic shifts: horizontal, vertical, diagonal, or knight's move (the latest is available for a $$5\times 5$$ mask). The overall distance is calculated as a sum of these basic distances. Since the distance function should be symmetric, all of the horizontal and vertical shifts must have the same cost (denoted as a ), all the diagonal shifts must have the same cost (denoted as  b  ), and all knight's moves must have the same cost (denoted as  c  ). For the DIST_C and DIST_L1 types, the distance is calculated precisely, whereas for DIST_L2 (Euclidean distance) the distance can be calculated only with a relative error (a $$5\times 5$$ mask gives more accurate results). For  a  ,  b  ，和  c  , OpenCV uses the values suggested in the original paper:

• DIST_L1:  a = 1, b = 2 
• DIST_L2:
•  3 x 3  :  a=0.955, b=1.3693 
•  5 x 5  :  a=1, b=1.4, c=2.1969 
• DIST_C:  a = 1, b = 1 

Typically, for a fast, coarse distance estimation DIST_L2 , a $$3\times 3$$ mask is used. For a more accurate distance estimation DIST_L2 , a $$5\times 5$$ mask or the precise algorithm is used. Note that both the precise and the approximate algorithms are linear on the number of pixels.

This variant of the function does not only compute the minimum distance for each pixel $$(x, y)$$ but also identifies the nearest connected component consisting of zero pixels (labelType== DIST_LABEL_CCOMP ) or the nearest zero pixel (labelType== DIST_LABEL_PIXEL ). Index of the component/pixel is stored in  labels(x, y)  . When labelType== DIST_LABEL_CCOMP , the function automatically finds connected components of zero pixels in the input image and marks them with distinct labels. When labelType== DIST_LABEL_CCOMP , the function scans through the input image and marks all the zero pixels with distinct labels.

In this mode, the complexity is still linear. That is, the function provides a very fast way to compute the Voronoi diagram for a binary image. Currently, the second variant can use only the approximate distance transform algorithm, i.e. maskSize= DIST_MASK_PRECISE is not supported yet.

 src 8-bit, single-channel (binary) source image. dst Output image with calculated distances. It is a 8-bit or 32-bit floating-point, single-channel image of the same size as src. labels Output 2D array of labels (the discrete Voronoi diagram). It has the type CV_32SC1 and the same size as src. distanceType Type of distance, see DistanceTypes maskSize Size of the distance transform mask, see DistanceTransformMasks . DIST_MASK_PRECISE is not supported by this variant. In case of the DIST_L1 or DIST_C distance type, the parameter is forced to 3 because a $$3\times 3$$ mask gives the same result as $$5\times 5$$ or any larger aperture. labelType Type of the label array to build, see DistanceTransformLabelTypes .

samples/cpp/distrans.cpp .

## ◆ distanceTransform() [2/2]

 void cv::distanceTransform ( InputArray src , OutputArray dst , int distanceType , int maskSize , int dstType =  CV_32F  )
Python:
dst = cv.distanceTransform( src, distanceType, maskSize[, dst[, dstType]] )
dst, labels = cv.distanceTransformWithLabels( src, distanceType, maskSize[, dst[, labels[, labelType]]] )

 #include < opencv2/imgproc.hpp > 

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

 src 8-bit, single-channel (binary) source image. dst Output image with calculated distances. It is a 8-bit or 32-bit floating-point, single-channel image of the same size as src . distanceType Type of distance, see DistanceTypes maskSize Size of the distance transform mask, see DistanceTransformMasks . In case of the DIST_L1 or DIST_C distance type, the parameter is forced to 3 because a $$3\times 3$$ mask gives the same result as $$5\times 5$$ or any larger aperture. dstType Type of output image. It can be CV_8U or CV_32F. Type CV_8U can be used only for the first variant of the function and distanceType == DIST_L1 .

## ◆ floodFill() [1/2]

 int cv::floodFill ( InputOutputArray image , Point seedPoint , Scalar newVal , Rect * rect =  0  , Scalar loDiff =  Scalar ()  , Scalar upDiff =  Scalar ()  , int flags =  4  )
Python:
retval, image, mask, rect = cv.floodFill( image, mask, seedPoint, newVal[, loDiff[, upDiff[, flags]]] )

 #include < opencv2/imgproc.hpp > 

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

variant without  mask  parameter

samples/cpp/ffilldemo.cpp .

## ◆ floodFill() [2/2]

 int cv::floodFill ( InputOutputArray image , InputOutputArray mask , Point seedPoint , Scalar newVal , Rect * rect =  0  , Scalar loDiff =  Scalar ()  , Scalar upDiff =  Scalar ()  , int flags =  4  )
Python:
retval, image, mask, rect = cv.floodFill( image, mask, seedPoint, newVal[, loDiff[, upDiff[, flags]]] )

 #include < opencv2/imgproc.hpp > 

Fills a connected component with the given color.

• in case of a grayscale image and floating range

$\texttt{src} (x',y')- \texttt{loDiff} \leq \texttt{src} (x,y) \leq \texttt{src} (x',y')+ \texttt{upDiff}$

• in case of a grayscale image and fixed range

$\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)- \texttt{loDiff} \leq \texttt{src} (x,y) \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)+ \texttt{upDiff}$

• in case of a color image and floating range

$\texttt{src} (x',y')_r- \texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq \texttt{src} (x',y')_r+ \texttt{upDiff} _r,$

$\texttt{src} (x',y')_g- \texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq \texttt{src} (x',y')_g+ \texttt{upDiff} _g$

and

$\texttt{src} (x',y')_b- \texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq \texttt{src} (x',y')_b+ \texttt{upDiff} _b$

• in case of a color image and fixed range

$\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_r- \texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_r+ \texttt{upDiff} _r,$

$\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_g- \texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_g+ \texttt{upDiff} _g$

and

$\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_b- \texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_b+ \texttt{upDiff} _b$

where $$src(x',y')$$ is the value of one of pixel neighbors that is already known to belong to the component. That is, to be added to the connected component, a color/brightness of the pixel should be close enough to:

• Color/brightness of one of its neighbors that already belong to the connected component in case of a floating range.
• Color/brightness of the seed point in case of a fixed range.

Use these functions to either mark a connected component with the specified color in-place, or build a mask and then extract the contour, or copy the region to another image, and so on.

Since the mask is larger than the filled image, a pixel $$(x, y)$$ in image corresponds to the pixel $$(x+1, y+1)$$ in the mask .

findContours

## ◆ grabCut()

 void cv::grabCut ( InputArray img , InputOutputArray mask , Rect rect , InputOutputArray bgdModel , InputOutputArray fgdModel , int iterCount , int mode =  GC_EVAL  )
Python:
mask, bgdModel, fgdModel = cv.grabCut( img, mask, rect, bgdModel, fgdModel, iterCount[, mode] )

 #include < opencv2/imgproc.hpp > 

Runs the GrabCut algorithm.

The function implements the GrabCut image segmentation algorithm .

 img Input 8-bit 3-channel image. mask Input/output 8-bit single-channel mask. The mask is initialized by the function when mode is set to GC_INIT_WITH_RECT . Its elements may have one of the GrabCutClasses . rect ROI containing a segmented object. The pixels outside of the ROI are marked as "obvious background". The parameter is only used when mode== GC_INIT_WITH_RECT . bgdModel Temporary array for the background model. Do not modify it while you are processing the same image. fgdModel Temporary arrays for the foreground model. Do not modify it while you are processing the same image. iterCount Number of iterations the algorithm should make before returning the result. Note that the result can be refined with further calls with mode== GC_INIT_WITH_MASK or mode==GC_EVAL . mode Operation mode that could be one of the GrabCutModes

samples/cpp/grabcut.cpp .

## ◆ integral() [1/3]

 void cv::integral ( InputArray src , OutputArray sum , int sdepth =  -1  )
Python:
sum = cv.integral( src[, sum[, sdepth]] )
sum, sqsum = cv.integral2( src[, sum[, sqsum[, sdepth[, sqdepth]]]] )
sum, sqsum, tilted = cv.integral3( src[, sum[, sqsum[, tilted[, sdepth[, sqdepth]]]]] )

 #include < opencv2/imgproc.hpp > 

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

## ◆ integral() [2/3]

 void cv::integral ( InputArray src , OutputArray sum , OutputArray sqsum , int sdepth =  -1  , int sqdepth =  -1  )
Python:
sum = cv.integral( src[, sum[, sdepth]] )
sum, sqsum = cv.integral2( src[, sum[, sqsum[, sdepth[, sqdepth]]]] )
sum, sqsum, tilted = cv.integral3( src[, sum[, sqsum[, tilted[, sdepth[, sqdepth]]]]] )

 #include < opencv2/imgproc.hpp > 

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

## ◆ integral() [3/3]

 void cv::integral ( InputArray src , OutputArray sum , OutputArray sqsum , OutputArray tilted , int sdepth =  -1  , int sqdepth =  -1  )
Python:
sum = cv.integral( src[, sum[, sdepth]] )
sum, sqsum = cv.integral2( src[, sum[, sqsum[, sdepth[, sqdepth]]]] )
sum, sqsum, tilted = cv.integral3( src[, sum[, sqsum[, tilted[, sdepth[, sqdepth]]]]] )

 #include < opencv2/imgproc.hpp > 

Calculates the integral of an image.

The function calculates one or more integral images for the source image as follows:

$\texttt{sum} (X,Y) = \sum _{x<X,y<Y} \texttt{image} (x,y)$

$\texttt{sqsum} (X,Y) = \sum _{x<X,y<Y} \texttt{image} (x,y)^2$

$\texttt{tilted} (X,Y) = \sum _{y<Y,abs(x-X+1) \leq Y-y-1} \texttt{image} (x,y)$

Using these integral images, you can calculate sum, mean, and standard deviation over a specific up-right or rotated rectangular region of the image in a constant time, for example:

$\sum _{x_1 \leq x < x_2, \, y_1 \leq y < y_2} \texttt{image} (x,y) = \texttt{sum} (x_2,y_2)- \texttt{sum} (x_1,y_2)- \texttt{sum} (x_2,y_1)+ \texttt{sum} (x_1,y_1)$

It makes possible to do a fast blurring or fast block correlation with a variable window size, for example. In case of multi-channel images, sums for each channel are accumulated independently.

As a practical example, the next figure shows the calculation of the integral of a straight rectangle Rect(3,3,3,2) and of a tilted rectangle Rect(5,1,2,3) . The selected pixels in the original image are shown, as well as the relative pixels in the integral images sum and tilted .

integral calculation example

 src input image as $$W \times H$$, 8-bit or floating-point (32f or 64f). sum integral image as $$(W+1)\times (H+1)$$ , 32-bit integer or floating-point (32f or 64f). sqsum integral image for squared pixel values; it is $$(W+1)\times (H+1)$$, double-precision floating-point (64f) array. tilted integral for the image rotated by 45 degrees; it is $$(W+1)\times (H+1)$$ array with the same data type as sum. sdepth desired depth of the integral and the tilted integral images, CV_32S, CV_32F, or CV_64F. sqdepth desired depth of the integral image of squared pixel values, CV_32F or CV_64F.

## ◆ threshold()

 double cv::threshold ( InputArray src , OutputArray dst , double thresh , double maxval , int type )
Python:
retval, dst = cv.threshold( src, thresh, maxval, type[, dst] )

 #include < opencv2/imgproc.hpp > 

Applies a fixed-level threshold to each array element.

The function applies fixed-level thresholding to a multiple-channel array. The function is typically used to get a bi-level (binary) image out of a grayscale image ( compare could be also used for this purpose) or for removing a noise, that is, filtering out pixels with too small or too large values. There are several types of thresholding supported by the function. They are determined by type parameter.

Also, the special values THRESH_OTSU or THRESH_TRIANGLE may be combined with one of the above values. In these cases, the function determines the optimal threshold value using the Otsu's or Triangle algorithm and uses it instead of the specified thresh.

Currently, the Otsu's and Triangle methods are implemented only for 8-bit single-channel images.

 src input array (multiple-channel, 8-bit or 32-bit floating point). dst output array of the same size and type and the same number of channels as src. thresh threshold value. maxval maximum value to use with the THRESH_BINARY and THRESH_BINARY_INV thresholding types. type thresholding type (see ThresholdTypes ).

the computed threshold value if Otsu's or Triangle methods used.

adaptiveThreshold , findContours , compare , min , max

samples/cpp/ffilldemo.cpp , samples/cpp/tutorial_code/ml/introduction_to_pca/introduction_to_pca.cpp ，和 samples/tapi/squares.cpp .

## ◆ watershed()

 void cv::watershed ( InputArray image , InputOutputArray markers )
Python:
markers = cv.watershed( image, markers )

 #include < opencv2/imgproc.hpp > 

Performs a marker-based image segmentation using the watershed algorithm.

The function implements one of the variants of watershed, non-parametric marker-based segmentation algorithm, described in [158] .

Before passing the image to the function, you have to roughly outline the desired regions in the image markers with positive (>0) indices. So, every region is represented as one or more connected components with the pixel values 1, 2, 3, and so on. Such markers can be retrieved from a binary mask using findContours and drawContours (see the watershed.cpp demo). The markers are "seeds" of the future image regions. All the other pixels in markers , whose relation to the outlined regions is not known and should be defined by the algorithm, should be set to 0's. In the function output, each pixel in markers is set to a value of the "seed" components or to -1 at boundaries between the regions.

Any two neighbor connected components are not necessarily separated by a watershed boundary (-1's pixels); for example, they can touch each other in the initial marker image passed to the function.

 image Input 8-bit 3-channel image. markers Input/output 32-bit single-channel image (map) of markers. It should have the same size as image .

findContours

samples/cpp/watershed.cpp .