@spec absdiff(Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in()) ::
  Evision.Mat.t() | {:error, String.t()}

Calculates the per-element absolute difference between two arrays or between an array and a scalar.

Positional Arguments

• src1: Evision.Mat.t().

  first input array or a scalar.

• src2: Evision.Mat.t().

  second input array or a scalar.

Return

• dst: Evision.Mat.t().

  output array that has the same size and type as input arrays.

The function cv::absdiff calculates: Absolute difference between two arrays when they have the same size and type: \f[\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{src2}(I)|)\f] Absolute difference between an array and a scalar when the second array is constructed from Scalar or has as many elements as the number of channels in src1: \f[\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{src2} |)\f] Absolute difference between a scalar and an array when the first array is constructed from Scalar or has as many elements as the number of channels in src2: \f[\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1} - \texttt{src2}(I) |)\f] where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently. Note: Saturation is not applied when the arrays have the depth CV_32S. You may even get a negative value in the case of overflow. @sa cv::abs(const Mat&)

Python prototype (for reference only):

absdiff(src1, src2[, dst]) -> dst

@spec absdiff(
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  [{atom(), term()}, ...] | nil
) ::
  Evision.Mat.t() | {:error, String.t()}

Calculates the per-element absolute difference between two arrays or between an array and a scalar.

Positional Arguments

• src1: Evision.Mat.t().

  first input array or a scalar.

• src2: Evision.Mat.t().

  second input array or a scalar.

Return

• dst: Evision.Mat.t().

  output array that has the same size and type as input arrays.

The function cv::absdiff calculates: Absolute difference between two arrays when they have the same size and type: \f[\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{src2}(I)|)\f] Absolute difference between an array and a scalar when the second array is constructed from Scalar or has as many elements as the number of channels in src1: \f[\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{src2} |)\f] Absolute difference between a scalar and an array when the first array is constructed from Scalar or has as many elements as the number of channels in src2: \f[\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1} - \texttt{src2}(I) |)\f] where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently. Note: Saturation is not applied when the arrays have the depth CV_32S. You may even get a negative value in the case of overflow. @sa cv::abs(const Mat&)

Python prototype (for reference only):

absdiff(src1, src2[, dst]) -> dst

@spec accumulate(Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in()) ::
  Evision.Mat.t() | {:error, String.t()}

Adds an image to the accumulator image.

Positional Arguments

• src: Evision.Mat.t().

  Input image of type CV_8UC(n), CV_16UC(n), CV_32FC(n) or CV_64FC(n), where n is a positive integer.

Keyword Arguments

• mask: Evision.Mat.t().

  Optional operation mask.

Return

• dst: Evision.Mat.t().

  %Accumulator image with the same number of channels as input image, and a depth of CV_32F or CV_64F.

The function adds src or some of its elements to dst : \f[\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\f] The function supports multi-channel images. Each channel is processed independently. The function cv::accumulate can be used, for example, to collect statistics of a scene background viewed by a still camera and for the further foreground-background segmentation.

@sa accumulateSquare, accumulateProduct, accumulateWeighted

Python prototype (for reference only):

accumulate(src, dst[, mask]) -> dst

@spec accumulate(
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  [{atom(), term()}, ...] | nil
) ::
  Evision.Mat.t() | {:error, String.t()}

Adds an image to the accumulator image.

Positional Arguments

• src: Evision.Mat.t().

  Input image of type CV_8UC(n), CV_16UC(n), CV_32FC(n) or CV_64FC(n), where n is a positive integer.

Keyword Arguments

• mask: Evision.Mat.t().

  Optional operation mask.

Return

• dst: Evision.Mat.t().

  %Accumulator image with the same number of channels as input image, and a depth of CV_32F or CV_64F.

The function adds src or some of its elements to dst : \f[\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\f] The function supports multi-channel images. Each channel is processed independently. The function cv::accumulate can be used, for example, to collect statistics of a scene background viewed by a still camera and for the further foreground-background segmentation.

@sa accumulateSquare, accumulateProduct, accumulateWeighted

Python prototype (for reference only):

accumulate(src, dst[, mask]) -> dst

@spec accumulateProduct(
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in()
) :: Evision.Mat.t() | {:error, String.t()}

Adds the per-element product of two input images to the accumulator image.

Positional Arguments

• src1: Evision.Mat.t().

  First input image, 1- or 3-channel, 8-bit or 32-bit floating point.

• src2: Evision.Mat.t().

  Second input image of the same type and the same size as src1 .

Keyword Arguments

• mask: Evision.Mat.t().

  Optional operation mask.

Return

• dst: Evision.Mat.t().

  %Accumulator image with the same number of channels as input images, 32-bit or 64-bit floating-point.

The function adds the product of two images or their selected regions to the accumulator dst : \f[\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src1} (x,y) \cdot \texttt{src2} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\f] The function supports multi-channel images. Each channel is processed independently.

@sa accumulate, accumulateSquare, accumulateWeighted

Python prototype (for reference only):

accumulateProduct(src1, src2, dst[, mask]) -> dst

@spec accumulateProduct(
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  [{atom(), term()}, ...] | nil
) :: Evision.Mat.t() | {:error, String.t()}

Adds the per-element product of two input images to the accumulator image.

Positional Arguments

• src1: Evision.Mat.t().

  First input image, 1- or 3-channel, 8-bit or 32-bit floating point.

• src2: Evision.Mat.t().

  Second input image of the same type and the same size as src1 .

Keyword Arguments

• mask: Evision.Mat.t().

  Optional operation mask.

Return

• dst: Evision.Mat.t().

  %Accumulator image with the same number of channels as input images, 32-bit or 64-bit floating-point.

The function adds the product of two images or their selected regions to the accumulator dst : \f[\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src1} (x,y) \cdot \texttt{src2} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\f] The function supports multi-channel images. Each channel is processed independently.

@sa accumulate, accumulateSquare, accumulateWeighted

Python prototype (for reference only):

accumulateProduct(src1, src2, dst[, mask]) -> dst

@spec accumulateSquare(Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in()) ::
  Evision.Mat.t() | {:error, String.t()}

Adds the square of a source image to the accumulator image.

Positional Arguments

• src: Evision.Mat.t().

  Input image as 1- or 3-channel, 8-bit or 32-bit floating point.

Keyword Arguments

• mask: Evision.Mat.t().

  Optional operation mask.

Return

• dst: Evision.Mat.t().

  %Accumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point.

The function adds the input image src or its selected region, raised to a power of 2, to the accumulator dst : \f[\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src} (x,y)^2 \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\f] The function supports multi-channel images. Each channel is processed independently.

@sa accumulateSquare, accumulateProduct, accumulateWeighted

Python prototype (for reference only):

accumulateSquare(src, dst[, mask]) -> dst

@spec accumulateSquare(
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  [{atom(), term()}, ...] | nil
) :: Evision.Mat.t() | {:error, String.t()}

Adds the square of a source image to the accumulator image.

Positional Arguments

• src: Evision.Mat.t().

  Input image as 1- or 3-channel, 8-bit or 32-bit floating point.

Keyword Arguments

• mask: Evision.Mat.t().

  Optional operation mask.

Return

• dst: Evision.Mat.t().

  %Accumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point.

The function adds the input image src or its selected region, raised to a power of 2, to the accumulator dst : \f[\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src} (x,y)^2 \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\f] The function supports multi-channel images. Each channel is processed independently.

@sa accumulateSquare, accumulateProduct, accumulateWeighted

Python prototype (for reference only):

accumulateSquare(src, dst[, mask]) -> dst

@spec accumulateWeighted(
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  number()
) ::
  Evision.Mat.t() | {:error, String.t()}

Updates a running average.

Positional Arguments

• src: Evision.Mat.t().

  Input image as 1- or 3-channel, 8-bit or 32-bit floating point.

• alpha: double.

  Weight of the input image.

Keyword Arguments

• mask: Evision.Mat.t().

  Optional operation mask.

Return

• dst: Evision.Mat.t().

  %Accumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point.

The function calculates the weighted sum of the input image src and the accumulator dst so that dst becomes a running average of a frame sequence: \f[\texttt{dst} (x,y) \leftarrow (1- \texttt{alpha} ) \cdot \texttt{dst} (x,y) + \texttt{alpha} \cdot \texttt{src} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\f] That is, alpha regulates the update speed (how fast the accumulator "forgets" about earlier images). The function supports multi-channel images. Each channel is processed independently.

@sa accumulate, accumulateSquare, accumulateProduct

Python prototype (for reference only):

accumulateWeighted(src, dst, alpha[, mask]) -> dst

@spec accumulateWeighted(
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  number(),
  [{atom(), term()}, ...] | nil
) :: Evision.Mat.t() | {:error, String.t()}

Updates a running average.

Positional Arguments

• src: Evision.Mat.t().

  Input image as 1- or 3-channel, 8-bit or 32-bit floating point.

• alpha: double.

  Weight of the input image.

Keyword Arguments

• mask: Evision.Mat.t().

  Optional operation mask.

Return

• dst: Evision.Mat.t().

  %Accumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point.

The function calculates the weighted sum of the input image src and the accumulator dst so that dst becomes a running average of a frame sequence: \f[\texttt{dst} (x,y) \leftarrow (1- \texttt{alpha} ) \cdot \texttt{dst} (x,y) + \texttt{alpha} \cdot \texttt{src} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\f] That is, alpha regulates the update speed (how fast the accumulator "forgets" about earlier images). The function supports multi-channel images. Each channel is processed independently.

@sa accumulate, accumulateSquare, accumulateProduct

Python prototype (for reference only):

accumulateWeighted(src, dst, alpha[, mask]) -> dst

@spec adaptiveThreshold(
  Evision.Mat.maybe_mat_in(),
  number(),
  integer(),
  integer(),
  integer(),
  number()
) ::
  Evision.Mat.t() | {:error, String.t()}

Applies an adaptive threshold to an array.

Positional Arguments

• src: Evision.Mat.t().

  Source 8-bit single-channel image.

• maxValue: double.

  Non-zero value assigned to the pixels for which the condition is satisfied

• adaptiveMethod: int.

  Adaptive thresholding algorithm to use, see #AdaptiveThresholdTypes. The #BORDER_REPLICATE | #BORDER_ISOLATED is used to process boundaries.

• thresholdType: int.

  Thresholding type that must be either #THRESH_BINARY or #THRESH_BINARY_INV, see #ThresholdTypes.

• blockSize: int.

  Size of a pixel neighborhood that is used to calculate a threshold value for the pixel: 3, 5, 7, and so on.

• c: double.

  Constant subtracted from the mean or weighted mean (see the details below). Normally, it is positive but may be zero or negative as well.

Return

• dst: Evision.Mat.t().

  Destination image of the same size and the same type as src.

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

• THRESH_BINARY \f[dst(x,y) = \fork{\texttt{maxValue}}{if (src(x,y) > T(x,y))}{0}{otherwise}\f]

• THRESH_BINARY_INV \f[dst(x,y) = \fork{0}{if (src(x,y) > T(x,y))}{\texttt{maxValue}}{otherwise}\f] where \f$T(x,y)\f$ is a threshold calculated individually for each pixel (see adaptiveMethod parameter).

The function can process the image in-place.

@sa threshold, blur, GaussianBlur

Python prototype (for reference only):

adaptiveThreshold(src, maxValue, adaptiveMethod, thresholdType, blockSize, C[, dst]) -> dst

@spec adaptiveThreshold(
  Evision.Mat.maybe_mat_in(),
  number(),
  integer(),
  integer(),
  integer(),
  number(),
  [{atom(), term()}, ...] | nil
) :: Evision.Mat.t() | {:error, String.t()}

Applies an adaptive threshold to an array.

Positional Arguments

• src: Evision.Mat.t().

  Source 8-bit single-channel image.

• maxValue: double.

  Non-zero value assigned to the pixels for which the condition is satisfied

• adaptiveMethod: int.

  Adaptive thresholding algorithm to use, see #AdaptiveThresholdTypes. The #BORDER_REPLICATE | #BORDER_ISOLATED is used to process boundaries.

• thresholdType: int.

  Thresholding type that must be either #THRESH_BINARY or #THRESH_BINARY_INV, see #ThresholdTypes.

• blockSize: int.

  Size of a pixel neighborhood that is used to calculate a threshold value for the pixel: 3, 5, 7, and so on.

• c: double.

  Constant subtracted from the mean or weighted mean (see the details below). Normally, it is positive but may be zero or negative as well.

Return

• dst: Evision.Mat.t().

  Destination image of the same size and the same type as src.

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

• THRESH_BINARY \f[dst(x,y) = \fork{\texttt{maxValue}}{if (src(x,y) > T(x,y))}{0}{otherwise}\f]

• THRESH_BINARY_INV \f[dst(x,y) = \fork{0}{if (src(x,y) > T(x,y))}{\texttt{maxValue}}{otherwise}\f] where \f$T(x,y)\f$ is a threshold calculated individually for each pixel (see adaptiveMethod parameter).

The function can process the image in-place.

@sa threshold, blur, GaussianBlur

Python prototype (for reference only):

adaptiveThreshold(src, maxValue, adaptiveMethod, thresholdType, blockSize, C[, dst]) -> dst

@spec add(Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in()) ::
  Evision.Mat.t() | {:error, String.t()}

Calculates the per-element sum of two arrays or an array and a scalar.

Positional Arguments

• src1: Evision.Mat.t().

  first input array or a scalar.

• src2: Evision.Mat.t().

  second input array or a scalar.

Keyword Arguments

• mask: Evision.Mat.t().

  optional operation mask - 8-bit single channel array, that specifies elements of the output array to be changed.

• dtype: int.

  optional depth of the output array (see the discussion below).

Return

• dst: Evision.Mat.t().

  output array that has the same size and number of channels as the input array(s); the depth is defined by dtype or src1/src2.

The function add calculates:

• Sum of two arrays when both input arrays have the same size and the same number of channels: \f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\f]

• Sum of an array and a scalar when src2 is constructed from Scalar or has the same number of elements as src1.channels(): \f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\f]

• Sum of a scalar and an array when src1 is constructed from Scalar or has the same number of elements as src2.channels(): \f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} + \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\f] where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently.

The first function in the list above can be replaced with matrix expressions:

dst = src1 + src2;
dst += src1; // equivalent to add(dst, src1, dst);

The input arrays and the output array can all have the same or different depths. For example, you can add a 16-bit unsigned array to a 8-bit signed array and store the sum as a 32-bit floating-point array. Depth of the output array is determined by the dtype parameter. In the second and third cases above, as well as in the first case, when src1.depth() == src2.depth(), dtype can be set to the default -1. In this case, the output array will have the same depth as the input array, be it src1, src2 or both. Note: Saturation is not applied when the output array has the depth CV_32S. You may even get result of an incorrect sign in the case of overflow. @sa subtract, addWeighted, scaleAdd, Mat::convertTo

Python prototype (for reference only):

add(src1, src2[, dst[, mask[, dtype]]]) -> dst

@spec add(
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  [{atom(), term()}, ...] | nil
) ::
  Evision.Mat.t() | {:error, String.t()}

Calculates the per-element sum of two arrays or an array and a scalar.

Positional Arguments

• src1: Evision.Mat.t().

  first input array or a scalar.

• src2: Evision.Mat.t().

  second input array or a scalar.

Keyword Arguments

• mask: Evision.Mat.t().

  optional operation mask - 8-bit single channel array, that specifies elements of the output array to be changed.

• dtype: int.

  optional depth of the output array (see the discussion below).

Return

• dst: Evision.Mat.t().

  output array that has the same size and number of channels as the input array(s); the depth is defined by dtype or src1/src2.

The function add calculates:

• Sum of two arrays when both input arrays have the same size and the same number of channels: \f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\f]

• Sum of an array and a scalar when src2 is constructed from Scalar or has the same number of elements as src1.channels(): \f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\f]

• Sum of a scalar and an array when src1 is constructed from Scalar or has the same number of elements as src2.channels(): \f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} + \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\f] where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently.

The first function in the list above can be replaced with matrix expressions:

dst = src1 + src2;
dst += src1; // equivalent to add(dst, src1, dst);

The input arrays and the output array can all have the same or different depths. For example, you can add a 16-bit unsigned array to a 8-bit signed array and store the sum as a 32-bit floating-point array. Depth of the output array is determined by the dtype parameter. In the second and third cases above, as well as in the first case, when src1.depth() == src2.depth(), dtype can be set to the default -1. In this case, the output array will have the same depth as the input array, be it src1, src2 or both. Note: Saturation is not applied when the output array has the depth CV_32S. You may even get result of an incorrect sign in the case of overflow. @sa subtract, addWeighted, scaleAdd, Mat::convertTo

Python prototype (for reference only):

add(src1, src2[, dst[, mask[, dtype]]]) -> dst

@spec addText(Evision.Mat.maybe_mat_in(), binary(), {number(), number()}, binary()) ::
  :ok | {:error, String.t()}

Draws a text on the image.

Positional Arguments

• img: Evision.Mat.t().

  8-bit 3-channel image where the text should be drawn.

• text: String.

  Text to write on an image.

• org: Point.

  Point(x,y) where the text should start on an image.

• nameFont: String.

  Name of the font. The name should match the name of a system font (such as Times*). If the font is not found, a default one is used.

Keyword Arguments

• pointSize: int.

  Size of the font. If not specified, equal zero or negative, the point size of the font is set to a system-dependent default value. Generally, this is 12 points.

• color: Scalar.

  Color of the font in BGRA where A = 255 is fully transparent.

• weight: int.

  Font weight. Available operation flags are : cv::QtFontWeights You can also specify a positive integer for better control.

• style: int.

  Font style. Available operation flags are : cv::QtFontStyles

• spacing: int.

  Spacing between characters. It can be negative or positive.

Python prototype (for reference only):

addText(img, text, org, nameFont[, pointSize[, color[, weight[, style[, spacing]]]]]) -> None

@spec addText(
  Evision.Mat.maybe_mat_in(),
  binary(),
  {number(), number()},
  binary(),
  [{atom(), term()}, ...] | nil
) :: :ok | {:error, String.t()}

Draws a text on the image.

Positional Arguments

• img: Evision.Mat.t().

  8-bit 3-channel image where the text should be drawn.

• text: String.

  Text to write on an image.

• org: Point.

  Point(x,y) where the text should start on an image.

• nameFont: String.

  Name of the font. The name should match the name of a system font (such as Times*). If the font is not found, a default one is used.

Keyword Arguments

• pointSize: int.

  Size of the font. If not specified, equal zero or negative, the point size of the font is set to a system-dependent default value. Generally, this is 12 points.

• color: Scalar.

  Color of the font in BGRA where A = 255 is fully transparent.

• weight: int.

  Font weight. Available operation flags are : cv::QtFontWeights You can also specify a positive integer for better control.

• style: int.

  Font style. Available operation flags are : cv::QtFontStyles

• spacing: int.

  Spacing between characters. It can be negative or positive.

Python prototype (for reference only):

addText(img, text, org, nameFont[, pointSize[, color[, weight[, style[, spacing]]]]]) -> None

@spec addWeighted(
  Evision.Mat.maybe_mat_in(),
  number(),
  Evision.Mat.maybe_mat_in(),
  number(),
  number()
) ::
  Evision.Mat.t() | {:error, String.t()}

Calculates the weighted sum of two arrays.

Positional Arguments

• src1: Evision.Mat.t().

  first input array.

• alpha: double.

  weight of the first array elements.

• src2: Evision.Mat.t().

  second input array of the same size and channel number as src1.

• beta: double.

  weight of the second array elements.

• gamma: double.

  scalar added to each sum.

Keyword Arguments

• dtype: int.

  optional depth of the output array; when both input arrays have the same depth, dtype can be set to -1, which will be equivalent to src1.depth().

Return

• dst: Evision.Mat.t().

  output array that has the same size and number of channels as the input arrays.

The function addWeighted calculates the weighted sum of two arrays as follows: \f[\texttt{dst} (I)= \texttt{saturate} ( \texttt{src1} (I)* \texttt{alpha} + \texttt{src2} (I)* \texttt{beta} + \texttt{gamma} )\f] where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently. The function can be replaced with a matrix expression:

dst = src1*alpha + src2*beta + gamma;

Note: Saturation is not applied when the output array has the depth CV_32S. You may even get result of an incorrect sign in the case of overflow. @sa add, subtract, scaleAdd, Mat::convertTo

Python prototype (for reference only):

addWeighted(src1, alpha, src2, beta, gamma[, dst[, dtype]]) -> dst

@spec addWeighted(
  Evision.Mat.maybe_mat_in(),
  number(),
  Evision.Mat.maybe_mat_in(),
  number(),
  number(),
  [{atom(), term()}, ...] | nil
) :: Evision.Mat.t() | {:error, String.t()}

Calculates the weighted sum of two arrays.

Positional Arguments

• src1: Evision.Mat.t().

  first input array.

• alpha: double.

  weight of the first array elements.

• src2: Evision.Mat.t().

  second input array of the same size and channel number as src1.

• beta: double.

  weight of the second array elements.

• gamma: double.

  scalar added to each sum.

Keyword Arguments

• dtype: int.

  optional depth of the output array; when both input arrays have the same depth, dtype can be set to -1, which will be equivalent to src1.depth().

Return

• dst: Evision.Mat.t().

  output array that has the same size and number of channels as the input arrays.

The function addWeighted calculates the weighted sum of two arrays as follows: \f[\texttt{dst} (I)= \texttt{saturate} ( \texttt{src1} (I)* \texttt{alpha} + \texttt{src2} (I)* \texttt{beta} + \texttt{gamma} )\f] where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently. The function can be replaced with a matrix expression:

dst = src1*alpha + src2*beta + gamma;

Note: Saturation is not applied when the output array has the depth CV_32S. You may even get result of an incorrect sign in the case of overflow. @sa add, subtract, scaleAdd, Mat::convertTo

Python prototype (for reference only):

addWeighted(src1, alpha, src2, beta, gamma[, dst[, dtype]]) -> dst

@spec applyColorMap(Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in()) ::
  Evision.Mat.t() | {:error, String.t()}

@spec applyColorMap(Evision.Mat.maybe_mat_in(), integer()) ::
  Evision.Mat.t() | {:error, String.t()}

Variant 1:

Applies a user colormap on a given image.

Positional Arguments

• src: Evision.Mat.t().

  The source image, grayscale or colored of type CV_8UC1 or CV_8UC3.

• userColor: Evision.Mat.t().

  The colormap to apply of type CV_8UC1 or CV_8UC3 and size 256

Return

• dst: Evision.Mat.t().

  The result is the colormapped source image. Note: Mat::create is called on dst.

Python prototype (for reference only):

applyColorMap(src, userColor[, dst]) -> dst

Variant 2:

Applies a GNU Octave/MATLAB equivalent colormap on a given image.

Positional Arguments

• src: Evision.Mat.t().

  The source image, grayscale or colored of type CV_8UC1 or CV_8UC3.

• colormap: int.

  The colormap to apply, see #ColormapTypes

Return

• dst: Evision.Mat.t().

  The result is the colormapped source image. Note: Mat::create is called on dst.

Python prototype (for reference only):

applyColorMap(src, colormap[, dst]) -> dst

@spec applyColorMap(
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  [{atom(), term()}, ...] | nil
) :: Evision.Mat.t() | {:error, String.t()}

@spec applyColorMap(
  Evision.Mat.maybe_mat_in(),
  integer(),
  [{atom(), term()}, ...] | nil
) ::
  Evision.Mat.t() | {:error, String.t()}

Variant 1:

Applies a user colormap on a given image.

Positional Arguments

• src: Evision.Mat.t().

  The source image, grayscale or colored of type CV_8UC1 or CV_8UC3.

• userColor: Evision.Mat.t().

  The colormap to apply of type CV_8UC1 or CV_8UC3 and size 256

Return

• dst: Evision.Mat.t().

  The result is the colormapped source image. Note: Mat::create is called on dst.

Python prototype (for reference only):

applyColorMap(src, userColor[, dst]) -> dst

Variant 2:

Applies a GNU Octave/MATLAB equivalent colormap on a given image.

Positional Arguments

• src: Evision.Mat.t().

  The source image, grayscale or colored of type CV_8UC1 or CV_8UC3.

• colormap: int.

  The colormap to apply, see #ColormapTypes

Return

• dst: Evision.Mat.t().

  The result is the colormapped source image. Note: Mat::create is called on dst.

Python prototype (for reference only):

applyColorMap(src, colormap[, dst]) -> dst

@spec approxPolyDP(Evision.Mat.maybe_mat_in(), number(), boolean()) ::
  Evision.Mat.t() | {:error, String.t()}

Approximates a polygonal curve(s) with the specified precision.

Positional Arguments

• curve: Evision.Mat.t().

  Input vector of a 2D point stored in std::vector or Mat

• epsilon: double.

  Parameter specifying the approximation accuracy. This is the maximum distance between the original curve and its approximation.

• closed: bool.

  If true, the approximated curve is closed (its first and last vertices are connected). Otherwise, it is not closed.

Return

• approxCurve: Evision.Mat.t().

  Result of the approximation. The type should match the type of the input curve.

The function cv::approxPolyDP approximates a curve or a polygon with another curve/polygon with less vertices so that the distance between them is less or equal to the specified precision. It uses the Douglas-Peucker algorithm http://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm

Python prototype (for reference only):

approxPolyDP(curve, epsilon, closed[, approxCurve]) -> approxCurve

@spec approxPolyDP(
  Evision.Mat.maybe_mat_in(),
  number(),
  boolean(),
  [{atom(), term()}, ...] | nil
) ::
  Evision.Mat.t() | {:error, String.t()}

Approximates a polygonal curve(s) with the specified precision.

Positional Arguments

• curve: Evision.Mat.t().

  Input vector of a 2D point stored in std::vector or Mat

• epsilon: double.

  Parameter specifying the approximation accuracy. This is the maximum distance between the original curve and its approximation.

• closed: bool.

  If true, the approximated curve is closed (its first and last vertices are connected). Otherwise, it is not closed.

Return

• approxCurve: Evision.Mat.t().

  Result of the approximation. The type should match the type of the input curve.

The function cv::approxPolyDP approximates a curve or a polygon with another curve/polygon with less vertices so that the distance between them is less or equal to the specified precision. It uses the Douglas-Peucker algorithm http://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm

Python prototype (for reference only):

approxPolyDP(curve, epsilon, closed[, approxCurve]) -> approxCurve

@spec arcLength(Evision.Mat.maybe_mat_in(), boolean()) ::
  number() | {:error, String.t()}

Calculates a contour perimeter or a curve length.

Positional Arguments

• curve: Evision.Mat.t().

  Input vector of 2D points, stored in std::vector or Mat.

• closed: bool.

  Flag indicating whether the curve is closed or not.

Return

• retval: double

The function computes a curve length or a closed contour perimeter.

Python prototype (for reference only):

arcLength(curve, closed) -> retval

@spec arrowedLine(
  Evision.Mat.maybe_mat_in(),
  {number(), number()},
  {number(), number()},
  {number()}
  | {number(), number()}
  | {number(), number(), number()}
  | {number(), number(), number(), number()}
) :: Evision.Mat.t() | {:error, String.t()}

Draws an arrow segment pointing from the first point to the second one.

Positional Arguments

• pt1: Point.

  The point the arrow starts from.

• pt2: Point.

  The point the arrow points to.

• color: Scalar.

  Line color.

Keyword Arguments

• thickness: int.

  Line thickness.

• line_type: int.

  Type of the line. See #LineTypes

• shift: int.

  Number of fractional bits in the point coordinates.

• tipLength: double.

  The length of the arrow tip in relation to the arrow length

Return

• img: Evision.Mat.t().

  Image.

The function cv::arrowedLine draws an arrow between pt1 and pt2 points in the image. See also #line.

Python prototype (for reference only):

arrowedLine(img, pt1, pt2, color[, thickness[, line_type[, shift[, tipLength]]]]) -> img

@spec arrowedLine(
  Evision.Mat.maybe_mat_in(),
  {number(), number()},
  {number(), number()},
  {number()}
  | {number(), number()}
  | {number(), number(), number()}
  | {number(), number(), number(), number()},
  [{atom(), term()}, ...] | nil
) :: Evision.Mat.t() | {:error, String.t()}

Draws an arrow segment pointing from the first point to the second one.

Positional Arguments

• pt1: Point.

  The point the arrow starts from.

• pt2: Point.

  The point the arrow points to.

• color: Scalar.

  Line color.

Keyword Arguments

• thickness: int.

  Line thickness.

• line_type: int.

  Type of the line. See #LineTypes

• shift: int.

  Number of fractional bits in the point coordinates.

• tipLength: double.

  The length of the arrow tip in relation to the arrow length

Return

• img: Evision.Mat.t().

  Image.

The function cv::arrowedLine draws an arrow between pt1 and pt2 points in the image. See also #line.

Python prototype (for reference only):

arrowedLine(img, pt1, pt2, color[, thickness[, line_type[, shift[, tipLength]]]]) -> img

@spec batchDistance(Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), integer()) ::
  {Evision.Mat.t(), Evision.Mat.t()} | {:error, String.t()}

naive nearest neighbor finder

Positional Arguments

• src1: Evision.Mat.t()
• src2: Evision.Mat.t()
• dtype: int

Keyword Arguments

• normType: int.
• k: int.
• mask: Evision.Mat.t().
• update: int.
• crosscheck: bool.

Return

• dist: Evision.Mat.t().
• nidx: Evision.Mat.t().

see http://en.wikipedia.org/wiki/Nearest_neighbor_search @todo document

Python prototype (for reference only):

batchDistance(src1, src2, dtype[, dist[, nidx[, normType[, K[, mask[, update[, crosscheck]]]]]]]) -> dist, nidx

@spec batchDistance(
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  integer(),
  [{atom(), term()}, ...] | nil
) :: {Evision.Mat.t(), Evision.Mat.t()} | {:error, String.t()}

naive nearest neighbor finder

Positional Arguments

• src1: Evision.Mat.t()
• src2: Evision.Mat.t()
• dtype: int

Keyword Arguments

• normType: int.
• k: int.
• mask: Evision.Mat.t().
• update: int.
• crosscheck: bool.

Return

• dist: Evision.Mat.t().
• nidx: Evision.Mat.t().

see http://en.wikipedia.org/wiki/Nearest_neighbor_search @todo document

Python prototype (for reference only):

batchDistance(src1, src2, dtype[, dist[, nidx[, normType[, K[, mask[, update[, crosscheck]]]]]]]) -> dist, nidx

@spec bilateralFilter(Evision.Mat.maybe_mat_in(), integer(), number(), number()) ::
  Evision.Mat.t() | {:error, String.t()}

Applies the bilateral filter to an image.

Positional Arguments

• src: Evision.Mat.t().

  Source 8-bit or floating-point, 1-channel or 3-channel image.

• d: int.

  Diameter of each pixel neighborhood that is used during filtering. If it is non-positive, it is computed from sigmaSpace.

• sigmaColor: double.

  Filter sigma in the color space. A larger value of the parameter means that farther colors within the pixel neighborhood (see sigmaSpace) will be mixed together, resulting in larger areas of semi-equal color.

• sigmaSpace: double.

  Filter sigma in the coordinate space. A larger value of the parameter means that farther pixels will influence each other as long as their colors are close enough (see sigmaColor ). When d>0, it specifies the neighborhood size regardless of sigmaSpace. Otherwise, d is proportional to sigmaSpace.

Keyword Arguments

• borderType: int.

  border mode used to extrapolate pixels outside of the image, see #BorderTypes

Return

• dst: Evision.Mat.t().

  Destination image of the same size and type as src .

The function applies bilateral filtering to the input image, as described in http://www.dai.ed.ac.uk/CVonline/LOCAL_COPIES/MANDUCHI1/Bilateral_Filtering.html bilateralFilter can reduce unwanted noise very well while keeping edges fairly sharp. However, it is very slow compared to most filters. Sigma values: For simplicity, you can set the 2 sigma values to be the same. If they are small (\< 10), the filter will not have much effect, whereas if they are large (> 150), they will have a very strong effect, making the image look "cartoonish". Filter size: Large filters (d > 5) are very slow, so it is recommended to use d=5 for real-time applications, and perhaps d=9 for offline applications that need heavy noise filtering. This filter does not work inplace.

Python prototype (for reference only):

bilateralFilter(src, d, sigmaColor, sigmaSpace[, dst[, borderType]]) -> dst

@spec bilateralFilter(
  Evision.Mat.maybe_mat_in(),
  integer(),
  number(),
  number(),
  [{atom(), term()}, ...] | nil
) :: Evision.Mat.t() | {:error, String.t()}

Applies the bilateral filter to an image.

Positional Arguments

• src: Evision.Mat.t().

  Source 8-bit or floating-point, 1-channel or 3-channel image.

• d: int.

  Diameter of each pixel neighborhood that is used during filtering. If it is non-positive, it is computed from sigmaSpace.

• sigmaColor: double.

  Filter sigma in the color space. A larger value of the parameter means that farther colors within the pixel neighborhood (see sigmaSpace) will be mixed together, resulting in larger areas of semi-equal color.

• sigmaSpace: double.

  Filter sigma in the coordinate space. A larger value of the parameter means that farther pixels will influence each other as long as their colors are close enough (see sigmaColor ). When d>0, it specifies the neighborhood size regardless of sigmaSpace. Otherwise, d is proportional to sigmaSpace.

Keyword Arguments

• borderType: int.

  border mode used to extrapolate pixels outside of the image, see #BorderTypes

Return

• dst: Evision.Mat.t().

  Destination image of the same size and type as src .

The function applies bilateral filtering to the input image, as described in http://www.dai.ed.ac.uk/CVonline/LOCAL_COPIES/MANDUCHI1/Bilateral_Filtering.html bilateralFilter can reduce unwanted noise very well while keeping edges fairly sharp. However, it is very slow compared to most filters. Sigma values: For simplicity, you can set the 2 sigma values to be the same. If they are small (\< 10), the filter will not have much effect, whereas if they are large (> 150), they will have a very strong effect, making the image look "cartoonish". Filter size: Large filters (d > 5) are very slow, so it is recommended to use d=5 for real-time applications, and perhaps d=9 for offline applications that need heavy noise filtering. This filter does not work inplace.

Python prototype (for reference only):

bilateralFilter(src, d, sigmaColor, sigmaSpace[, dst[, borderType]]) -> dst

@spec blendLinear(
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in()
) :: Evision.Mat.t() | {:error, String.t()}

blendLinear

Positional Arguments

• src1: Evision.Mat.t()
• src2: Evision.Mat.t()
• weights1: Evision.Mat.t()
• weights2: Evision.Mat.t()

Return

• dst: Evision.Mat.t().

Has overloading in C++

variant without mask parameter

Python prototype (for reference only):

blendLinear(src1, src2, weights1, weights2[, dst]) -> dst

@spec blendLinear(
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  [{atom(), term()}, ...] | nil
) :: Evision.Mat.t() | {:error, String.t()}

blendLinear

Positional Arguments

• src1: Evision.Mat.t()
• src2: Evision.Mat.t()
• weights1: Evision.Mat.t()
• weights2: Evision.Mat.t()

Return

• dst: Evision.Mat.t().

Has overloading in C++

variant without mask parameter

Python prototype (for reference only):

blendLinear(src1, src2, weights1, weights2[, dst]) -> dst

@spec blur(
  Evision.Mat.maybe_mat_in(),
  {number(), number()}
) :: Evision.Mat.t() | {:error, String.t()}

Blurs an image using the normalized box filter.

Positional Arguments

• src: Evision.Mat.t().

  input image; it can have any number of channels, which are processed independently, but the depth should be CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.

• ksize: Size.

  blurring kernel size.

Keyword Arguments

• anchor: Point.

  anchor point; default value Point(-1,-1) means that the anchor is at the kernel center.

• borderType: int.

  border mode used to extrapolate pixels outside of the image, see #BorderTypes. #BORDER_WRAP is not supported.

Return

• dst: Evision.Mat.t().

  output image of the same size and type as src.

The function smooths an image using the kernel: \f[\texttt{K} = \frac{1}{\texttt{ksize.width*ksize.height}} \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \end{bmatrix}\f] The call blur(src, dst, ksize, anchor, borderType) is equivalent to boxFilter(src, dst, src.type(), ksize, anchor, true, borderType). @sa boxFilter, bilateralFilter, GaussianBlur, medianBlur

Python prototype (for reference only):

blur(src, ksize[, dst[, anchor[, borderType]]]) -> dst

@spec blur(
  Evision.Mat.maybe_mat_in(),
  {number(), number()},
  [{atom(), term()}, ...] | nil
) ::
  Evision.Mat.t() | {:error, String.t()}

Blurs an image using the normalized box filter.

Positional Arguments

• src: Evision.Mat.t().

  input image; it can have any number of channels, which are processed independently, but the depth should be CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.

• ksize: Size.

  blurring kernel size.

Keyword Arguments

• anchor: Point.

  anchor point; default value Point(-1,-1) means that the anchor is at the kernel center.

• borderType: int.

  border mode used to extrapolate pixels outside of the image, see #BorderTypes. #BORDER_WRAP is not supported.

Return

• dst: Evision.Mat.t().

  output image of the same size and type as src.

The function smooths an image using the kernel: \f[\texttt{K} = \frac{1}{\texttt{ksize.width*ksize.height}} \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \end{bmatrix}\f] The call blur(src, dst, ksize, anchor, borderType) is equivalent to boxFilter(src, dst, src.type(), ksize, anchor, true, borderType). @sa boxFilter, bilateralFilter, GaussianBlur, medianBlur

Python prototype (for reference only):

blur(src, ksize[, dst[, anchor[, borderType]]]) -> dst

@spec borderInterpolate(integer(), integer(), integer()) ::
  integer() | {:error, String.t()}

Computes the source location of an extrapolated pixel.

Positional Arguments

• p: int.

  0-based coordinate of the extrapolated pixel along one of the axes, likely \<0 or >= len

• len: int.

  Length of the array along the corresponding axis.

• borderType: int.

  Border type, one of the #BorderTypes, except for #BORDER_TRANSPARENT and #BORDER_ISOLATED . When borderType==#BORDER_CONSTANT , the function always returns -1, regardless of p and len.

Return

• retval: int

The function computes and returns the coordinate of a donor pixel corresponding to the specified extrapolated pixel when using the specified extrapolation border mode. For example, if you use cv::BORDER_WRAP mode in the horizontal direction, cv::BORDER_REFLECT_101 in the vertical direction and want to compute value of the "virtual" pixel Point(-5, 100) in a floating-point image img , it looks like:

float val = img.at<float>(borderInterpolate(100, img.rows, cv::BORDER_REFLECT_101),
borderInterpolate(-5, img.cols, cv::BORDER_WRAP));

Normally, the function is not called directly. It is used inside filtering functions and also in copyMakeBorder.

@sa copyMakeBorder

Python prototype (for reference only):

borderInterpolate(p, len, borderType) -> retval

@spec boundingRect(Evision.Mat.maybe_mat_in()) ::
  {number(), number(), number(), number()} | {:error, String.t()}

Calculates the up-right bounding rectangle of a point set or non-zero pixels of gray-scale image.

Positional Arguments

• array: Evision.Mat.t().

  Input gray-scale image or 2D point set, stored in std::vector or Mat.

Return

• retval: Rect

The function calculates and returns the minimal up-right bounding rectangle for the specified point set or non-zero pixels of gray-scale image.

Python prototype (for reference only):

boundingRect(array) -> retval

@spec boxFilter(Evision.Mat.maybe_mat_in(), integer(), {number(), number()}) ::
  Evision.Mat.t() | {:error, String.t()}

Blurs an image using the box filter.

Positional Arguments

• src: Evision.Mat.t().

  input image.

• ddepth: int.

  the output image depth (-1 to use src.depth()).

• ksize: Size.

  blurring kernel size.

Keyword Arguments

• anchor: Point.

  anchor point; default value Point(-1,-1) means that the anchor is at the kernel center.

• normalize: bool.

  flag, specifying whether the kernel is normalized by its area or not.

• borderType: int.

  border mode used to extrapolate pixels outside of the image, see #BorderTypes. #BORDER_WRAP is not supported.

Return

• dst: Evision.Mat.t().

  output image of the same size and type as src.

The function smooths an image using the kernel: \f[\texttt{K} = \alpha \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \end{bmatrix}\f] where \f[\alpha = \begin{cases} \frac{1}{\texttt{ksize.width*ksize.height}} & \texttt{when } \texttt{normalize=true} \\1 & \texttt{otherwise}\end{cases}\f] Unnormalized box filter is useful for computing various integral characteristics over each pixel neighborhood, such as covariance matrices of image derivatives (used in dense optical flow algorithms, and so on). If you need to compute pixel sums over variable-size windows, use #integral. @sa blur, bilateralFilter, GaussianBlur, medianBlur, integral

Python prototype (for reference only):

boxFilter(src, ddepth, ksize[, dst[, anchor[, normalize[, borderType]]]]) -> dst

@spec boxFilter(
  Evision.Mat.maybe_mat_in(),
  integer(),
  {number(), number()},
  [{atom(), term()}, ...] | nil
) :: Evision.Mat.t() | {:error, String.t()}

Blurs an image using the box filter.

Positional Arguments

• src: Evision.Mat.t().

  input image.

• ddepth: int.

  the output image depth (-1 to use src.depth()).

• ksize: Size.

  blurring kernel size.

Keyword Arguments

• anchor: Point.

  anchor point; default value Point(-1,-1) means that the anchor is at the kernel center.

• normalize: bool.

  flag, specifying whether the kernel is normalized by its area or not.

• borderType: int.

  border mode used to extrapolate pixels outside of the image, see #BorderTypes. #BORDER_WRAP is not supported.

Return

• dst: Evision.Mat.t().

  output image of the same size and type as src.

The function smooths an image using the kernel: \f[\texttt{K} = \alpha \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \end{bmatrix}\f] where \f[\alpha = \begin{cases} \frac{1}{\texttt{ksize.width*ksize.height}} & \texttt{when } \texttt{normalize=true} \\1 & \texttt{otherwise}\end{cases}\f] Unnormalized box filter is useful for computing various integral characteristics over each pixel neighborhood, such as covariance matrices of image derivatives (used in dense optical flow algorithms, and so on). If you need to compute pixel sums over variable-size windows, use #integral. @sa blur, bilateralFilter, GaussianBlur, medianBlur, integral

Python prototype (for reference only):

boxFilter(src, ddepth, ksize[, dst[, anchor[, normalize[, borderType]]]]) -> dst

@spec boxPoints({{number(), number()}, {number(), number()}, number()}) ::
  Evision.Mat.t() | {:error, String.t()}

Finds the four vertices of a rotated rect. Useful to draw the rotated rectangle.

Positional Arguments

• box: {centre={x, y}, size={s1, s2}, angle}.

  The input rotated rectangle. It may be the output of

Return

• points: Evision.Mat.t().

  The output array of four vertices of rectangles.

The function finds the four vertices of a rotated rectangle. This function is useful to draw the rectangle. In C++, instead of using this function, you can directly use RotatedRect::points method. Please visit the @ref tutorial_bounding_rotated_ellipses "tutorial on Creating Bounding rotated boxes and ellipses for contours" for more information.

Python prototype (for reference only):

boxPoints(box[, points]) -> points

@spec boxPoints(
  {{number(), number()}, {number(), number()}, number()},
  [{atom(), term()}, ...] | nil
) ::
  Evision.Mat.t() | {:error, String.t()}

Finds the four vertices of a rotated rect. Useful to draw the rotated rectangle.

Positional Arguments

• box: {centre={x, y}, size={s1, s2}, angle}.

  The input rotated rectangle. It may be the output of

Return

• points: Evision.Mat.t().

  The output array of four vertices of rectangles.

The function finds the four vertices of a rotated rectangle. This function is useful to draw the rectangle. In C++, instead of using this function, you can directly use RotatedRect::points method. Please visit the @ref tutorial_bounding_rotated_ellipses "tutorial on Creating Bounding rotated boxes and ellipses for contours" for more information.

Python prototype (for reference only):

boxPoints(box[, points]) -> points

@spec buildOpticalFlowPyramid(
  Evision.Mat.maybe_mat_in(),
  {number(), number()},
  integer()
) ::
  {integer(), [Evision.Mat.t()]} | {:error, String.t()}

Constructs the image pyramid which can be passed to calcOpticalFlowPyrLK.

Positional Arguments

• img: Evision.Mat.t().

  8-bit input image.

• winSize: Size.

  window size of optical flow algorithm. Must be not less than winSize argument of calcOpticalFlowPyrLK. It is needed to calculate required padding for pyramid levels.

• maxLevel: int.

  0-based maximal pyramid level number.

Keyword Arguments

• withDerivatives: bool.

  set to precompute gradients for the every pyramid level. If pyramid is constructed without the gradients then calcOpticalFlowPyrLK will calculate them internally.

• pyrBorder: int.

  the border mode for pyramid layers.

• derivBorder: int.

  the border mode for gradients.

• tryReuseInputImage: bool.

  put ROI of input image into the pyramid if possible. You can pass false to force data copying.

Return

• retval: int

• pyramid: [Evision.Mat].

  output pyramid.

@return number of levels in constructed pyramid. Can be less than maxLevel.

Python prototype (for reference only):

buildOpticalFlowPyramid(img, winSize, maxLevel[, pyramid[, withDerivatives[, pyrBorder[, derivBorder[, tryReuseInputImage]]]]]) -> retval, pyramid

@spec buildOpticalFlowPyramid(
  Evision.Mat.maybe_mat_in(),
  {number(), number()},
  integer(),
  [{atom(), term()}, ...] | nil
) :: {integer(), [Evision.Mat.t()]} | {:error, String.t()}

Constructs the image pyramid which can be passed to calcOpticalFlowPyrLK.

Positional Arguments

• img: Evision.Mat.t().

  8-bit input image.

• winSize: Size.

  window size of optical flow algorithm. Must be not less than winSize argument of calcOpticalFlowPyrLK. It is needed to calculate required padding for pyramid levels.

• maxLevel: int.

  0-based maximal pyramid level number.

Keyword Arguments

• withDerivatives: bool.

  set to precompute gradients for the every pyramid level. If pyramid is constructed without the gradients then calcOpticalFlowPyrLK will calculate them internally.

• pyrBorder: int.

  the border mode for pyramid layers.

• derivBorder: int.

  the border mode for gradients.

• tryReuseInputImage: bool.

  put ROI of input image into the pyramid if possible. You can pass false to force data copying.

Return

• retval: int

• pyramid: [Evision.Mat].

  output pyramid.

@return number of levels in constructed pyramid. Can be less than maxLevel.

Python prototype (for reference only):

buildOpticalFlowPyramid(img, winSize, maxLevel[, pyramid[, withDerivatives[, pyrBorder[, derivBorder[, tryReuseInputImage]]]]]) -> retval, pyramid

@spec calcBackProject(
  [Evision.Mat.maybe_mat_in()],
  [integer()],
  Evision.Mat.maybe_mat_in(),
  [number()],
  number()
) :: Evision.Mat.t() | {:error, String.t()}

calcBackProject

Positional Arguments

• images: [Evision.Mat]
• channels: [int]
• hist: Evision.Mat.t()
• ranges: [float]
• scale: double

Return

• dst: Evision.Mat.t().

Has overloading in C++

Python prototype (for reference only):

calcBackProject(images, channels, hist, ranges, scale[, dst]) -> dst

@spec calcBackProject(
  [Evision.Mat.maybe_mat_in()],
  [integer()],
  Evision.Mat.maybe_mat_in(),
  [number()],
  number(),
  [{atom(), term()}, ...] | nil
) :: Evision.Mat.t() | {:error, String.t()}

calcBackProject

Positional Arguments

• images: [Evision.Mat]
• channels: [int]
• hist: Evision.Mat.t()
• ranges: [float]
• scale: double

Return

• dst: Evision.Mat.t().

Has overloading in C++

Python prototype (for reference only):

calcBackProject(images, channels, hist, ranges, scale[, dst]) -> dst

@spec calcCovarMatrix(
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  integer()
) ::
  {Evision.Mat.t(), Evision.Mat.t()} | {:error, String.t()}

calcCovarMatrix

Positional Arguments

• samples: Evision.Mat.t().

  samples stored as rows/columns of a single matrix.

• flags: int.

  operation flags as a combination of #CovarFlags

Keyword Arguments

• ctype: int.

  type of the matrixl; it equals 'CV_64F' by default.

Return

• covar: Evision.Mat.t().

  output covariance matrix of the type ctype and square size.

• mean: Evision.Mat.t().

  input or output (depending on the flags) array as the average value of the input vectors.

Has overloading in C++

Note: use #COVAR_ROWS or #COVAR_COLS flag

Python prototype (for reference only):

calcCovarMatrix(samples, mean, flags[, covar[, ctype]]) -> covar, mean

@spec calcCovarMatrix(
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  integer(),
  [{atom(), term()}, ...] | nil
) :: {Evision.Mat.t(), Evision.Mat.t()} | {:error, String.t()}

calcCovarMatrix

Positional Arguments

• samples: Evision.Mat.t().

  samples stored as rows/columns of a single matrix.

• flags: int.

  operation flags as a combination of #CovarFlags

Keyword Arguments

• ctype: int.

  type of the matrixl; it equals 'CV_64F' by default.

Return

• covar: Evision.Mat.t().

  output covariance matrix of the type ctype and square size.

• mean: Evision.Mat.t().

  input or output (depending on the flags) array as the average value of the input vectors.

Has overloading in C++

Note: use #COVAR_ROWS or #COVAR_COLS flag

Python prototype (for reference only):

calcCovarMatrix(samples, mean, flags[, covar[, ctype]]) -> covar, mean

@spec calcHist(
  [Evision.Mat.maybe_mat_in()],
  [integer()],
  Evision.Mat.maybe_mat_in(),
  [integer()],
  [
    number()
  ]
) :: Evision.Mat.t() | {:error, String.t()}

calcHist

Positional Arguments

• images: [Evision.Mat]
• channels: [int]
• mask: Evision.Mat.t()
• histSize: [int]
• ranges: [float]

Keyword Arguments

• accumulate: bool.

Return

• hist: Evision.Mat.t().

Has overloading in C++

this variant supports only uniform histograms. ranges argument is either empty vector or a flattened vector of histSize.size()*2 elements (histSize.size() element pairs). The first and second elements of each pair specify the lower and upper boundaries.

Python prototype (for reference only):

calcHist(images, channels, mask, histSize, ranges[, hist[, accumulate]]) -> hist

@spec calcHist(
  [Evision.Mat.maybe_mat_in()],
  [integer()],
  Evision.Mat.maybe_mat_in(),
  [integer()],
  [number()],
  [{atom(), term()}, ...] | nil
) :: Evision.Mat.t() | {:error, String.t()}

calcHist

Positional Arguments

• images: [Evision.Mat]
• channels: [int]
• mask: Evision.Mat.t()
• histSize: [int]
• ranges: [float]

Keyword Arguments

• accumulate: bool.

Return

• hist: Evision.Mat.t().

Has overloading in C++

this variant supports only uniform histograms. ranges argument is either empty vector or a flattened vector of histSize.size()*2 elements (histSize.size() element pairs). The first and second elements of each pair specify the lower and upper boundaries.

Python prototype (for reference only):

calcHist(images, channels, mask, histSize, ranges[, hist[, accumulate]]) -> hist

@spec calcOpticalFlowFarneback(
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  number(),
  integer(),
  integer(),
  integer(),
  integer(),
  number(),
  integer()
) :: Evision.Mat.t() | {:error, String.t()}

Computes a dense optical flow using the Gunnar Farneback's algorithm.

Positional Arguments

• prev: Evision.Mat.t().

  first 8-bit single-channel input image.

• next: Evision.Mat.t().

  second input image of the same size and the same type as prev.

• pyr_scale: double.

  parameter, specifying the image scale (\<1) to build pyramids for each image; pyr_scale=0.5 means a classical pyramid, where each next layer is twice smaller than the previous one.

• levels: int.

  number of pyramid layers including the initial image; levels=1 means that no extra layers are created and only the original images are used.

• winsize: int.

  averaging window size; larger values increase the algorithm robustness to image noise and give more chances for fast motion detection, but yield more blurred motion field.

• iterations: int.

  number of iterations the algorithm does at each pyramid level.

• poly_n: int.

  size of the pixel neighborhood used to find polynomial expansion in each pixel; larger values mean that the image will be approximated with smoother surfaces, yielding more robust algorithm and more blurred motion field, typically poly_n =5 or 7.

• poly_sigma: double.

  standard deviation of the Gaussian that is used to smooth derivatives used as a basis for the polynomial expansion; for poly_n=5, you can set poly_sigma=1.1, for poly_n=7, a good value would be poly_sigma=1.5.

• flags: int.

  operation flags that can be a combination of the following:

  • OPTFLOW_USE_INITIAL_FLOW uses the input flow as an initial flow approximation.
  • OPTFLOW_FARNEBACK_GAUSSIAN uses the Gaussian \f$\texttt{winsize}\times\texttt{winsize}\f$ filter instead of a box filter of the same size for optical flow estimation; usually, this option gives z more accurate flow than with a box filter, at the cost of lower speed; normally, winsize for a Gaussian window should be set to a larger value to achieve the same level of robustness.

Return

• flow: Evision.Mat.t().

  computed flow image that has the same size as prev and type CV_32FC2.

The function finds an optical flow for each prev pixel using the @cite Farneback2003 algorithm so that \f[\texttt{prev} (y,x) \sim \texttt{next} ( y + \texttt{flow} (y,x)[1], x + \texttt{flow} (y,x)[0])\f] Note:

• An example using the optical flow algorithm described by Gunnar Farneback can be found at opencv_source_code/samples/cpp/fback.cpp

• (Python) An example using the optical flow algorithm described by Gunnar Farneback can be found at opencv_source_code/samples/python/opt_flow.py

Python prototype (for reference only):

calcOpticalFlowFarneback(prev, next, flow, pyr_scale, levels, winsize, iterations, poly_n, poly_sigma, flags) -> flow

@spec calcOpticalFlowPyrLK(
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in()
) :: {Evision.Mat.t(), Evision.Mat.t(), Evision.Mat.t()} | {:error, String.t()}

Calculates an optical flow for a sparse feature set using the iterative Lucas-Kanade method with pyramids.

Positional Arguments

• prevImg: Evision.Mat.t().

  first 8-bit input image or pyramid constructed by buildOpticalFlowPyramid.

• nextImg: Evision.Mat.t().

  second input image or pyramid of the same size and the same type as prevImg.

• prevPts: Evision.Mat.t().

  vector of 2D points for which the flow needs to be found; point coordinates must be single-precision floating-point numbers.

Keyword Arguments

• winSize: Size.

  size of the search window at each pyramid level.

• maxLevel: int.

  0-based maximal pyramid level number; if set to 0, pyramids are not used (single level), if set to 1, two levels are used, and so on; if pyramids are passed to input then algorithm will use as many levels as pyramids have but no more than maxLevel.

• criteria: TermCriteria.

  parameter, specifying the termination criteria of the iterative search algorithm (after the specified maximum number of iterations criteria.maxCount or when the search window moves by less than criteria.epsilon.

• flags: int.

  operation flags:

  • OPTFLOW_USE_INITIAL_FLOW uses initial estimations, stored in nextPts; if the flag is not set, then prevPts is copied to nextPts and is considered the initial estimate.
  • OPTFLOW_LK_GET_MIN_EIGENVALS use minimum eigen values as an error measure (see minEigThreshold description); if the flag is not set, then L1 distance between patches around the original and a moved point, divided by number of pixels in a window, is used as a error measure.

• minEigThreshold: double.

  the algorithm calculates the minimum eigen value of a 2x2 normal matrix of optical flow equations (this matrix is called a spatial gradient matrix in @cite Bouguet00), divided by number of pixels in a window; if this value is less than minEigThreshold, then a corresponding feature is filtered out and its flow is not processed, so it allows to remove bad points and get a performance boost.

Return

• nextPts: Evision.Mat.t().

  output vector of 2D points (with single-precision floating-point coordinates) containing the calculated new positions of input features in the second image; when OPTFLOW_USE_INITIAL_FLOW flag is passed, the vector must have the same size as in the input.

• status: Evision.Mat.t().

  output status vector (of unsigned chars); each element of the vector is set to 1 if the flow for the corresponding features has been found, otherwise, it is set to 0.

• err: Evision.Mat.t().

  output vector of errors; each element of the vector is set to an error for the corresponding feature, type of the error measure can be set in flags parameter; if the flow wasn't found then the error is not defined (use the status parameter to find such cases).

The function implements a sparse iterative version of the Lucas-Kanade optical flow in pyramids. See @cite Bouguet00 . The function is parallelized with the TBB library. Note:

• An example using the Lucas-Kanade optical flow algorithm can be found at opencv_source_code/samples/cpp/lkdemo.cpp

• (Python) An example using the Lucas-Kanade optical flow algorithm can be found at opencv_source_code/samples/python/lk_track.py

• (Python) An example using the Lucas-Kanade tracker for homography matching can be found at opencv_source_code/samples/python/lk_homography.py

Python prototype (for reference only):

calcOpticalFlowPyrLK(prevImg, nextImg, prevPts, nextPts[, status[, err[, winSize[, maxLevel[, criteria[, flags[, minEigThreshold]]]]]]]) -> nextPts, status, err

@spec calcOpticalFlowPyrLK(
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  [{atom(), term()}, ...] | nil
) :: {Evision.Mat.t(), Evision.Mat.t(), Evision.Mat.t()} | {:error, String.t()}

Calculates an optical flow for a sparse feature set using the iterative Lucas-Kanade method with pyramids.

Positional Arguments

• prevImg: Evision.Mat.t().

  first 8-bit input image or pyramid constructed by buildOpticalFlowPyramid.

• nextImg: Evision.Mat.t().

  second input image or pyramid of the same size and the same type as prevImg.

• prevPts: Evision.Mat.t().

  vector of 2D points for which the flow needs to be found; point coordinates must be single-precision floating-point numbers.

Keyword Arguments

• winSize: Size.

  size of the search window at each pyramid level.

• maxLevel: int.

  0-based maximal pyramid level number; if set to 0, pyramids are not used (single level), if set to 1, two levels are used, and so on; if pyramids are passed to input then algorithm will use as many levels as pyramids have but no more than maxLevel.

• criteria: TermCriteria.

  parameter, specifying the termination criteria of the iterative search algorithm (after the specified maximum number of iterations criteria.maxCount or when the search window moves by less than criteria.epsilon.

• flags: int.

  operation flags:

  • OPTFLOW_USE_INITIAL_FLOW uses initial estimations, stored in nextPts; if the flag is not set, then prevPts is copied to nextPts and is considered the initial estimate.
  • OPTFLOW_LK_GET_MIN_EIGENVALS use minimum eigen values as an error measure (see minEigThreshold description); if the flag is not set, then L1 distance between patches around the original and a moved point, divided by number of pixels in a window, is used as a error measure.

• minEigThreshold: double.

  the algorithm calculates the minimum eigen value of a 2x2 normal matrix of optical flow equations (this matrix is called a spatial gradient matrix in @cite Bouguet00), divided by number of pixels in a window; if this value is less than minEigThreshold, then a corresponding feature is filtered out and its flow is not processed, so it allows to remove bad points and get a performance boost.

Return

• nextPts: Evision.Mat.t().

  output vector of 2D points (with single-precision floating-point coordinates) containing the calculated new positions of input features in the second image; when OPTFLOW_USE_INITIAL_FLOW flag is passed, the vector must have the same size as in the input.

• status: Evision.Mat.t().

  output status vector (of unsigned chars); each element of the vector is set to 1 if the flow for the corresponding features has been found, otherwise, it is set to 0.

• err: Evision.Mat.t().

  output vector of errors; each element of the vector is set to an error for the corresponding feature, type of the error measure can be set in flags parameter; if the flow wasn't found then the error is not defined (use the status parameter to find such cases).

The function implements a sparse iterative version of the Lucas-Kanade optical flow in pyramids. See @cite Bouguet00 . The function is parallelized with the TBB library. Note:

• An example using the Lucas-Kanade optical flow algorithm can be found at opencv_source_code/samples/cpp/lkdemo.cpp

• (Python) An example using the Lucas-Kanade optical flow algorithm can be found at opencv_source_code/samples/python/lk_track.py

• (Python) An example using the Lucas-Kanade tracker for homography matching can be found at opencv_source_code/samples/python/lk_homography.py

Python prototype (for reference only):

calcOpticalFlowPyrLK(prevImg, nextImg, prevPts, nextPts[, status[, err[, winSize[, maxLevel[, criteria[, flags[, minEigThreshold]]]]]]]) -> nextPts, status, err

@spec calibrateCamera(
  [Evision.Mat.maybe_mat_in()],
  [Evision.Mat.maybe_mat_in()],
  {number(), number()},
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in()
) ::
  {number(), Evision.Mat.t(), Evision.Mat.t(), [Evision.Mat.t()],
   [Evision.Mat.t()]}
  | {:error, String.t()}

calibrateCamera

Positional Arguments

• objectPoints: [Evision.Mat]
• imagePoints: [Evision.Mat]
• imageSize: Size

Keyword Arguments

• flags: int.
• criteria: TermCriteria.

Return

• retval: double
• cameraMatrix: Evision.Mat.t()
• distCoeffs: Evision.Mat.t()
• rvecs: [Evision.Mat].
• tvecs: [Evision.Mat].

Has overloading in C++

Python prototype (for reference only):

calibrateCamera(objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs[, rvecs[, tvecs[, flags[, criteria]]]]) -> retval, cameraMatrix, distCoeffs, rvecs, tvecs

@spec calibrateCamera(
  [Evision.Mat.maybe_mat_in()],
  [Evision.Mat.maybe_mat_in()],
  {number(), number()},
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  [{atom(), term()}, ...] | nil
) ::
  {number(), Evision.Mat.t(), Evision.Mat.t(), [Evision.Mat.t()],
   [Evision.Mat.t()]}
  | {:error, String.t()}

calibrateCamera

Positional Arguments

• objectPoints: [Evision.Mat]
• imagePoints: [Evision.Mat]
• imageSize: Size

Keyword Arguments

• flags: int.
• criteria: TermCriteria.

Return

• retval: double
• cameraMatrix: Evision.Mat.t()
• distCoeffs: Evision.Mat.t()
• rvecs: [Evision.Mat].
• tvecs: [Evision.Mat].

Has overloading in C++

Python prototype (for reference only):

calibrateCamera(objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs[, rvecs[, tvecs[, flags[, criteria]]]]) -> retval, cameraMatrix, distCoeffs, rvecs, tvecs

@spec calibrateCameraExtended(
  [Evision.Mat.maybe_mat_in()],
  [Evision.Mat.maybe_mat_in()],
  {number(), number()},
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in()
) ::
  {number(), Evision.Mat.t(), Evision.Mat.t(), [Evision.Mat.t()],
   [Evision.Mat.t()], Evision.Mat.t(), Evision.Mat.t(), Evision.Mat.t()}
  | {:error, String.t()}

Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern.

Positional Arguments

• objectPoints: [Evision.Mat].

  In the new interface it is a vector of vectors of calibration pattern points in the calibration pattern coordinate space (e.g. std::vector<std::vector<cv::Vec3f>>). The outer vector contains as many elements as the number of pattern views. If the same calibration pattern is shown in each view and it is fully visible, all the vectors will be the same. Although, it is possible to use partially occluded patterns or even different patterns in different views. Then, the vectors will be different. Although the points are 3D, they all lie in the calibration pattern's XY coordinate plane (thus 0 in the Z-coordinate), if the used calibration pattern is a planar rig. In the old interface all the vectors of object points from different views are concatenated together.

• imagePoints: [Evision.Mat].

  In the new interface it is a vector of vectors of the projections of calibration pattern points (e.g. std::vector<std::vector<cv::Vec2f>>). imagePoints.size() and objectPoints.size(), and imagePoints[i].size() and objectPoints[i].size() for each i, must be equal, respectively. In the old interface all the vectors of object points from different views are concatenated together.

• imageSize: Size.

  Size of the image used only to initialize the camera intrinsic matrix.

Keyword Arguments

• flags: int.

  Different flags that may be zero or a combination of the following values:

  • @ref CALIB_USE_INTRINSIC_GUESS cameraMatrix contains valid initial values of fx, fy, cx, cy that are optimized further. Otherwise, (cx, cy) is initially set to the image center ( imageSize is used), and focal distances are computed in a least-squares fashion. Note, that if intrinsic parameters are known, there is no need to use this function just to estimate extrinsic parameters. Use @ref solvePnP instead.
  • @ref CALIB_FIX_PRINCIPAL_POINT The principal point is not changed during the global optimization. It stays at the center or at a different location specified when

• criteria: TermCriteria.

  Termination criteria for the iterative optimization algorithm.

Return

• retval: double

• cameraMatrix: Evision.Mat.t().

  Input/output 3x3 floating-point camera intrinsic matrix \f$\cameramatrix{A}\f$ . If @ref CALIB_USE_INTRINSIC_GUESS and/or @ref CALIB_FIX_ASPECT_RATIO, @ref CALIB_FIX_PRINCIPAL_POINT or @ref CALIB_FIX_FOCAL_LENGTH are specified, some or all of fx, fy, cx, cy must be initialized before calling the function.

• distCoeffs: Evision.Mat.t().

  Input/output vector of distortion coefficients \f$\distcoeffs\f$.

• rvecs: [Evision.Mat].

  Output vector of rotation vectors (@ref Rodrigues ) estimated for each pattern view (e.g. std::vector<cv::Mat>>). That is, each i-th rotation vector together with the corresponding i-th translation vector (see the next output parameter description) brings the calibration pattern from the object coordinate space (in which object points are specified) to the camera coordinate space. In more technical terms, the tuple of the i-th rotation and translation vector performs a change of basis from object coordinate space to camera coordinate space. Due to its duality, this tuple is equivalent to the position of the calibration pattern with respect to the camera coordinate space.

• tvecs: [Evision.Mat].

  Output vector of translation vectors estimated for each pattern view, see parameter describtion above.

• stdDeviationsIntrinsics: Evision.Mat.t().

  Output vector of standard deviations estimated for intrinsic parameters. Order of deviations values: \f$(f_x, f_y, c_x, c_y, k_1, k_2, p_1, p_2, k_3, k_4, k_5, k_6 , s_1, s_2, s_3, s_4, \tau_x, \tau_y)\f$ If one of parameters is not estimated, it's deviation is equals to zero.

• stdDeviationsExtrinsics: Evision.Mat.t().

  Output vector of standard deviations estimated for extrinsic parameters. Order of deviations values: \f$(R0, T_0, \dotsc , R{M - 1}, T_{M - 1})\f$ where M is the number of pattern views. \f$R_i, T_i\f$ are concatenated 1x3 vectors.

• perViewErrors: Evision.Mat.t().

  Output vector of the RMS re-projection error estimated for each pattern view.

@ref CALIB_USE_INTRINSIC_GUESS is set too.

• @ref CALIB_FIX_ASPECT_RATIO The functions consider only fy as a free parameter. The ratio fx/fy stays the same as in the input cameraMatrix . When

@ref CALIB_USE_INTRINSIC_GUESS is not set, the actual input values of fx and fy are ignored, only their ratio is computed and used further.

• @ref CALIB_ZERO_TANGENT_DIST Tangential distortion coefficients \f$(p_1, p_2)\f$ are set to zeros and stay zero.

• @ref CALIB_FIX_FOCAL_LENGTH The focal length is not changed during the global optimization if @ref CALIB_USE_INTRINSIC_GUESS is set.

• @ref CALIB_FIX_K1,..., @ref CALIB_FIX_K6 The corresponding radial distortion coefficient is not changed during the optimization. If @ref CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the supplied distCoeffs matrix is used. Otherwise, it is set to 0.

• @ref CALIB_RATIONAL_MODEL Coefficients k4, k5, and k6 are enabled. To provide the backward compatibility, this extra flag should be explicitly specified to make the calibration function use the rational model and return 8 coefficients or more.

• @ref CALIB_THIN_PRISM_MODEL Coefficients s1, s2, s3 and s4 are enabled. To provide the backward compatibility, this extra flag should be explicitly specified to make the calibration function use the thin prism model and return 12 coefficients or more.

• @ref CALIB_FIX_S1_S2_S3_S4 The thin prism distortion coefficients are not changed during the optimization. If @ref CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the supplied distCoeffs matrix is used. Otherwise, it is set to 0.

• @ref CALIB_TILTED_MODEL Coefficients tauX and tauY are enabled. To provide the backward compatibility, this extra flag should be explicitly specified to make the calibration function use the tilted sensor model and return 14 coefficients.

• @ref CALIB_FIX_TAUX_TAUY The coefficients of the tilted sensor model are not changed during the optimization. If @ref CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the supplied distCoeffs matrix is used. Otherwise, it is set to 0.

@return the overall RMS re-projection error. The function estimates the intrinsic camera parameters and extrinsic parameters for each of the views. The algorithm is based on @cite Zhang2000 and @cite BouguetMCT . The coordinates of 3D object points and their corresponding 2D projections in each view must be specified. That may be achieved by using an object with known geometry and easily detectable feature points. Such an object is called a calibration rig or calibration pattern, and OpenCV has built-in support for a chessboard as a calibration rig (see @ref findChessboardCorners). Currently, initialization of intrinsic parameters (when @ref CALIB_USE_INTRINSIC_GUESS is not set) is only implemented for planar calibration patterns (where Z-coordinates of the object points must be all zeros). 3D calibration rigs can also be used as long as initial cameraMatrix is provided. The algorithm performs the following steps:

• Compute the initial intrinsic parameters (the option only available for planar calibration patterns) or read them from the input parameters. The distortion coefficients are all set to zeros initially unless some of CALIB_FIX_K? are specified.

• Estimate the initial camera pose as if the intrinsic parameters have been already known. This is done using @ref solvePnP .

• Run the global Levenberg-Marquardt optimization algorithm to minimize the reprojection error, that is, the total sum of squared distances between the observed feature points imagePoints and the projected (using the current estimates for camera parameters and the poses) object points objectPoints. See @ref projectPoints for details.

Note: If you use a non-square (i.e. non-N-by-N) grid and @ref findChessboardCorners for calibration, and @ref calibrateCamera returns bad values (zero distortion coefficients, \f$c_x\f$ and \f$c_y\f$ very far from the image center, and/or large differences between \f$f_x\f$ and \f$f_y\f$ (ratios of 10:1 or more)), then you are probably using patternSize=cvSize(rows,cols) instead of using patternSize=cvSize(cols,rows) in @ref findChessboardCorners. @sa calibrateCameraRO, findChessboardCorners, solvePnP, initCameraMatrix2D, stereoCalibrate, undistort

Python prototype (for reference only):

calibrateCameraExtended(objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs[, rvecs[, tvecs[, stdDeviationsIntrinsics[, stdDeviationsExtrinsics[, perViewErrors[, flags[, criteria]]]]]]]) -> retval, cameraMatrix, distCoeffs, rvecs, tvecs, stdDeviationsIntrinsics, stdDeviationsExtrinsics, perViewErrors

@spec calibrateCameraExtended(
  [Evision.Mat.maybe_mat_in()],
  [Evision.Mat.maybe_mat_in()],
  {number(), number()},
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  [{atom(), term()}, ...] | nil
) ::
  {number(), Evision.Mat.t(), Evision.Mat.t(), [Evision.Mat.t()],
   [Evision.Mat.t()], Evision.Mat.t(), Evision.Mat.t(), Evision.Mat.t()}
  | {:error, String.t()}

Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern.

Positional Arguments

• objectPoints: [Evision.Mat].

  In the new interface it is a vector of vectors of calibration pattern points in the calibration pattern coordinate space (e.g. std::vector<std::vector<cv::Vec3f>>). The outer vector contains as many elements as the number of pattern views. If the same calibration pattern is shown in each view and it is fully visible, all the vectors will be the same. Although, it is possible to use partially occluded patterns or even different patterns in different views. Then, the vectors will be different. Although the points are 3D, they all lie in the calibration pattern's XY coordinate plane (thus 0 in the Z-coordinate), if the used calibration pattern is a planar rig. In the old interface all the vectors of object points from different views are concatenated together.

• imagePoints: [Evision.Mat].

  In the new interface it is a vector of vectors of the projections of calibration pattern points (e.g. std::vector<std::vector<cv::Vec2f>>). imagePoints.size() and objectPoints.size(), and imagePoints[i].size() and objectPoints[i].size() for each i, must be equal, respectively. In the old interface all the vectors of object points from different views are concatenated together.

• imageSize: Size.

  Size of the image used only to initialize the camera intrinsic matrix.

Keyword Arguments

• flags: int.

  Different flags that may be zero or a combination of the following values:

  • @ref CALIB_USE_INTRINSIC_GUESS cameraMatrix contains valid initial values of fx, fy, cx, cy that are optimized further. Otherwise, (cx, cy) is initially set to the image center ( imageSize is used), and focal distances are computed in a least-squares fashion. Note, that if intrinsic parameters are known, there is no need to use this function just to estimate extrinsic parameters. Use @ref solvePnP instead.
  • @ref CALIB_FIX_PRINCIPAL_POINT The principal point is not changed during the global optimization. It stays at the center or at a different location specified when

• criteria: TermCriteria.

  Termination criteria for the iterative optimization algorithm.

Return

• retval: double

• cameraMatrix: Evision.Mat.t().

  Input/output 3x3 floating-point camera intrinsic matrix \f$\cameramatrix{A}\f$ . If @ref CALIB_USE_INTRINSIC_GUESS and/or @ref CALIB_FIX_ASPECT_RATIO, @ref CALIB_FIX_PRINCIPAL_POINT or @ref CALIB_FIX_FOCAL_LENGTH are specified, some or all of fx, fy, cx, cy must be initialized before calling the function.

• distCoeffs: Evision.Mat.t().

  Input/output vector of distortion coefficients \f$\distcoeffs\f$.

• rvecs: [Evision.Mat].

  Output vector of rotation vectors (@ref Rodrigues ) estimated for each pattern view (e.g. std::vector<cv::Mat>>). That is, each i-th rotation vector together with the corresponding i-th translation vector (see the next output parameter description) brings the calibration pattern from the object coordinate space (in which object points are specified) to the camera coordinate space. In more technical terms, the tuple of the i-th rotation and translation vector performs a change of basis from object coordinate space to camera coordinate space. Due to its duality, this tuple is equivalent to the position of the calibration pattern with respect to the camera coordinate space.

• tvecs: [Evision.Mat].

  Output vector of translation vectors estimated for each pattern view, see parameter describtion above.

• stdDeviationsIntrinsics: Evision.Mat.t().

  Output vector of standard deviations estimated for intrinsic parameters. Order of deviations values: \f$(f_x, f_y, c_x, c_y, k_1, k_2, p_1, p_2, k_3, k_4, k_5, k_6 , s_1, s_2, s_3, s_4, \tau_x, \tau_y)\f$ If one of parameters is not estimated, it's deviation is equals to zero.

• stdDeviationsExtrinsics: Evision.Mat.t().

  Output vector of standard deviations estimated for extrinsic parameters. Order of deviations values: \f$(R0, T_0, \dotsc , R{M - 1}, T_{M - 1})\f$ where M is the number of pattern views. \f$R_i, T_i\f$ are concatenated 1x3 vectors.

• perViewErrors: Evision.Mat.t().

  Output vector of the RMS re-projection error estimated for each pattern view.

@ref CALIB_USE_INTRINSIC_GUESS is set too.

• @ref CALIB_FIX_ASPECT_RATIO The functions consider only fy as a free parameter. The ratio fx/fy stays the same as in the input cameraMatrix . When

@ref CALIB_USE_INTRINSIC_GUESS is not set, the actual input values of fx and fy are ignored, only their ratio is computed and used further.

• @ref CALIB_ZERO_TANGENT_DIST Tangential distortion coefficients \f$(p_1, p_2)\f$ are set to zeros and stay zero.

• @ref CALIB_FIX_FOCAL_LENGTH The focal length is not changed during the global optimization if @ref CALIB_USE_INTRINSIC_GUESS is set.

• @ref CALIB_FIX_K1,..., @ref CALIB_FIX_K6 The corresponding radial distortion coefficient is not changed during the optimization. If @ref CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the supplied distCoeffs matrix is used. Otherwise, it is set to 0.

• @ref CALIB_RATIONAL_MODEL Coefficients k4, k5, and k6 are enabled. To provide the backward compatibility, this extra flag should be explicitly specified to make the calibration function use the rational model and return 8 coefficients or more.

• @ref CALIB_THIN_PRISM_MODEL Coefficients s1, s2, s3 and s4 are enabled. To provide the backward compatibility, this extra flag should be explicitly specified to make the calibration function use the thin prism model and return 12 coefficients or more.

• @ref CALIB_FIX_S1_S2_S3_S4 The thin prism distortion coefficients are not changed during the optimization. If @ref CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the supplied distCoeffs matrix is used. Otherwise, it is set to 0.

• @ref CALIB_TILTED_MODEL Coefficients tauX and tauY are enabled. To provide the backward compatibility, this extra flag should be explicitly specified to make the calibration function use the tilted sensor model and return 14 coefficients.

• @ref CALIB_FIX_TAUX_TAUY The coefficients of the tilted sensor model are not changed during the optimization. If @ref CALIB_USE_INTRINSIC_GUESS is set, the coefficient from the supplied distCoeffs matrix is used. Otherwise, it is set to 0.

@return the overall RMS re-projection error. The function estimates the intrinsic camera parameters and extrinsic parameters for each of the views. The algorithm is based on @cite Zhang2000 and @cite BouguetMCT . The coordinates of 3D object points and their corresponding 2D projections in each view must be specified. That may be achieved by using an object with known geometry and easily detectable feature points. Such an object is called a calibration rig or calibration pattern, and OpenCV has built-in support for a chessboard as a calibration rig (see @ref findChessboardCorners). Currently, initialization of intrinsic parameters (when @ref CALIB_USE_INTRINSIC_GUESS is not set) is only implemented for planar calibration patterns (where Z-coordinates of the object points must be all zeros). 3D calibration rigs can also be used as long as initial cameraMatrix is provided. The algorithm performs the following steps:

• Compute the initial intrinsic parameters (the option only available for planar calibration patterns) or read them from the input parameters. The distortion coefficients are all set to zeros initially unless some of CALIB_FIX_K? are specified.

• Estimate the initial camera pose as if the intrinsic parameters have been already known. This is done using @ref solvePnP .

• Run the global Levenberg-Marquardt optimization algorithm to minimize the reprojection error, that is, the total sum of squared distances between the observed feature points imagePoints and the projected (using the current estimates for camera parameters and the poses) object points objectPoints. See @ref projectPoints for details.

Note: If you use a non-square (i.e. non-N-by-N) grid and @ref findChessboardCorners for calibration, and @ref calibrateCamera returns bad values (zero distortion coefficients, \f$c_x\f$ and \f$c_y\f$ very far from the image center, and/or large differences between \f$f_x\f$ and \f$f_y\f$ (ratios of 10:1 or more)), then you are probably using patternSize=cvSize(rows,cols) instead of using patternSize=cvSize(cols,rows) in @ref findChessboardCorners. @sa calibrateCameraRO, findChessboardCorners, solvePnP, initCameraMatrix2D, stereoCalibrate, undistort

Python prototype (for reference only):

calibrateCameraExtended(objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs[, rvecs[, tvecs[, stdDeviationsIntrinsics[, stdDeviationsExtrinsics[, perViewErrors[, flags[, criteria]]]]]]]) -> retval, cameraMatrix, distCoeffs, rvecs, tvecs, stdDeviationsIntrinsics, stdDeviationsExtrinsics, perViewErrors

@spec calibrateCameraRO(
  [Evision.Mat.maybe_mat_in()],
  [Evision.Mat.maybe_mat_in()],
  {number(), number()},
  integer(),
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in()
) ::
  {number(), Evision.Mat.t(), Evision.Mat.t(), [Evision.Mat.t()],
   [Evision.Mat.t()], Evision.Mat.t()}
  | {:error, String.t()}

calibrateCameraRO

Positional Arguments

• objectPoints: [Evision.Mat]
• imagePoints: [Evision.Mat]
• imageSize: Size
• iFixedPoint: int

Keyword Arguments

• flags: int.
• criteria: TermCriteria.

Return

• retval: double
• cameraMatrix: Evision.Mat.t()
• distCoeffs: Evision.Mat.t()
• rvecs: [Evision.Mat].
• tvecs: [Evision.Mat].
• newObjPoints: Evision.Mat.t().

Has overloading in C++

Python prototype (for reference only):

calibrateCameraRO(objectPoints, imagePoints, imageSize, iFixedPoint, cameraMatrix, distCoeffs[, rvecs[, tvecs[, newObjPoints[, flags[, criteria]]]]]) -> retval, cameraMatrix, distCoeffs, rvecs, tvecs, newObjPoints

@spec calibrateCameraRO(
  [Evision.Mat.maybe_mat_in()],
  [Evision.Mat.maybe_mat_in()],
  {number(), number()},
  integer(),
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  [{atom(), term()}, ...] | nil
) ::
  {number(), Evision.Mat.t(), Evision.Mat.t(), [Evision.Mat.t()],
   [Evision.Mat.t()], Evision.Mat.t()}
  | {:error, String.t()}

calibrateCameraRO

Positional Arguments

• objectPoints: [Evision.Mat]
• imagePoints: [Evision.Mat]
• imageSize: Size
• iFixedPoint: int

Keyword Arguments

• flags: int.
• criteria: TermCriteria.

Return

• retval: double
• cameraMatrix: Evision.Mat.t()
• distCoeffs: Evision.Mat.t()
• rvecs: [Evision.Mat].
• tvecs: [Evision.Mat].
• newObjPoints: Evision.Mat.t().

Has overloading in C++

Python prototype (for reference only):

calibrateCameraRO(objectPoints, imagePoints, imageSize, iFixedPoint, cameraMatrix, distCoeffs[, rvecs[, tvecs[, newObjPoints[, flags[, criteria]]]]]) -> retval, cameraMatrix, distCoeffs, rvecs, tvecs, newObjPoints

@spec calibrateCameraROExtended(
  [Evision.Mat.maybe_mat_in()],
  [Evision.Mat.maybe_mat_in()],
  {number(), number()},
  integer(),
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in()
) ::
  {number(), Evision.Mat.t(), Evision.Mat.t(), [Evision.Mat.t()],
   [Evision.Mat.t()], Evision.Mat.t(), Evision.Mat.t(), Evision.Mat.t(),
   Evision.Mat.t(), Evision.Mat.t()}
  | {:error, String.t()}

Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern.

Positional Arguments

• objectPoints: [Evision.Mat].

  Vector of vectors of calibration pattern points in the calibration pattern coordinate space. See #calibrateCamera for details. If the method of releasing object to be used, the identical calibration board must be used in each view and it must be fully visible, and all objectPoints[i] must be the same and all points should be roughly close to a plane. The calibration target has to be rigid, or at least static if the camera (rather than the calibration target) is shifted for grabbing images.

• imagePoints: [Evision.Mat].

  Vector of vectors of the projections of calibration pattern points. See #calibrateCamera for details.

• imageSize: Size.

  Size of the image used only to initialize the intrinsic camera matrix.

• iFixedPoint: int.

  The index of the 3D object point in objectPoints[0] to be fixed. It also acts as a switch for calibration method selection. If object-releasing method to be used, pass in the parameter in the range of [1, objectPoints[0].size()-2], otherwise a value out of this range will make standard calibration method selected. Usually the top-right corner point of the calibration board grid is recommended to be fixed when object-releasing method being utilized. According to \cite strobl2011iccv, two other points are also fixed. In this implementation, objectPoints[0].front and objectPoints[0].back.z are used. With object-releasing method, accurate rvecs, tvecs and newObjPoints are only possible if coordinates of these three fixed points are accurate enough.

Keyword Arguments

• flags: int.

  Different flags that may be zero or a combination of some predefined values. See #calibrateCamera for details. If the method of releasing object is used, the calibration time may be much longer. CALIB_USE_QR or CALIB_USE_LU could be used for faster calibration with potentially less precise and less stable in some rare cases.

• criteria: TermCriteria.

  Termination criteria for the iterative optimization algorithm.

Return

• retval: double

• cameraMatrix: Evision.Mat.t().

  Output 3x3 floating-point camera matrix. See #calibrateCamera for details.

• distCoeffs: Evision.Mat.t().

  Output vector of distortion coefficients. See #calibrateCamera for details.

• rvecs: [Evision.Mat].

  Output vector of rotation vectors estimated for each pattern view. See #calibrateCamera for details.

• tvecs: [Evision.Mat].

  Output vector of translation vectors estimated for each pattern view.

• newObjPoints: Evision.Mat.t().

  The updated output vector of calibration pattern points. The coordinates might be scaled based on three fixed points. The returned coordinates are accurate only if the above mentioned three fixed points are accurate. If not needed, noArray() can be passed in. This parameter is ignored with standard calibration method.

• stdDeviationsIntrinsics: Evision.Mat.t().

  Output vector of standard deviations estimated for intrinsic parameters. See #calibrateCamera for details.

• stdDeviationsExtrinsics: Evision.Mat.t().

  Output vector of standard deviations estimated for extrinsic parameters. See #calibrateCamera for details.

• stdDeviationsObjPoints: Evision.Mat.t().

  Output vector of standard deviations estimated for refined coordinates of calibration pattern points. It has the same size and order as objectPoints[0] vector. This parameter is ignored with standard calibration method.

• perViewErrors: Evision.Mat.t().

  Output vector of the RMS re-projection error estimated for each pattern view.

This function is an extension of #calibrateCamera with the method of releasing object which was proposed in @cite strobl2011iccv. In many common cases with inaccurate, unmeasured, roughly planar targets (calibration plates), this method can dramatically improve the precision of the estimated camera parameters. Both the object-releasing method and standard method are supported by this function. Use the parameter iFixedPoint for method selection. In the internal implementation, #calibrateCamera is a wrapper for this function.

@return the overall RMS re-projection error. The function estimates the intrinsic camera parameters and extrinsic parameters for each of the views. The algorithm is based on @cite Zhang2000, @cite BouguetMCT and @cite strobl2011iccv. See #calibrateCamera for other detailed explanations. @sa calibrateCamera, findChessboardCorners, solvePnP, initCameraMatrix2D, stereoCalibrate, undistort

Python prototype (for reference only):

calibrateCameraROExtended(objectPoints, imagePoints, imageSize, iFixedPoint, cameraMatrix, distCoeffs[, rvecs[, tvecs[, newObjPoints[, stdDeviationsIntrinsics[, stdDeviationsExtrinsics[, stdDeviationsObjPoints[, perViewErrors[, flags[, criteria]]]]]]]]]) -> retval, cameraMatrix, distCoeffs, rvecs, tvecs, newObjPoints, stdDeviationsIntrinsics, stdDeviationsExtrinsics, stdDeviationsObjPoints, perViewErrors

@spec calibrateCameraROExtended(
  [Evision.Mat.maybe_mat_in()],
  [Evision.Mat.maybe_mat_in()],
  {number(), number()},
  integer(),
  Evision.Mat.maybe_mat_in(),
  Evision.Mat.maybe_mat_in(),
  [{atom(), term()}, ...] | nil
) ::
  {number(), Evision.Mat.t(), Evision.Mat.t(), [Evision.Mat.t()],
   [Evision.Mat.t()], Evision.Mat.t(), Evision.Mat.t(), Evision.Mat.t(),
   Evision.Mat.t(), Evision.Mat.t()}
  | {:error, String.t()}

Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern.

Positional Arguments

• objectPoints: [Evision.Mat].

  Vector of vectors of calibration pattern points in the calibration pattern coordinate space. See #calibrateCamera for details. If the method of releasing object to be used, the identical calibration board must be used in each view and it must be fully visible, and all objectPoints[i] must be the same and all points should be roughly close to a plane. The calibration target has to be rigid, or at least static if the camera (rather than the calibration target) is shifted for grabbing images.

• imagePoints: [Evision.Mat].

  Vector of vectors of the projections of calibration pattern points. See #calibrateCamera for details.

• imageSize: Size.

  Size of the image used only to initialize the intrinsic camera matrix.

• iFixedPoint: int.

  The index of the 3D object point in objectPoints[0] to be fixed. It also acts as a switch for calibration method selection. If object-releasing method to be used, pass in the parameter in the range of [1, objectPoints[0].size()-2], otherwise a value out of this range will make standard calibration method selected. Usually the top-right corner point of the calibration board grid is recommended to be fixed when object-releasing method being utilized. According to \cite strobl2011iccv, two other points are also fixed. In this implementation, objectPoints[0].front and objectPoints[0].back.z are used. With object-releasing method, accurate rvecs, tvecs and newObjPoints are only possible if coordinates of these three fixed points are accurate enough.

Keyword Arguments

• flags: int.

  Different flags that may be zero or a combination of some predefined values. See #calibrateCamera for details. If the method of releasing object is used, the calibration time may be much longer. CALIB_USE_QR or CALIB_USE_LU could be used for faster calibration with potentially less precise and less stable in some rare cases.

• criteria: TermCriteria.

  Termination criteria for the iterative optimization algorithm.

Return

• retval: double

• cameraMatrix: Evision.Mat.t().

  Output 3x3 floating-point camera matrix. See #calibrateCamera for details.

• distCoeffs: Evision.Mat.t().

  Output vector of distortion coefficients. See #calibrateCamera for details.

• rvecs: [Evision.Mat].

  Output vector of rotation vectors estimated for each pattern view. See #calibrateCamera for details.

• tvecs: [Evision.Mat].

  Output vector of translation vectors estimated for each pattern view.

• newObjPoints: Evision.Mat.t().

  The updated output vector of calibration pattern points. The coordinates might be scaled based on three fixed points. The returned coordinates are accurate only if the above mentioned three fixed points are accurate. If not needed, noArray() can be passed in. This parameter is ignored with standard calibration method.

• stdDeviationsIntrinsics: Evision.Mat.t().

  Output vector of standard deviations estimated for intrinsic parameters. See #calibrateCamera for details.

• stdDeviationsExtrinsics: Evision.Mat.t().

  Output vector of standard deviations estimated for extrinsic parameters. See #calibrateCamera for details.

• stdDeviationsObjPoints: Evision.Mat.t().

  Output vector of standard deviations estimated for refined coordinates of calibration pattern points. It has the same size and order as objectPoints[0] vector. This parameter is ignored with standard calibration method.

• perViewErrors: Evision.Mat.t().

  Output vector of the RMS re-projection error estimated for each pattern view.

This function is an extension of #calibrateCamera with the method of releasing object which was proposed in @cite strobl2011iccv. In many common cases with inaccurate, unmeasured, roughly planar targets (calibration plates), this method can dramatically improve the precision of the estimated camera parameters. Both the object-releasing method and standard method are supported by this function. Use the parameter iFixedPoint for method selection. In the internal implementation, #calibrateCamera is a wrapper for this function.

@return the overall RMS re-projection error. The function estimates the intrinsic camera parameters and extrinsic parameters for each of the views. The algorithm is based on @cite Zhang2000, @cite BouguetMCT and @cite strobl2011iccv. See #calibrateCamera for other detailed explanations. @sa calibrateCamera, findChessboardCorners, solvePnP, initCameraMatrix2D, stereoCalibrate, undistort

Python prototype (for reference only):

calibrateCameraROExtended(objectPoints, imagePoints, imageSize, iFixedPoint, cameraMatrix, distCoeffs[, rvecs[, tvecs[, newObjPoints[, stdDeviationsIntrinsics[, stdDeviationsExtrinsics[, stdDeviationsObjPoints[, perViewErrors[, flags[, criteria]]]]]]]]]) -> retval, cameraMatrix, distCoeffs, rvecs, tvecs, newObjPoints, stdDeviationsIntrinsics, stdDeviationsExtrinsics, stdDeviationsObjPoints, perViewErrors

@spec calibrateHandEye(
  [Evision.Mat.maybe_mat_in()],
  [Evision.Mat.maybe_mat_in()],
  [Evision.Mat.maybe_mat_in()],
  [Evision.Mat.maybe_mat_in()]
) :: {Evision.Mat.t(), Evision.Mat.t()} | {:error, String.t()}

Computes Hand-Eye calibration: \f$_{}^{g}\textrm{T}_c\f$

Positional Arguments

• r_gripper2base: [Evision.Mat].

  Rotation part extracted from the homogeneous matrix that transforms a point expressed in the gripper frame to the robot base frame (\f$_{}^{b}\textrm{T}_g\f$). This is a vector (vector<Mat>) that contains the rotation, (3x3) rotation matrices or (3x1) rotation vectors, for all the transformations from gripper frame to robot base frame.

• t_gripper2base: [Evision.Mat].

  Translation part extracted from the homogeneous matrix that transforms a point expressed in the gripper frame to the robot base frame (\f$_{}^{b}\textrm{T}_g\f$). This is a vector (vector<Mat>) that contains the (3x1) translation vectors for all the transformations from gripper frame to robot base frame.

• r_target2cam: [Evision.Mat].

  Rotation part extracted from the homogeneous matrix that transforms a point expressed in the target frame to the camera frame (\f$_{}^{c}\textrm{T}_t\f$). This is a vector (vector<Mat>) that contains the rotation, (3x3) rotation matrices or (3x1) rotation vectors, for all the transformations from calibration target frame to camera frame.

• t_target2cam: [Evision.Mat].

  Rotation part extracted from the homogeneous matrix that transforms a point expressed in the target frame to the camera frame (\f$_{}^{c}\textrm{T}_t\f$). This is a vector (vector<Mat>) that contains the (3x1) translation vectors for all the transformations from calibration target frame to camera frame.

Keyword Arguments

• method: HandEyeCalibrationMethod.

  One of the implemented Hand-Eye calibration method, see cv::HandEyeCalibrationMethod

Return

• r_cam2gripper: Evision.Mat.t().

  Estimated (3x3) rotation part extracted from the homogeneous matrix that transforms a point expressed in the camera frame to the gripper frame (\f$_{}^{g}\textrm{T}_c\f$).

• t_cam2gripper: Evision.Mat.t().

  Estimated (3x1) translation part extracted from the homogeneous matrix that transforms a point expressed in the camera frame to the gripper frame (\f$_{}^{g}\textrm{T}_c\f$).

The function performs the Hand-Eye calibration using various methods. One approach consists in estimating the rotation then the translation (separable solutions) and the following methods are implemented:

• R. Tsai, R. Lenz A New Technique for Fully Autonomous and Efficient 3D Robotics Hand/EyeCalibration \cite Tsai89
• F. Park, B. Martin Robot Sensor Calibration: Solving AX = XB on the Euclidean Group \cite Park94
• R. Horaud, F. Dornaika Hand-Eye Calibration \cite Horaud95

Another approach consists in estimating simultaneously the rotation and the translation (simultaneous solutions), with the following implemented methods:

• N. Andreff, R. Horaud, B. Espiau On-line Hand-Eye Calibration \cite Andreff99
• K. Daniilidis Hand-Eye Calibration Using Dual Quaternions \cite Daniilidis98

The following picture describes the Hand-Eye calibration problem where the transformation between a camera ("eye") mounted on a robot gripper ("hand") has to be estimated. This configuration is called eye-in-hand. The eye-to-hand configuration consists in a static camera observing a calibration pattern mounted on the robot end-effector. The transformation from the camera to the robot base frame can then be estimated by inputting the suitable transformations to the function, see below. The calibration procedure is the following:

• a static calibration pattern is used to estimate the transformation between the target frame and the camera frame

• the robot gripper is moved in order to acquire several poses

• for each pose, the homogeneous transformation between the gripper frame and the robot base frame is recorded using for instance the robot kinematics \f[ \begin{bmatrix} X_b\\ Y_b\\ Z_b\\ 1 \end{bmatrix}= \begin{bmatrix} _{}^{b}\textrm{R}_g & _{}^{b}\textrm{t}_g \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_g\\ Y_g\\ Z_g\\ 1 \end{bmatrix} \f]

• for each pose, the homogeneous transformation between the calibration target frame and the camera frame is recorded using for instance a pose estimation method (PnP) from 2D-3D point correspondences \f[ \begin{bmatrix} X_c\\ Y_c\\ Z_c\\ 1 \end{bmatrix}= \begin{bmatrix} _{}^{c}\textrm{R}_t & _{}^{c}\textrm{t}_t \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_t\\ Y_t\\ Z_t\\ 1 \end{bmatrix} \f]

The Hand-Eye calibration procedure returns the following homogeneous transformation \f[ \begin{bmatrix} X_g\\ Y_g\\ Z_g\\ 1 \end{bmatrix} \begin{bmatrix} _{}^{g}\textrm{R}_c & _{}^{g}\textrm{t}_c \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_c\\ Y_c\\ Z_c\\ 1 \end{bmatrix} \f] This problem is also known as solving the \f$\mathbf{A}\mathbf{X}=\mathbf{X}\mathbf{B}\f$ equation:

• for an eye-in-hand configuration \f[ \begin{align*} ^{b}{\textrm{T}_g}^{(1)} \hspace{0.2em} ^{g}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(1)} &= \hspace{0.1em} ^{b}{\textrm{T}_g}^{(2)} \hspace{0.2em} ^{g}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} \\ (^{b}{\textrm{T}_g}^{(2)})^{-1} \hspace{0.2em} ^{b}{\textrm{T}_g}^{(1)} \hspace{0.2em} ^{g}\textrm{T}_c &= \hspace{0.1em} ^{g}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} (^{c}{\textrm{T}_t}^{(1)})^{-1} \\ \textrm{A}_i \textrm{X} &= \textrm{X} \textrm{B}_i \\ \end{align*} \f]

• for an eye-to-hand configuration \f[ \begin{align*} ^{g}{\textrm{T}_b}^{(1)} \hspace{0.2em} ^{b}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(1)} &= \hspace{0.1em} ^{g}{\textrm{T}_b}^{(2)} \hspace{0.2em} ^{b}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} \\ (^{g}{\textrm{T}_b}^{(2)})^{-1} \hspace{0.2em} ^{g}{\textrm{T}_b}^{(1)} \hspace{0.2em} ^{b}\textrm{T}_c &= \hspace{0.1em} ^{b}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} (^{c}{\textrm{T}_t}^{(1)})^{-1} \\ \textrm{A}_i \textrm{X} &= \textrm{X} \textrm{B}_i \\ \end{align*} \f]

\note Additional information can be found on this website. \note A minimum of 2 motions with non parallel rotation axes are necessary to determine the hand-eye transformation. So at least 3 different poses are required, but it is strongly recommended to use many more poses.

Python prototype (for reference only):

calibrateHandEye(R_gripper2base, t_gripper2base, R_target2cam, t_target2cam[, R_cam2gripper[, t_cam2gripper[, method]]]) -> R_cam2gripper, t_cam2gripper

@spec calibrateHandEye(
  [Evision.Mat.maybe_mat_in()],
  [Evision.Mat.maybe_mat_in()],
  [Evision.Mat.maybe_mat_in()],
  [Evision.Mat.maybe_mat_in()],
  [{atom(), term()}, ...] | nil
) :: {Evision.Mat.t(), Evision.Mat.t()} | {:error, String.t()}

Computes Hand-Eye calibration: \f$_{}^{g}\textrm{T}_c\f$

Positional Arguments

• r_gripper2base: [Evision.Mat].

  Rotation part extracted from the homogeneous matrix that transforms a point expressed in the gripper frame to the robot base frame (\f$_{}^{b}\textrm{T}_g\f$). This is a vector (vector<Mat>) that contains the rotation, (3x3) rotation matrices or (3x1) rotation vectors, for all the transformations from gripper frame to robot base frame.

• t_gripper2base: [Evision.Mat].

  Translation part extracted from the homogeneous matrix that transforms a point expressed in the gripper frame to the robot base frame (\f$_{}^{b}\textrm{T}_g\f$). This is a vector (vector<Mat>) that contains the (3x1) translation vectors for all the transformations from gripper frame to robot base frame.

• r_target2cam: [Evision.Mat].

  Rotation part extracted from the homogeneous matrix that transforms a point expressed in the target frame to the camera frame (\f$_{}^{c}\textrm{T}_t\f$). This is a vector (vector<Mat>) that contains the rotation, (3x3) rotation matrices or (3x1) rotation vectors, for all the transformations from calibration target frame to camera frame.

• t_target2cam: [Evision.Mat].

  Rotation part extracted from the homogeneous matrix that transforms a point expressed in the target frame to the camera frame (\f$_{}^{c}\textrm{T}_t\f$). This is a vector (vector<Mat>) that contains the (3x1) translation vectors for all the transformations from calibration target frame to camera frame.

Keyword Arguments

• method: HandEyeCalibrationMethod.

  One of the implemented Hand-Eye calibration method, see cv::HandEyeCalibrationMethod

Return

• r_cam2gripper: Evision.Mat.t().

  Estimated (3x3) rotation part extracted from the homogeneous matrix that transforms a point expressed in the camera frame to the gripper frame (\f$_{}^{g}\textrm{T}_c\f$).

• t_cam2gripper: Evision.Mat.t().

  Estimated (3x1) translation part extracted from the homogeneous matrix that transforms a point expressed in the camera frame to the gripper frame (\f$_{}^{g}\textrm{T}_c\f$).

The function performs the Hand-Eye calibration using various methods. One approach consists in estimating the rotation then the translation (separable solutions) and the following methods are implemented:

• R. Tsai, R. Lenz A New Technique for Fully Autonomous and Efficient 3D Robotics Hand/EyeCalibration \cite Tsai89
• F. Park, B. Martin Robot Sensor Calibration: Solving AX = XB on the Euclidean Group \cite Park94
• R. Horaud, F. Dornaika Hand-Eye Calibration \cite Horaud95

Another approach consists in estimating simultaneously the rotation and the translation (simultaneous solutions), with the following implemented methods:

• N. Andreff, R. Horaud, B. Espiau On-line Hand-Eye Calibration \cite Andreff99
• K. Daniilidis Hand-Eye Calibration Using Dual Quaternions \cite Daniilidis98

The following picture describes the Hand-Eye calibration problem where the transformation between a camera ("eye") mounted on a robot gripper ("hand") has to be estimated. This configuration is called eye-in-hand. The eye-to-hand configuration consists in a static camera observing a calibration pattern mounted on the robot end-effector. The transformation from the camera to the robot base frame can then be estimated by inputting the suitable transformations to the function, see below. The calibration procedure is the following:

• a static calibration pattern is used to estimate the transformation between the target frame and the camera frame

• the robot gripper is moved in order to acquire several poses

• for each pose, the homogeneous transformation between the gripper frame and the robot base frame is recorded using for instance the robot kinematics \f[ \begin{bmatrix} X_b\\ Y_b\\ Z_b\\ 1 \end{bmatrix}= \begin{bmatrix} _{}^{b}\textrm{R}_g & _{}^{b}\textrm{t}_g \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_g\\ Y_g\\ Z_g\\ 1 \end{bmatrix} \f]

• for each pose, the homogeneous transformation between the calibration target frame and the camera frame is recorded using for instance a pose estimation method (PnP) from 2D-3D point correspondences \f[ \begin{bmatrix} X_c\\ Y_c\\ Z_c\\ 1 \end{bmatrix}= \begin{bmatrix} _{}^{c}\textrm{R}_t & _{}^{c}\textrm{t}_t \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_t\\ Y_t\\ Z_t\\ 1 \end{bmatrix} \f]

The Hand-Eye calibration procedure returns the following homogeneous transformation \f[ \begin{bmatrix} X_g\\ Y_g\\ Z_g\\ 1 \end{bmatrix} \begin{bmatrix} _{}^{g}\textrm{R}_c & _{}^{g}\textrm{t}_c \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_c\\ Y_c\\ Z_c\\ 1 \end{bmatrix} \f] This problem is also known as solving the \f$\mathbf{A}\mathbf{X}=\mathbf{X}\mathbf{B}\f$ equation:

• for an eye-in-hand configuration \f[ \begin{align*} ^{b}{\textrm{T}_g}^{(1)} \hspace{0.2em} ^{g}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(1)} &= \hspace{0.1em} ^{b}{\textrm{T}_g}^{(2)} \hspace{0.2em} ^{g}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} \\ (^{b}{\textrm{T}_g}^{(2)})^{-1} \hspace{0.2em} ^{b}{\textrm{T}_g}^{(1)} \hspace{0.2em} ^{g}\textrm{T}_c &= \hspace{0.1em} ^{g}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} (^{c}{\textrm{T}_t}^{(1)})^{-1} \\ \textrm{A}_i \textrm{X} &= \textrm{X} \textrm{B}_i \\ \end{align*} \f]

• for an eye-to-hand configuration \f[ \begin{align*} ^{g}{\textrm{T}_b}^{(1)} \hspace{0.2em} ^{b}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(1)} &= \hspace{0.1em} ^{g}{\textrm{T}_b}^{(2)} \hspace{0.2em} ^{b}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} \\ (^{g}{\textrm{T}_b}^{(2)})^{-1} \hspace{0.2em} ^{g}{\textrm{T}_b}^{(1)} \hspace{0.2em} ^{b}\textrm{T}_c &= \hspace{0.1em} ^{b}\textrm{T}_c \hspace{0.2em} ^{c}{\textrm{T}_t}^{(2)} (^{c}{\textrm{T}_t}^{(1)})^{-1} \\ \textrm{A}_i \textrm{X} &= \textrm{X} \textrm{B}_i \\ \end{align*} \f]

\note Additional information can be found on this website. \note A minimum of 2 motions with non parallel rotation axes are necessary to determine the hand-eye transformation. So at least 3 different poses are required, but it is strongly recommended to use many more poses.

Python prototype (for reference only):

calibrateHandEye(R_gripper2base, t_gripper2base, R_target2cam, t_target2cam[, R_cam2gripper[, t_cam2gripper[, method]]]) -> R_cam2gripper, t_cam2gripper

@spec calibrateRobotWorldHandEye(
  [Evision.Mat.maybe_mat_in()],
  [Evision.Mat.maybe_mat_in()],
  [Evision.Mat.maybe_mat_in()],
  [Evision.Mat.maybe_mat_in()]
) ::
  {Evision.Mat.t(), Evision.Mat.t(), Evision.Mat.t(), Evision.Mat.t()}
  | {:error, String.t()}

Computes Robot-World/Hand-Eye calibration: \f$_{}^{w}\textrm{T}_b\f$ and \f$_{}^{c}\textrm{T}_g\f$

Positional Arguments

• r_world2cam: [Evision.Mat].

  Rotation part extracted from the homogeneous matrix that transforms a point expressed in the world frame to the camera frame (\f$_{}^{c}\textrm{T}_w\f$). This is a vector (vector<Mat>) that contains the rotation, (3x3) rotation matrices or (3x1) rotation vectors, for all the transformations from world frame to the camera frame.

• t_world2cam: [Evision.Mat].

  Translation part extracted from the homogeneous matrix that transforms a point expressed in the world frame to the camera frame (\f$_{}^{c}\textrm{T}_w\f$). This is a vector (vector<Mat>) that contains the (3x1) translation vectors for all the transformations from world frame to the camera frame.

• r_base2gripper: [Evision.Mat].

  Rotation part extracted from the homogeneous matrix that transforms a point expressed in the robot base frame to the gripper frame (\f$_{}^{g}\textrm{T}_b\f$). This is a vector (vector<Mat>) that contains the rotation, (3x3) rotation matrices or (3x1) rotation vectors, for all the transformations from robot base frame to the gripper frame.

• t_base2gripper: [Evision.Mat].

  Rotation part extracted from the homogeneous matrix that transforms a point expressed in the robot base frame to the gripper frame (\f$_{}^{g}\textrm{T}_b\f$). This is a vector (vector<Mat>) that contains the (3x1) translation vectors for all the transformations from robot base frame to the gripper frame.

Keyword Arguments

• method: RobotWorldHandEyeCalibrationMethod.

  One of the implemented Robot-World/Hand-Eye calibration method, see cv::RobotWorldHandEyeCalibrationMethod

Return

• r_base2world: Evision.Mat.t().

  Estimated (3x3) rotation part extracted from the homogeneous matrix that transforms a point expressed in the robot base frame to the world frame (\f$_{}^{w}\textrm{T}_b\f$).

• t_base2world: Evision.Mat.t().

  Estimated (3x1) translation part extracted from the homogeneous matrix that transforms a point expressed in the robot base frame to the world frame (\f$_{}^{w}\textrm{T}_b\f$).

• r_gripper2cam: Evision.Mat.t().

  Estimated (3x3) rotation part extracted from the homogeneous matrix that transforms a point expressed in the gripper frame to the camera frame (\f$_{}^{c}\textrm{T}_g\f$).

• t_gripper2cam: Evision.Mat.t().

  Estimated (3x1) translation part extracted from the homogeneous matrix that transforms a point expressed in the gripper frame to the camera frame (\f$_{}^{c}\textrm{T}_g\f$).

The function performs the Robot-World/Hand-Eye calibration using various methods. One approach consists in estimating the rotation then the translation (separable solutions):

• M. Shah, Solving the robot-world/hand-eye calibration problem using the kronecker product \cite Shah2013SolvingTR

Another approach consists in estimating simultaneously the rotation and the translation (simultaneous solutions), with the following implemented method:

• A. Li, L. Wang, and D. Wu, Simultaneous robot-world and hand-eye calibration using dual-quaternions and kronecker product \cite Li2010SimultaneousRA

The following picture describes the Robot-World/Hand-Eye calibration problem where the transformations between a robot and a world frame and between a robot gripper ("hand") and a camera ("eye") mounted at the robot end-effector have to be estimated. The calibration procedure is the following:

• a static calibration pattern is used to estimate the transformation between the target frame and the camera frame

• the robot gripper is moved in order to acquire several poses

• for each pose, the homogeneous transformation between the gripper frame and the robot base frame is recorded using for instance the robot kinematics \f[ \begin{bmatrix} X_g\\ Y_g\\ Z_g\\ 1 \end{bmatrix}= \begin{bmatrix} _{}^{g}\textrm{R}_b & _{}^{g}\textrm{t}_b \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_b\\ Y_b\\ Z_b\\ 1 \end{bmatrix} \f]

• for each pose, the homogeneous transformation between the calibration target frame (the world frame) and the camera frame is recorded using for instance a pose estimation method (PnP) from 2D-3D point correspondences \f[ \begin{bmatrix} X_c\\ Y_c\\ Z_c\\ 1 \end{bmatrix}= \begin{bmatrix} _{}^{c}\textrm{R}_w & _{}^{c}\textrm{t}_w \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_w\\ Y_w\\ Z_w\\ 1 \end{bmatrix} \f]

The Robot-World/Hand-Eye calibration procedure returns the following homogeneous transformations \f[ \begin{bmatrix} X_w\\ Y_w\\ Z_w\\ 1 \end{bmatrix} \begin{bmatrix} _{}^{w}\textrm{R}_b & _{}^{w}\textrm{t}_b \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_b\\ Y_b\\ Z_b\\ 1 \end{bmatrix} \f] \f[ \begin{bmatrix} X_c\\ Y_c\\ Z_c\\ 1 \end{bmatrix} \begin{bmatrix} _{}^{c}\textrm{R}_g & _{}^{c}\textrm{t}_g \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_g\\ Y_g\\ Z_g\\ 1 \end{bmatrix} \f] This problem is also known as solving the \f$\mathbf{A}\mathbf{X}=\mathbf{Z}\mathbf{B}\f$ equation, with:

• \f$\mathbf{A} \Leftrightarrow \hspace{0.1em} _{}^{c}\textrm{T}_w\f$
• \f$\mathbf{X} \Leftrightarrow \hspace{0.1em} _{}^{w}\textrm{T}_b\f$
• \f$\mathbf{Z} \Leftrightarrow \hspace{0.1em} _{}^{c}\textrm{T}_g\f$
• \f$\mathbf{B} \Leftrightarrow \hspace{0.1em} _{}^{g}\textrm{T}_b\f$

\note At least 3 measurements are required (input vectors size must be greater or equal to 3).

Python prototype (for reference only):

calibrateRobotWorldHandEye(R_world2cam, t_world2cam, R_base2gripper, t_base2gripper[, R_base2world[, t_base2world[, R_gripper2cam[, t_gripper2cam[, method]]]]]) -> R_base2world, t_base2world, R_gripper2cam, t_gripper2cam

@spec calibrateRobotWorldHandEye(
  [Evision.Mat.maybe_mat_in()],
  [Evision.Mat.maybe_mat_in()],
  [Evision.Mat.maybe_mat_in()],
  [Evision.Mat.maybe_mat_in()],
  [{atom(), term()}, ...] | nil
) ::
  {Evision.Mat.t(), Evision.Mat.t(), Evision.Mat.t(), Evision.Mat.t()}
  | {:error, String.t()}

Computes Robot-World/Hand-Eye calibration: \f$_{}^{w}\textrm{T}_b\f$ and \f$_{}^{c}\textrm{T}_g\f$

Positional Arguments

• r_world2cam: [Evision.Mat].

  Rotation part extracted from the homogeneous matrix that transforms a point expressed in the world frame to the camera frame (\f$_{}^{c}\textrm{T}_w\f$). This is a vector (vector<Mat>) that contains the rotation, (3x3) rotation matrices or (3x1) rotation vectors, for all the transformations from world frame to the camera frame.

• t_world2cam: [Evision.Mat].

  Translation part extracted from the homogeneous matrix that transforms a point expressed in the world frame to the camera frame (\f$_{}^{c}\textrm{T}_w\f$). This is a vector (vector<Mat>) that contains the (3x1) translation vectors for all the transformations from world frame to the camera frame.

• r_base2gripper: [Evision.Mat].

  Rotation part extracted from the homogeneous matrix that transforms a point expressed in the robot base frame to the gripper frame (\f$_{}^{g}\textrm{T}_b\f$). This is a vector (vector<Mat>) that contains the rotation, (3x3) rotation matrices or (3x1) rotation vectors, for all the transformations from robot base frame to the gripper frame.

• t_base2gripper: [Evision.Mat].

  Rotation part extracted from the homogeneous matrix that transforms a point expressed in the robot base frame to the gripper frame (\f$_{}^{g}\textrm{T}_b\f$). This is a vector (vector<Mat>) that contains the (3x1) translation vectors for all the transformations from robot base frame to the gripper frame.

Keyword Arguments

• method: RobotWorldHandEyeCalibrationMethod.

  One of the implemented Robot-World/Hand-Eye calibration method, see cv::RobotWorldHandEyeCalibrationMethod

Return

• r_base2world: Evision.Mat.t().

  Estimated (3x3) rotation part extracted from the homogeneous matrix that transforms a point expressed in the robot base frame to the world frame (\f$_{}^{w}\textrm{T}_b\f$).

• t_base2world: Evision.Mat.t().

  Estimated (3x1) translation part extracted from the homogeneous matrix that transforms a point expressed in the robot base frame to the world frame (\f$_{}^{w}\textrm{T}_b\f$).

• r_gripper2cam: Evision.Mat.t().

  Estimated (3x3) rotation part extracted from the homogeneous matrix that transforms a point expressed in the gripper frame to the camera frame (\f$_{}^{c}\textrm{T}_g\f$).

• t_gripper2cam: Evision.Mat.t().

  Estimated (3x1) translation part extracted from the homogeneous matrix that transforms a point expressed in the gripper frame to the camera frame (\f$_{}^{c}\textrm{T}_g\f$).

The function performs the Robot-World/Hand-Eye calibration using various methods. One approach consists in estimating the rotation then the translation (separable solutions):

• M. Shah, Solving the robot-world/hand-eye calibration problem using the kronecker product \cite Shah2013SolvingTR

Another approach consists in estimating simultaneously the rotation and the translation (simultaneous solutions), with the following implemented method:

• A. Li, L. Wang, and D. Wu, Simultaneous robot-world and hand-eye calibration using dual-quaternions and kronecker product \cite Li2010SimultaneousRA

The following picture describes the Robot-World/Hand-Eye calibration problem where the transformations between a robot and a world frame and between a robot gripper ("hand") and a camera ("eye") mounted at the robot end-effector have to be estimated. The calibration procedure is the following:

• a static calibration pattern is used to estimate the transformation between the target frame and the camera frame

• the robot gripper is moved in order to acquire several poses

• for each pose, the homogeneous transformation between the gripper frame and the robot base frame is recorded using for instance the robot kinematics \f[ \begin{bmatrix} X_g\\ Y_g\\ Z_g\\ 1 \end{bmatrix}= \begin{bmatrix} _{}^{g}\textrm{R}_b & _{}^{g}\textrm{t}_b \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_b\\ Y_b\\ Z_b\\ 1 \end{bmatrix} \f]

• for each pose, the homogeneous transformation between the calibration target frame (the world frame) and the camera frame is recorded using for instance a pose estimation method (PnP) from 2D-3D point correspondences \f[ \begin{bmatrix} X_c\\ Y_c\\ Z_c\\ 1 \end{bmatrix}= \begin{bmatrix} _{}^{c}\textrm{R}_w & _{}^{c}\textrm{t}_w \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_w\\ Y_w\\ Z_w\\ 1 \end{bmatrix} \f]

The Robot-World/Hand-Eye calibration procedure returns the following homogeneous transformations \f[ \begin{bmatrix} X_w\\ Y_w\\ Z_w\\ 1 \end{bmatrix} \begin{bmatrix} _{}^{w}\textrm{R}_b & _{}^{w}\textrm{t}_b \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_b\\ Y_b\\ Z_b\\ 1 \end{bmatrix} \f] \f[ \begin{bmatrix} X_c\\ Y_c\\ Z_c\\ 1 \end{bmatrix} \begin{bmatrix} _{}^{c}\textrm{R}_g & _{}^{c}\textrm{t}_g \\ 0_{1 \times 3} & 1 \end{bmatrix} \begin{bmatrix} X_g\\ Y_g\\ Z_g\\ 1 \end{bmatrix} \f] This problem is also known as solving the \f$\mathbf{A}\mathbf{X}=\mathbf{Z}\mathbf{B}\f$ equation, with:

• \f$\mathbf{A} \Leftrightarrow \hspace{0.1em} _{}^{c}\textrm{T}_w\f$
• \f$\mathbf{X} \Leftrightarrow \hspace{0.1em} _{}^{w}\textrm{T}_b\f$
• \f$\mathbf{Z} \Leftrightarrow \hspace{0.1em} _{}^{c}\textrm{T}_g\f$
• \f$\mathbf{B} \Leftrightarrow \hspace{0.1em} _{}^{g}\textrm{T}_b\f$

\note At least 3 measurements are required (input vectors size must be greater or equal to 3).

Python prototype (for reference only):

calibrateRobotWorldHandEye(R_world2cam, t_world2cam, R_base2gripper, t_base2gripper[, R_base2world[, t_base2world[, R_gripper2cam[, t_gripper2cam[, method]]]]]) -> R_base2world, t_base2world, R_gripper2cam, t_gripper2cam

@spec calibrationMatrixValues(
  Evision.Mat.maybe_mat_in(),
  {number(), number()},
  number(),
  number()
) ::
  {number(), number(), number(), {number(), number()}, number()}
  | {:error, String.t()}

Computes useful camera characteristics from the camera intrinsic matrix.

Positional Arguments

• cameraMatrix: Evision.Mat.t().

  Input camera intrinsic matrix that can be estimated by #calibrateCamera or #stereoCalibrate .

• imageSize: Size.

  Input image size in pixels.

• apertureWidth: double.

  Physical width in mm of the sensor.

• apertureHeight: double.

  Physical height in mm of the sensor.

Return

• fovx: double.

  Output field of view in degrees along the horizontal sensor axis.

• fovy: double.

  Output field of view in degrees along the vertical sensor axis.

• focalLength: double.

  Focal length of the lens in mm.

• principalPoint: Point2d.

  Principal point in mm.

• aspectRatio: double.

  \f$f_y/f_x\f$

The function computes various useful camera characteristics from the previously estimated camera matrix. Note: Do keep in mind that the unity measure 'mm' stands for whatever unit of measure one chooses for the chessboard pitch (it can thus be any value).

Python prototype (for reference only):

calibrationMatrixValues(cameraMatrix, imageSize, apertureWidth, apertureHeight) -> fovx, fovy, focalLength, principalPoint, aspectRatio

@spec camShift(
  Evision.Mat.maybe_mat_in(),
  {number(), number(), number(), number()},
  {integer(), integer(), number()}
) ::
  {{{number(), number()}, {number(), number()}, number()},
   {number(), number(), number(), number()}}
  | {:error, String.t()}

Finds an object center, size, and orientation.

Positional Arguments

• probImage: Evision.Mat.t().

  Back projection of the object histogram. See calcBackProject.

• criteria: TermCriteria.

  Stop criteria for the underlying meanShift. returns (in old interfaces) Number of iterations CAMSHIFT took to converge The function implements the CAMSHIFT object tracking algorithm @cite Bradski98 . First, it finds an object center using meanShift and then adjusts the window size and finds the optimal rotation. The function returns the rotated rectangle structure that includes the object position, size, and orientation. The next position of the search window can be obtained with RotatedRect::boundingRect()

Return

• retval: {centre={x, y}, size={s1, s2}, angle}

• window: Rect.

  Initial search window.

See the OpenCV sample camshiftdemo.c that tracks colored objects. Note:

• (Python) A sample explaining the camshift tracking algorithm can be found at opencv_source_code/samples/python/camshift.py

Python prototype (for reference only):

CamShift(probImage, window, criteria) -> retval, window