Miscellaneous Image Transformations

Enumerations
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::DistanceTransformMasks { cv::DIST_MASK_3 = 3 , cv::DIST_MASK_5 = 5 , cv::DIST_MASK_PRECISE = 0 }
	Mask size for distance transform. More...
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_MASK = 7 , cv::THRESH_OTSU = 8 , cv::THRESH_TRIANGLE = 16 }
enum	cv::AdaptiveThresholdTypes { cv::ADAPTIVE_THRESH_MEAN_C = 0 , cv::ADAPTIVE_THRESH_GAUSSIAN_C = 1 }
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 More...
enum	cv::GrabCutModes { cv::GC_INIT_WITH_RECT = 0 , cv::GC_INIT_WITH_MASK = 1 , cv::GC_EVAL = 2 , cv::GC_EVAL_FREEZE_MODEL = 3 }
	GrabCut algorithm flags. More...
enum	cv::DistanceTransformLabelTypes { cv::DIST_LABEL_CCOMP = 0 , cv::DIST_LABEL_PIXEL = 1 }
	distanceTransform algorithm flags More...
enum	cv::FloodFillFlags { cv::FLOODFILL_FIXED_RANGE = 1 << 16 , cv::FLOODFILL_MASK_ONLY = 1 << 17 }
	floodfill algorithm flags More...

Functions
	cv::CV_EXPORTS_AS (integral3) void integral(InputArray src
	Calculates the integral of an image. More...
CV_EXPORTS_W void	cv::integral (InputArray src, OutputArray sum, int sdepth=-1)
	cv::CV_EXPORTS_AS (integral2) void integral(InputArray src
CV_EXPORTS_W double	cv::threshold (InputArray src, OutputArray dst, double thresh, double maxval, int type)
	Applies a fixed-level threshold to each array element. More...
CV_EXPORTS_W void	cv::adaptiveThreshold (InputArray src, OutputArray dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C)
	Applies an adaptive threshold to an array. More...
	cv::CV_EXPORTS_AS (distanceTransformWithLabels) void distanceTransform(InputArray src
	Calculates the distance to the closest zero pixel for each pixel of the source image. More...
CV_EXPORTS_W void	cv::distanceTransform (InputArray src, OutputArray dst, int distanceType, int maskSize, int dstType=CV_32F)
CV_EXPORTS_W int	cv::floodFill (InputOutputArray image, InputOutputArray mask, Point seedPoint, Scalar newVal, CV_OUT Rect *rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4)
	Fills a connected component with the given color. More...
CV_EXPORTS int	cv::floodFill (InputOutputArray image, Point seedPoint, Scalar newVal, CV_OUT Rect *rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4)
CV_EXPORTS_W void	cv::blendLinear (InputArray src1, InputArray src2, InputArray weights1, InputArray weights2, OutputArray dst)

Variables
OutputArray	cv::sum
OutputArray OutputArray	cv::sqsum
OutputArray OutputArray OutputArray	cv::tilted
OutputArray OutputArray OutputArray int	cv::sdepth = -1
OutputArray OutputArray OutputArray int int	cv::sqdepth = -1 )
OutputArray	cv::dst
OutputArray OutputArray	cv::labels
OutputArray OutputArray int	cv::distanceType
OutputArray OutputArray int int	cv::maskSize
OutputArray OutputArray int int int	cv::labelType = DIST_LABEL_CCOMP )

Detailed Description

Enumeration Type Documentation

AdaptiveThresholdTypes

enum cv::AdaptiveThresholdTypes

adaptive threshold algorithm

See also

adaptiveThreshold

Enumerator
ADAPTIVE_THRESH_MEAN_C	the threshold value is a mean of the neighborhood of minus C
ADAPTIVE_THRESH_GAUSSIAN_C	the threshold value is a weighted sum (cross-correlation with a Gaussian window) of the neighborhood of minus C . The default sigma (standard deviation) is used for the specified blockSize . See getGaussianKernel

DistanceTransformLabelTypes

enum cv::DistanceTransformLabelTypes

distanceTransform algorithm flags

Enumerator
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	each zero pixel (and all the non-zero pixels closest to it) gets its own label.

DistanceTransformMasks

enum cv::DistanceTransformMasks

Mask size for distance transform.

Enumerator
DIST_MASK_3	mask=3
DIST_MASK_5	mask=5
DIST_MASK_PRECISE

DistanceTypes

enum cv::DistanceTypes

Distance types for Distance Transform and M-estimators

See also

distanceTransform, fitLine

Enumerator
DIST_USER	User defined distance.
DIST_L1	distance = |x1-x2| + |y1-y2|
DIST_L2	the simple euclidean distance
DIST_C	distance = max(|x1-x2|,|y1-y2|)
DIST_L12	L1-L2 metric: distance = 2(sqrt(1+x*x/2) - 1))
DIST_FAIR	distance = c^2(|x|/c-log(1+|x|/c)), c = 1.3998
DIST_WELSCH	distance = c^2/2(1-exp(-(x/c)^2)), c = 2.9846
DIST_HUBER	distance = |x|<c ? x^2/2 : c(|x|-c/2), c=1.345

FloodFillFlags

enum cv::FloodFillFlags

floodfill algorithm flags

Enumerator
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).
FLOODFILL_MASK_ONLY	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

class of the pixel in GrabCut algorithm

Enumerator
GC_BGD	an obvious background pixels
GC_FGD	an obvious foreground (object) pixel
GC_PR_BGD	a possible background pixel
GC_PR_FGD	a possible foreground pixel

GrabCutModes

enum cv::GrabCutModes

GrabCut algorithm flags.

Enumerator
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.
GC_INIT_WITH_MASK	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	The value means that the algorithm should just resume.
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

type of the threshold operation

Enumerator
THRESH_BINARY
THRESH_BINARY_INV
THRESH_TRUNC
THRESH_TOZERO
THRESH_TOZERO_INV
THRESH_MASK
THRESH_OTSU	flag, use Otsu algorithm to choose the optimal threshold value
THRESH_TRIANGLE	flag, use Triangle algorithm to choose the optimal threshold value

Function Documentation

adaptiveThreshold()

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

Applies an adaptive threshold to an array.

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

• THRESH_BINARY

  

• THRESH_BINARY_INV

  

  where is a threshold calculated individually for each pixel (see adaptiveMethod parameter).

The function can process the image in-place.

Parameters

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. The BORDER_REPLICATE | BORDER_ISOLATED is used to process boundaries.
thresholdType	Thresholding type that must be either THRESH_BINARY or THRESH_BINARY_INV, see 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.

See also

threshold, blur, GaussianBlur

blendLinear()

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

Performs linear blending of two images:

Parameters

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.

CV_EXPORTS_AS() [1/3]

cv::CV_EXPORTS_AS

(

distanceTransformWithLabels

)

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

The function cv::distanceTransform calculates the approximate or precise distance from every binary image pixel to the nearest zero pixel. For zero image pixels, the distance will obviously be zero.

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

In other cases, the algorithm [Borgefors86] 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 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 mask gives more accurate results). For a,b, and 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 mask is used. For a more accurate distance estimation DIST_L2, a 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 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_PIXEL, 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.

Parameters

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 mask gives the same result as or any larger aperture.
labelType	Type of the label array to build, see DistanceTransformLabelTypes.

CV_EXPORTS_AS() [2/3]

cv::CV_EXPORTS_AS

(

integral2

)

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

CV_EXPORTS_AS() [3/3]

cv::CV_EXPORTS_AS

(

integral3

)

Calculates the integral of an image.

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

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:

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(4,4,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 .

Parameters

src	input image as , 8-bit or floating-point (32f or 64f).
sum	integral image as , 32-bit integer or floating-point (32f or 64f).
sqsum	integral image for squared pixel values; it is , double-precision floating-point (64f) array.
tilted	integral for the image rotated by 45 degrees; it is 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.

distanceTransform()

CV_EXPORTS_W void cv::distanceTransform	(	InputArray	src,
		OutputArray	dst,
		int	distanceType,
		int	maskSize,
		int	dstType = CV_32F
	)

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

Parameters

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 mask gives the same result as 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]

CV_EXPORTS_W int cv::floodFill	(	InputOutputArray	image,
		InputOutputArray	mask,
		Point	seedPoint,
		Scalar	newVal,
		CV_OUT Rect *	rect = 0,
		Scalar	loDiff = Scalar(),
		Scalar	upDiff = Scalar(),
		int	flags = 4
	)

Fills a connected component with the given color.

The function cv::floodFill fills a connected component starting from the seed point with the specified color. The connectivity is determined by the color/brightness closeness of the neighbor pixels. The pixel at is considered to belong to the repainted domain if:

• in case of a grayscale image and floating range

  

• in case of a grayscale image and fixed range

  

• in case of a color image and floating range

  

  

  and

  

• in case of a color image and fixed range

  

  

  and

  

where 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.

Parameters

image	Input/output 1- or 3-channel, 8-bit, or floating-point image. It is modified by the function unless the FLOODFILL_MASK_ONLY flag is set in the second variant of the function. See the details below.
mask	Operation mask that should be a single-channel 8-bit image, 2 pixels wider and 2 pixels taller than image. If an empty Mat is passed it will be created automatically. Since this is both an input and output parameter, you must take responsibility of initializing it. Flood-filling cannot go across non-zero pixels in the input mask. For example, an edge detector output can be used as a mask to stop filling at edges. On output, pixels in the mask corresponding to filled pixels in the image are set to 1 or to the specified value in flags as described below. Additionally, the function fills the border of the mask with ones to simplify internal processing. It is therefore possible to use the same mask in multiple calls to the function to make sure the filled areas do not overlap.
seedPoint	Starting point.
newVal	New value of the repainted domain pixels.
loDiff	Maximal lower brightness/color difference between the currently observed pixel and one of its neighbors belonging to the component, or a seed pixel being added to the component.
upDiff	Maximal upper brightness/color difference between the currently observed pixel and one of its neighbors belonging to the component, or a seed pixel being added to the component.
rect	Optional output parameter set by the function to the minimum bounding rectangle of the repainted domain.
flags	Operation flags. The first 8 bits contain a connectivity value. The default value of 4 means that only the four nearest neighbor pixels (those that share an edge) are considered. A connectivity value of 8 means that the eight nearest neighbor pixels (those that share a corner) will be considered. The next 8 bits (8-16) contain a value between 1 and 255 with which to fill the mask (the default value is 1). For example, 4 | ( 255 << 8 ) will consider 4 nearest neighbours and fill the mask with a value of 255. The following additional options occupy higher bits and therefore may be further combined with the connectivity and mask fill values using bit-wise or (|), see FloodFillFlags.

Note

Since the mask is larger than the filled image, a pixel in image corresponds to the pixel in the mask .

See also

findContours

floodFill() [2/2]

CV_EXPORTS int cv::floodFill	(	InputOutputArray	image,
		Point	seedPoint,
		Scalar	newVal,
		CV_OUT Rect *	rect = 0,
		Scalar	loDiff = Scalar(),
		Scalar	upDiff = Scalar(),
		int	flags = 4
	)

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

integral()

CV_EXPORTS_W void cv::integral	(	InputArray	src,
		OutputArray	sum,
		int	sdepth = -1
	)

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

threshold()

CV_EXPORTS_W double cv::threshold	(	InputArray	src,
		OutputArray	dst,
		double	thresh,
		double	maxval,
		int	type
	)

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.

Note

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

Parameters

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).

Returns

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

See also

adaptiveThreshold, findContours, compare, min, max

Variable Documentation

distanceType

OutputArray OutputArray int cv::distanceType

dst

OutputArray cv::dst

labels

OutputArray cv::labels

labelType

OutputArray OutputArray int int int cv::labelType = DIST_LABEL_CCOMP )

maskSize

OutputArray OutputArray int int cv::maskSize

sdepth

OutputArray OutputArray int cv::sdepth = -1

sqdepth

OutputArray OutputArray int int cv::sqdepth = -1 )

sqsum

OutputArray OutputArray cv::sqsum

sum

OutputArray cv::sum

tilted

OutputArray OutputArray OutputArray cv::tilted