IPP wrapper functions
[Image processing]

Comprehensive set of wrapper functions for Intel(R) Integrated Performance Primitives (IPP). More...

Functions

void Copy (const QVImage< uChar, 1 > &src, QVImage< uChar, 1 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Copies pixel values between two images.
void Copy (const QVImage< uShort, 1 > &src, QVImage< uShort, 1 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Copy pixel values between two images.
void Copy (const QVImage< sShort, 1 > &src, QVImage< sShort, 1 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Copy pixel values between two images.
void Copy (const QVImage< sInt, 1 > &src, QVImage< sInt, 1 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Copy pixel values between two images.
void Copy (const QVImage< sFloat, 1 > &src, QVImage< sFloat, 1 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Copy pixel values between two images.
void Copy (const QVImage< uChar, 3 > &src, QVImage< uChar, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Copy pixel values between two images.
void Copy (const QVImage< uShort, 3 > &src, QVImage< uShort, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Copy pixel values between two images.
void Copy (const QVImage< sShort, 3 > &src, QVImage< sShort, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Copy pixel values between two images.
void Copy (const QVImage< sInt, 3 > &src, QVImage< sInt, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Copy pixel values between two images.
void Copy (const QVImage< sFloat, 3 > &src, QVImage< sFloat, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Copy pixel values between two images.
void Copy (const QVImage< uChar, 1 > &src, QVImage< uChar, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Copy a one-channel image to a multi-channel image.
void Copy (const QVImage< uShort, 1 > &src, QVImage< uShort, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Copy a one-channel image to a multi-channel image.
void Copy (const QVImage< sShort, 1 > &src, QVImage< sShort, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Copy a one-channel image to a multi-channel image.
void Copy (const QVImage< sInt, 1 > &src, QVImage< sInt, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Copy a one-channel image to a multi-channel image.
void Copy (const QVImage< sFloat, 1 > &src, QVImage< sFloat, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Copy a one-channel image to a multi-channel image.
void Copy (const QVImage< uChar, 1 > &src1, const QVImage< uChar, 1 > &src2, const QVImage< uChar, 1 > &src3, QVImage< uChar, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Composes color image from separate channel images.
void Copy (const QVImage< uShort, 1 > &src1, const QVImage< uShort, 1 > &src2, const QVImage< uShort, 1 > &src3, QVImage< uShort, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Composes color image from separate channel images.
void Copy (const QVImage< sShort, 1 > &src1, const QVImage< sShort, 1 > &src2, const QVImage< sShort, 1 > &src3, QVImage< sShort, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Composes color image from separate channel images.
void Copy (const QVImage< sInt, 1 > &src1, const QVImage< sInt, 1 > &src2, const QVImage< sInt, 1 > &src3, QVImage< sInt, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Composes color image from separate channel images.
void Copy (const QVImage< sFloat, 1 > &src1, const QVImage< sFloat, 1 > &src2, const QVImage< sFloat, 1 > &src3, QVImage< sFloat, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Composes color image from separate channel images.
void Copy (const QVImage< uChar, 3 > &src, QVImage< uChar, 1 > &dest, uChar channel, QPoint destROIOffset=QPoint(0, 0))
 Copy a selected channel from a 3-channel image to a 1-channel image.
void Copy (const QVImage< uShort, 3 > &src, QVImage< uShort, 1 > &dest, uChar channel, QPoint destROIOffset=QPoint(0, 0))
 Copy a selected channel from a 3-channel image to a 1-channel image.
void Copy (const QVImage< sShort, 3 > &src, QVImage< sShort, 1 > &dest, uChar channel, QPoint destROIOffset=QPoint(0, 0))
 Copy a selected channel from a 3-channel image to a 1-channel image.
void Copy (const QVImage< sInt, 3 > &src, QVImage< sInt, 1 > &dest, uChar channel, QPoint destROIOffset=QPoint(0, 0))
 Copy a selected channel from a 3-channel image to a 1-channel image.
void Copy (const QVImage< sFloat, 3 > &src, QVImage< sFloat, 1 > &dest, uChar channel, QPoint destROIOffset=QPoint(0, 0))
 Copy a selected channel from a 3-channel image to a 1-channel image.
void Compare (const QVImage< uChar > &src1, const QVImage< uChar > &src2, QVImage< uChar > &dest, IppCmpOp ippCmpOp=ippCmpEq, QPoint destROIOffset=QPoint(0, 0))
 Compares pixel values of two images using a specified compare operation.
void Compare (const QVImage< uShort > &src1, const QVImage< uShort > &src2, QVImage< uChar > &dest, IppCmpOp ippCmpOp=ippCmpEq, QPoint destROIOffset=QPoint(0, 0))
 Compares pixel values of two images using a specified compare operation.
void Compare (const QVImage< sShort > &src1, const QVImage< sShort > &src2, QVImage< uChar > &dest, IppCmpOp ippCmpOp=ippCmpEq, QPoint destROIOffset=QPoint(0, 0))
 Compares pixel values of two images using a specified compare operation.
void Compare (const QVImage< sFloat > &src1, const QVImage< sFloat > &src2, QVImage< uChar > &dest, IppCmpOp ippCmpOp=ippCmpEq, QPoint destROIOffset=QPoint(0, 0))
 Compares pixel values of two images using a specified compare operation.
void Compare (const QVImage< uChar, 3 > &src1, const QVImage< uChar, 3 > &src2, QVImage< uChar > &dest, IppCmpOp ippCmpOp=ippCmpEq, QPoint destROIOffset=QPoint(0, 0))
 Compares pixel values of two images using a specified compare operation.
void Compare (const QVImage< uShort, 3 > &src1, const QVImage< uShort, 3 > &src2, QVImage< uChar > &dest, IppCmpOp ippCmpOp=ippCmpEq, QPoint destROIOffset=QPoint(0, 0))
 Compares pixel values of two images using a specified compare operation.
void Compare (const QVImage< sShort, 3 > &src1, const QVImage< sShort, 3 > &src2, QVImage< uChar > &dest, IppCmpOp ippCmpOp=ippCmpEq, QPoint destROIOffset=QPoint(0, 0))
 Compares pixel values of two images using a specified compare operation.
void Compare (const QVImage< sFloat, 3 > &src1, const QVImage< sFloat, 3 > &src2, QVImage< uChar > &dest, IppCmpOp ippCmpOp=ippCmpEq, QPoint destROIOffset=QPoint(0, 0))
 Compares pixel values of two images using a specified compare operation.
void CompareC (const QVImage< uChar > &src, QVImage< uChar > &dest, uChar constant, IppCmpOp ippCmpOp=ippCmpEq, QPoint destROIOffset=QPoint(0, 0))
 Compares pixel values of a source image to a given value using a specified compare operation.
void CompareC (const QVImage< sFloat > &src, QVImage< uChar > &dest, sFloat constant, IppCmpOp ippCmpOp=ippCmpEq, QPoint destROIOffset=QPoint(0, 0))
 Compares pixel values of a source image to a given value using a specified compare operation.
void Convert (const QVImage< uChar, 1 > &src, QVImage< uShort, 1 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from one bit depth to another.
void Convert (const QVImage< uChar, 1 > &src, QVImage< sShort, 1 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from one bit depth to another.
void Convert (const QVImage< uChar, 1 > &src, QVImage< sInt, 1 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from one bit depth to another.
void Convert (const QVImage< uChar, 1 > &src, QVImage< sFloat, 1 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from one bit depth to another.
void Convert (const QVImage< uShort, 1 > &src, QVImage< uChar, 1 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from one bit depth to another.
void Convert (const QVImage< uShort, 1 > &src, QVImage< sInt, 1 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from one bit depth to another.
void Convert (const QVImage< uShort, 1 > &src, QVImage< sFloat, 1 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from one bit depth to another.
void Convert (const QVImage< sShort, 1 > &src, QVImage< uChar, 1 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from one bit depth to another.
void Convert (const QVImage< sShort, 1 > &src, QVImage< sInt, 1 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from one bit depth to another.
void Convert (const QVImage< sShort, 1 > &src, QVImage< sFloat, 1 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from one bit depth to another.
void Convert (const QVImage< sInt, 1 > &src, QVImage< uChar, 1 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from one bit depth to another.
void Convert (const QVImage< uChar, 3 > &src, QVImage< uShort, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from one bit depth to another.
void Convert (const QVImage< uChar, 3 > &src, QVImage< sShort, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from one bit depth to another.
void Convert (const QVImage< uChar, 3 > &src, QVImage< sInt, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from one bit depth to another.
void Convert (const QVImage< uChar, 3 > &src, QVImage< sFloat, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from one bit depth to another.
void Convert (const QVImage< uShort, 3 > &src, QVImage< uChar, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from one bit depth to another.
void Convert (const QVImage< uShort, 3 > &src, QVImage< sInt, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from one bit depth to another.
void Convert (const QVImage< uShort, 3 > &src, QVImage< sFloat, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from one bit depth to another.
void Convert (const QVImage< sShort, 3 > &src, QVImage< uChar, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from one bit depth to another.
void Convert (const QVImage< sShort, 3 > &src, QVImage< sInt, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from one bit depth to another.
void Convert (const QVImage< sShort, 3 > &src, QVImage< sFloat, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from one bit depth to another.
void Convert (const QVImage< sInt, 3 > &src, QVImage< uChar, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from one bit depth to another.
void Convert (const QVImage< sFloat, 1 > &src, QVImage< uChar, 1 > &dest, IppRoundMode roundMode=ippRndNear, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from a floating point bit depth to a integer bit depth, using a given round mode.
void Convert (const QVImage< sFloat, 1 > &src, QVImage< uShort, 1 > &dest, IppRoundMode roundMode=ippRndNear, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from a floating point bit depth to a integer bit depth, using a given round mode.
void Convert (const QVImage< sFloat, 1 > &src, QVImage< sShort, 1 > &dest, IppRoundMode roundMode=ippRndNear, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from a floating point bit depth to a integer bit depth, using a given round mode.
void Convert (const QVImage< sFloat, 3 > &src, QVImage< uChar, 3 > &dest, IppRoundMode roundMode=ippRndNear, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from a floating point bit depth to a integer bit depth, using a given round mode.
void Convert (const QVImage< sFloat, 3 > &src, QVImage< uShort, 3 > &dest, IppRoundMode roundMode=ippRndNear, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from a floating point bit depth to a integer bit depth, using a given round mode.
void Convert (const QVImage< sFloat, 3 > &src, QVImage< sShort, 3 > &dest, IppRoundMode roundMode=ippRndNear, QPoint destROIOffset=QPoint(0, 0))
 Converts a image from a floating point bit depth to a integer bit depth, using a given round mode.
void RGBToGray (const QVImage< uChar, 3 > &src, QVImage< uChar, 1 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts an RGB image to gray-scale using fixed transform coefficients.
void RGBToGray (const QVImage< uShort, 3 > &src, QVImage< uShort, 1 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts an RGB image to gray-scale using fixed transform coefficients.
void RGBToGray (const QVImage< sShort, 3 > &src, QVImage< sShort, 1 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts an RGB image to gray-scale using fixed transform coefficients.
void RGBToGray (const QVImage< sFloat, 3 > &src, QVImage< sFloat, 1 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Converts an RGB image to gray-scale using fixed transform coefficients.
void Threshold (const QVImage< uChar > &src, QVImage< uChar > &dest, uChar constant, IppCmpOp ippCmpOp=ippCmpEq, QPoint destROIOffset=QPoint(0, 0))
 Performs thresholding of pixel values in an image buffer.
void Threshold (const QVImage< sShort > &src, QVImage< sShort > &dest, sShort constant, IppCmpOp ippCmpOp=ippCmpEq, QPoint destROIOffset=QPoint(0, 0))
 Performs thresholding of pixel values in an image buffer.
void Threshold (const QVImage< sFloat > &src, QVImage< sFloat > &dest, sFloat constant, IppCmpOp ippCmpOp=ippCmpEq, QPoint destROIOffset=QPoint(0, 0))
 Performs thresholding of pixel values in an image buffer.
void Threshold (QVImage< uChar > &src_dest, uChar constant, IppCmpOp ippCmpOp=ippCmpEq)
 Performs inplace (dest=src) thresholding of pixel values in an image buffer.
void Threshold (QVImage< sShort > &src_dest, sShort constant, IppCmpOp ippCmpOp=ippCmpEq)
 Performs inplace (dest=src) thresholding of pixel values in an image buffer.
void Threshold (QVImage< sFloat > &src_dest, sFloat constant, IppCmpOp ippCmpOp=ippCmpEq)
 Performs inplace (dest=src) thresholding of pixel values in an image buffer.
void Threshold_Val (const QVImage< uChar > &src, QVImage< uChar > &dest, uChar threshold, uChar value, IppCmpOp ippCmpOp, QPoint destROIOffset=QPoint(0, 0))
 Performs thresholding of pixel values in an image buffer. Pixels that satisfy the compare condition are set to a specified value.
void Threshold_Val (const QVImage< sFloat > &src, QVImage< sFloat > &dest, sFloat threshold, sFloat value, IppCmpOp ippCmpOp, QPoint destROIOffset=QPoint(0, 0))
 Performs thresholding of pixel values in an image buffer. Pixels that satisfy the compare condition are set to a specified value.
void Threshold_Val (QVImage< uChar > &src_dest, uChar threshold, uChar value, IppCmpOp ippCmpOp=ippCmpEq)
 Performs inplace (dest=src) thresholding of pixel values in an image buffer. Pixels that satisfy the compare condition are set to a specified value.
void Threshold_Val (QVImage< sShort > &src_dest, sShort threshold, sShort value, IppCmpOp ippCmpOp=ippCmpEq)
 Performs inplace (dest=src) thresholding of pixel values in an image buffer. Pixels that satisfy the compare condition are set to a specified value.
void Threshold_Val (QVImage< sFloat > &src_dest, sFloat threshold, sFloat value, IppCmpOp ippCmpOp=ippCmpEq)
 Performs inplace (dest=src) thresholding of pixel values in an image buffer. Pixels that satisfy the compare condition are set to a specified value.
void Threshold_LTValGTVal (const QVImage< uChar > &src, QVImage< uChar > &dest, uChar thresholdLT, uChar valueLT, uChar thresholdGT, uChar valueGT, QPoint destROIOffset=QPoint(0, 0))
 Performs double thresholding of pixel values in an image buffer.
void Threshold_LTValGTVal (const QVImage< sFloat > &src, QVImage< sFloat > &dest, sFloat thresholdLT, sFloat valueLT, sFloat thresholdGT, sFloat valueGT, QPoint destROIOffset=QPoint(0, 0))
 Performs double thresholding of pixel values in an image buffer.
void Set (QVImage< uChar > &img, uChar constant)
 Sets pixels of an image ROI to a value.
void Set (QVImage< uShort > &img, uShort constant)
 Sets pixels of an image ROI to a value.
void Set (QVImage< sShort > &img, sShort constant)
 Sets pixels of an image ROI to a value.
void Set (QVImage< sInt > &img, sInt constant)
 Sets pixels of an image ROI to a value.
void Set (QVImage< sFloat > &img, sFloat constant)
 Sets pixels of an image ROI to a value.
void Set (QVImage< uChar, 3 > &img, uChar red, uChar green, uChar blue)
 Sets pixels of a 3-channel image ROI to a value respective constant value, one for each channel.
void Set (QVImage< uShort, 3 > &img, uShort red, uShort green, uShort blue)
 Sets pixels of a 3-channel image ROI to a value respective constant value, one for each channel.
void Set (QVImage< sShort, 3 > &img, sShort red, sShort green, sShort blue)
 Sets pixels of a 3-channel image ROI to a value respective constant value, one for each channel.
void Set (QVImage< sInt, 3 > &img, sInt red, sInt green, sInt blue)
 Sets pixels of a 3-channel image ROI to a value respective constant value, one for each channel.
void Set (QVImage< sFloat, 3 > &img, sFloat red, sFloat green, sFloat blue)
 Sets pixels of a 3-channel image ROI to a value respective constant value, one for each channel.
void Abs (const QVImage< sShort > &src, QVImage< sShort > &dest, QPoint destROIOffset=QPoint(0, 0))
 Computes absolute pixel values of a source image and places them into the destination image.
void Abs (const QVImage< sFloat > &src, QVImage< sFloat > &dest, QPoint destROIOffset=QPoint(0, 0))
 Computes absolute pixel values of a source image and places them into the destination image.
void Not (const QVImage< uChar > &src, QVImage< uChar > &dest, QPoint destROIOffset=QPoint(0, 0))
 Performs a bit-wise NOT operation on each pixel of an image.
void Not (const QVImage< uChar, 3 > &src, QVImage< uChar, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Performs a bit-wise NOT operation on each pixel of an image.
void OrC (const QVImage< uChar > &src, QVImage< uChar > &dest, uChar constant, QPoint destROIOffset=QPoint(0, 0))
 Performs a bit-wise inclusive OR operation between each pixel of an image and a constant.
void OrC (const QVImage< uChar, 3 > &src, QVImage< uChar, 3 > &dest, uChar constant, QPoint destROIOffset=QPoint(0, 0))
 Performs a bit-wise inclusive OR operation between each pixel of an image and a constant.
void OrC (const QVImage< uShort > &src, QVImage< uShort > &dest, uShort constant, QPoint destROIOffset=QPoint(0, 0))
 Performs a bit-wise inclusive OR operation between each pixel of an image and a constant.
void OrC (const QVImage< uShort, 3 > &src, QVImage< uShort, 3 > &dest, uShort constant, QPoint destROIOffset=QPoint(0, 0))
 Performs a bit-wise inclusive OR operation between each pixel of an image and a constant.
void OrC (const QVImage< sInt > &src, QVImage< sInt > &dest, sInt constant, QPoint destROIOffset=QPoint(0, 0))
 Performs a bit-wise inclusive OR operation between each pixel of an image and a constant.
void OrC (const QVImage< sInt, 3 > &src, QVImage< sInt, 3 > &dest, sInt constant, QPoint destROIOffset=QPoint(0, 0))
 Performs a bit-wise inclusive OR operation between each pixel of an image and a constant.
void AndC (const QVImage< uChar > &src, QVImage< uChar > &dest, uChar constant, QPoint destROIOffset=QPoint(0, 0))
 Performs a bit-wise AND operation between each pixel of an image and a constant.
void AndC (const QVImage< uChar, 3 > &src, QVImage< uChar, 3 > &dest, uChar constant, QPoint destROIOffset=QPoint(0, 0))
 Performs a bit-wise AND operation between each pixel of an image and a constant.
void AndC (const QVImage< uShort > &src, QVImage< uShort > &dest, uShort constant, QPoint destROIOffset=QPoint(0, 0))
 Performs a bit-wise AND operation between each pixel of an image and a constant.
void AndC (const QVImage< uShort, 3 > &src, QVImage< uShort, 3 > &dest, uShort constant, QPoint destROIOffset=QPoint(0, 0))
 Performs a bit-wise AND operation between each pixel of an image and a constant.
void AndC (const QVImage< sInt > &src, QVImage< sInt > &dest, sInt constant, QPoint destROIOffset=QPoint(0, 0))
 Performs a bit-wise AND operation between each pixel of an image and a constant.
void AndC (const QVImage< sInt, 3 > &src, QVImage< sInt, 3 > &dest, sInt constant, QPoint destROIOffset=QPoint(0, 0))
 Performs a bit-wise AND operation between each pixel of an image and a constant.
void XorC (const QVImage< uChar > &src, QVImage< uChar > &dest, uChar constant, QPoint destROIOffset=QPoint(0, 0))
 Performs a bit-wise exclusive OR operation between each pixel of an image and a constant.
void XorC (const QVImage< uChar, 3 > &src, QVImage< uChar, 3 > &dest, uChar constant, QPoint destROIOffset=QPoint(0, 0))
 Performs a bit-wise exclusive OR operation between each pixel of an image and a constant.
void XorC (const QVImage< uShort > &src, QVImage< uShort > &dest, uShort constant, QPoint destROIOffset=QPoint(0, 0))
 Performs a bit-wise exclusive OR operation between each pixel of an image and a constant.
void XorC (const QVImage< uShort, 3 > &src, QVImage< uShort, 3 > &dest, uShort constant, QPoint destROIOffset=QPoint(0, 0))
 Performs a bit-wise exclusive OR operation between each pixel of an image and a constant.
void XorC (const QVImage< sInt > &src, QVImage< sInt > &dest, sInt constant, QPoint destROIOffset=QPoint(0, 0))
 Performs a bit-wise exclusive OR operation between each pixel of an image and a constant.
void XorC (const QVImage< sInt, 3 > &src, QVImage< sInt, 3 > &dest, sInt constant, QPoint destROIOffset=QPoint(0, 0))
 Performs a bit-wise exclusive OR operation between each pixel of an image and a constant.
void LShiftC (const QVImage< uChar > &src, QVImage< uChar > &dest, uChar constant, QPoint destROIOffset=QPoint(0, 0))
 Shifts bits in pixel values to the left.
void LShiftC (const QVImage< uChar, 3 > &src, QVImage< uChar, 3 > &dest, uChar constant, QPoint destROIOffset=QPoint(0, 0))
 Shifts bits in pixel values to the left.
void LShiftC (const QVImage< uShort > &src, QVImage< uShort > &dest, uShort constant, QPoint destROIOffset=QPoint(0, 0))
 Shifts bits in pixel values to the left.
void LShiftC (const QVImage< uShort, 3 > &src, QVImage< uShort, 3 > &dest, uShort constant, QPoint destROIOffset=QPoint(0, 0))
 Shifts bits in pixel values to the left.
void LShiftC (const QVImage< sInt > &src, QVImage< sInt > &dest, sInt constant, QPoint destROIOffset=QPoint(0, 0))
 Shifts bits in pixel values to the left.
void LShiftC (const QVImage< sInt, 3 > &src, QVImage< sInt, 3 > &dest, sInt constant, QPoint destROIOffset=QPoint(0, 0))
 Shifts bits in pixel values to the left.
void Ln (const QVImage< sFloat > &src, QVImage< sFloat > &dest, QPoint destROIOffset=QPoint(0, 0))
 Computes the natural logarithm of pixel values in a source image and writes the results into the destination image.
void Ln (const QVImage< sFloat, 3 > &src, QVImage< sFloat, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Computes the natural logarithm of pixel values in a source image and writes the results into the destination image.
void Sqr (const QVImage< sFloat, 1 > &src, QVImage< sFloat, 1 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Squares pixel values of an image and writes them into the destination image.
void RShiftC (const QVImage< uChar > &src, QVImage< uChar > &dest, uChar constant, QPoint destROIOffset=QPoint(0, 0))
 Shifts bits in pixel values to the right.
void RShiftC (const QVImage< uChar, 3 > &src, QVImage< uChar, 3 > &dest, uChar constant, QPoint destROIOffset=QPoint(0, 0))
 Shifts bits in pixel values to the right.
void RShiftC (const QVImage< uShort > &src, QVImage< uShort > &dest, uShort constant, QPoint destROIOffset=QPoint(0, 0))
 Shifts bits in pixel values to the right.
void RShiftC (const QVImage< uShort, 3 > &src, QVImage< uShort, 3 > &dest, uShort constant, QPoint destROIOffset=QPoint(0, 0))
 Shifts bits in pixel values to the right.
void RShiftC (const QVImage< sInt > &src, QVImage< sInt > &dest, sInt constant, QPoint destROIOffset=QPoint(0, 0))
 Shifts bits in pixel values to the right.
void RShiftC (const QVImage< sInt, 3 > &src, QVImage< sInt, 3 > &dest, sInt constant, QPoint destROIOffset=QPoint(0, 0))
 Shifts bits in pixel values to the right.
void Add (const QVImage< uChar > &src1, const QVImage< uChar > &src2, QVImage< uChar > &dest, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Adds pixel values of two images.
void Add (const QVImage< uChar, 3 > &src1, const QVImage< uChar, 3 > &src2, QVImage< uChar, 3 > &dest, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Adds pixel values of two images.
void Add (const QVImage< uShort > &src1, const QVImage< uShort > &src2, QVImage< uShort > &dest, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Adds pixel values of two images.
void Add (const QVImage< uShort, 3 > &src1, const QVImage< uShort, 3 > &src2, QVImage< uShort, 3 > &dest, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Adds pixel values of two images.
void Add (const QVImage< sShort > &src1, const QVImage< sShort > &src2, QVImage< sShort > &dest, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Adds pixel values of two images.
void Add (const QVImage< sShort, 3 > &src1, const QVImage< sShort, 3 > &src2, QVImage< sShort, 3 > &dest, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Adds pixel values of two images.
void Add (const QVImage< sFloat > &src1, const QVImage< sFloat > &src2, QVImage< sFloat > &dest, QPoint destROIOffset=QPoint(0, 0))
 Adds pixel values of two images.
void Add (const QVImage< sFloat, 3 > &src1, const QVImage< sFloat, 3 > &src2, QVImage< sFloat, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Adds pixel values of two images.
void Sub (const QVImage< uChar > &src1, const QVImage< uChar > &src2, QVImage< uChar > &dest, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Subtracts pixel values of two images.
void Sub (const QVImage< uChar, 3 > &src1, const QVImage< uChar, 3 > &src2, QVImage< uChar, 3 > &dest, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Subtracts pixel values of two images.
void Sub (const QVImage< uShort > &src1, const QVImage< uShort > &src2, QVImage< uShort > &dest, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Subtracts pixel values of two images.
void Sub (const QVImage< uShort, 3 > &src1, const QVImage< uShort, 3 > &src2, QVImage< uShort, 3 > &dest, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Subtracts pixel values of two images.
void Sub (const QVImage< sShort > &src1, const QVImage< sShort > &src2, QVImage< sShort > &dest, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Subtracts pixel values of two images.
void Sub (const QVImage< sShort, 3 > &src1, const QVImage< sShort, 3 > &src2, QVImage< sShort, 3 > &dest, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Subtracts pixel values of two images.
void Sub (const QVImage< sFloat > &src1, const QVImage< sFloat > &src2, QVImage< sFloat > &dest, QPoint destROIOffset=QPoint(0, 0))
 Subtracts pixel values of two images.
void Sub (const QVImage< sFloat, 3 > &src1, const QVImage< sFloat, 3 > &src2, QVImage< sFloat, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Subtracts pixel values of two images.
void Mul (const QVImage< uChar > &src1, const QVImage< uChar > &src2, QVImage< uChar > &dest, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Multiplies pixel values of two images.
void Mul (const QVImage< uChar, 3 > &src1, const QVImage< uChar, 3 > &src2, QVImage< uChar, 3 > &dest, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Multiplies pixel values of two images.
void Mul (const QVImage< uShort > &src1, const QVImage< uShort > &src2, QVImage< uShort > &dest, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Multiplies pixel values of two images.
void Mul (const QVImage< uShort, 3 > &src1, const QVImage< uShort, 3 > &src2, QVImage< uShort, 3 > &dest, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Multiplies pixel values of two images.
void Mul (const QVImage< sShort > &src1, const QVImage< sShort > &src2, QVImage< sShort > &dest, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Multiplies pixel values of two images.
void Mul (const QVImage< sShort, 3 > &src1, const QVImage< sShort, 3 > &src2, QVImage< sShort, 3 > &dest, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Multiplies pixel values of two images.
void Mul (const QVImage< sFloat > &src1, const QVImage< sFloat > &src2, QVImage< sFloat > &dest, QPoint destROIOffset=QPoint(0, 0))
 Multiplies pixel values of two images.
void Mul (const QVImage< sFloat, 3 > &src1, const QVImage< sFloat, 3 > &src2, QVImage< sFloat, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Multiplies pixel values of two images.
void Div (const QVImage< uChar > &src1, const QVImage< uChar > &src2, QVImage< uChar > &dest, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Divides pixel values of an image by pixel values of another image.
void Div (const QVImage< uChar, 3 > &src1, const QVImage< uChar, 3 > &src2, QVImage< uChar, 3 > &dest, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Divides pixel values of an image by pixel values of another image.
void Div (const QVImage< uShort > &src1, const QVImage< uShort > &src2, QVImage< uShort > &dest, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Divides pixel values of an image by pixel values of another image.
void Div (const QVImage< uShort, 3 > &src1, const QVImage< uShort, 3 > &src2, QVImage< uShort, 3 > &dest, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Divides pixel values of an image by pixel values of another image.
void Div (const QVImage< sShort > &src1, const QVImage< sShort > &src2, QVImage< sShort > &dest, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Divides pixel values of an image by pixel values of another image.
void Div (const QVImage< sShort, 3 > &src1, const QVImage< sShort, 3 > &src2, QVImage< sShort, 3 > &dest, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Divides pixel values of an image by pixel values of another image.
void Div (const QVImage< sFloat > &src1, const QVImage< sFloat > &src2, QVImage< sFloat > &dest, QPoint destROIOffset=QPoint(0, 0))
 Divides pixel values of an image by pixel values of another image.
void Div (const QVImage< sFloat, 3 > &src1, const QVImage< sFloat, 3 > &src2, QVImage< sFloat, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Divides pixel values of an image by pixel values of another image.
void MulScale (const QVImage< uChar > &src1, const QVImage< uChar > &src2, QVImage< uChar > &dest, QPoint destROIOffset=QPoint(0, 0))
 Multiplies pixel values of two images and scales the products.
void MulScale (const QVImage< uChar, 3 > &src1, const QVImage< uChar, 3 > &src2, QVImage< uChar, 3 > &dest, QPoint destROIOffset=QPoint(0, 0))
 Multiplies pixel values of two images and scales the products.
void AbsDiff (const QVImage< uChar > &src1, const QVImage< uChar > &src2, QVImage< uChar > &dest, QPoint destROIOffset=QPoint(0, 0))
 Calculates absolute difference between two images.
void AbsDiff (const QVImage< sFloat > &src1, const QVImage< sFloat > &src2, QVImage< sFloat > &dest, QPoint destROIOffset=QPoint(0, 0))
 Calculates absolute difference between two images.
void MulC (const QVImage< uChar > &src, QVImage< uChar > &dest, uChar constant, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Multiplies pixel values of an image by a constant.
void MulC (const QVImage< uShort > &src, QVImage< uShort > &dest, uShort constant, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Multiplies pixel values of an image by a constant.
void MulC (const QVImage< sShort > &src, QVImage< sShort > &dest, sShort constant, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Multiplies pixel values of an image by a constant.
void MulC (const QVImage< sFloat > &src, QVImage< sFloat > &dest, sFloat constant, QPoint destROIOffset=QPoint(0, 0))
 Multiplies pixel values of an image by a constant.
void MulC (const QVImage< uChar, 3 > &src, QVImage< uChar, 3 > &dest, uChar constant, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Adds a constant to pixel values of an image.
void MulC (const QVImage< uShort, 3 > &src, QVImage< uShort, 3 > &dest, uShort constant, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Adds a constant to pixel values of an image.
void MulC (const QVImage< sShort, 3 > &src, QVImage< sShort, 3 > &dest, sShort constant, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Adds a constant to pixel values of an image.
void MulC (const QVImage< sFloat, 3 > &src, QVImage< sFloat, 3 > &dest, sFloat constant, QPoint destROIOffset=QPoint(0, 0))
 Adds a constant to pixel values of an image.
void AddC (const QVImage< uChar > &src, QVImage< uChar > &dest, uChar constant, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Adds a constant to pixel values of an image.
void AddC (const QVImage< uShort > &src, QVImage< uShort > &dest, uShort constant, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Adds a constant to pixel values of an image.
void AddC (const QVImage< sShort > &src, QVImage< sShort > &dest, sShort constant, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Adds a constant to pixel values of an image.
void AddC (const QVImage< sFloat > &src, QVImage< sFloat > &dest, sFloat constant, QPoint destROIOffset=QPoint(0, 0))
 Adds a constant to pixel values of an image.
void AddC (const QVImage< uChar, 3 > &src, QVImage< uChar, 3 > &dest, uChar constant, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Adds a constant to pixel values of an image.
void AddC (const QVImage< uShort, 3 > &src, QVImage< uShort, 3 > &dest, uShort constant, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Adds a constant to pixel values of an image.
void AddC (const QVImage< sShort, 3 > &src, QVImage< sShort, 3 > &dest, sShort constant, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Adds a constant to pixel values of an image.
void AddC (const QVImage< sFloat, 3 > &src, QVImage< sFloat, 3 > &dest, sFloat constant, QPoint destROIOffset=QPoint(0, 0))
 Adds a constant to pixel values of an image.
void SubC (const QVImage< uChar > &src, QVImage< uChar > &dest, uChar constant, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Subtracts a constant from pixel values of an image.
void SubC (const QVImage< uShort > &src, QVImage< uShort > &dest, uShort constant, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Subtracts a constant from pixel values of an image.
void SubC (const QVImage< sShort > &src, QVImage< sShort > &dest, sShort constant, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Subtracts a constant from pixel values of an image.
void SubC (const QVImage< sFloat > &src, QVImage< sFloat > &dest, sFloat constant, QPoint destROIOffset=QPoint(0, 0))
 Subtracts a constant from pixel values of an image.
void SubC (const QVImage< uChar, 3 > &src, QVImage< uChar, 3 > &dest, uChar constant, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Adds a constant to pixel values of an image.
void SubC (const QVImage< uShort, 3 > &src, QVImage< uShort, 3 > &dest, uShort constant, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Adds a constant to pixel values of an image.
void SubC (const QVImage< sShort, 3 > &src, QVImage< sShort, 3 > &dest, sShort constant, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Adds a constant to pixel values of an image.
void SubC (const QVImage< sFloat, 3 > &src, QVImage< sFloat, 3 > &dest, sFloat constant, QPoint destROIOffset=QPoint(0, 0))
 Adds a constant to pixel values of an image.
void DivC (const QVImage< uChar > &src, QVImage< uChar > &dest, uChar constant, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Divides pixel values of an image by a constant.
void DivC (const QVImage< uShort > &src, QVImage< uShort > &dest, uShort constant, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Divides pixel values of an image by a constant.
void DivC (const QVImage< sShort > &src, QVImage< sShort > &dest, sShort constant, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Divides pixel values of an image by a constant.
void DivC (const QVImage< sFloat > &src, QVImage< sFloat > &dest, sFloat constant, QPoint destROIOffset=QPoint(0, 0))
 Divides pixel values of an image by a constant.
void DivC (const QVImage< uChar, 3 > &src, QVImage< uChar, 3 > &dest, uChar constant, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Adds a constant to pixel values of an image.
void DivC (const QVImage< uShort, 3 > &src, QVImage< uShort, 3 > &dest, uShort constant, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Adds a constant to pixel values of an image.
void DivC (const QVImage< sShort, 3 > &src, QVImage< sShort, 3 > &dest, sShort constant, int scale=1, QPoint destROIOffset=QPoint(0, 0))
 Adds a constant to pixel values of an image.
void DivC (const QVImage< sFloat, 3 > &src, QVImage< sFloat, 3 > &dest, sFloat constant, QPoint destROIOffset=QPoint(0, 0))
 Adds a constant to pixel values of an image.
void Sum (const QVImage< uChar > &src, sDouble &value)
 Computes the sum of image pixel values.
void Sum (const QVImage< sShort > &src, sDouble &value)
 Computes the sum of image pixel values.
void Sum (const QVImage< uChar, 3 > &src, sDouble &r, sDouble &g, sDouble &b)
 Computes the sum of image pixel values, by separate planes.
void Sum (const QVImage< sShort, 3 > &src, sDouble &r, sDouble &g, sDouble &b)
 Computes the sum of image pixel values, by separate planes.
void Integral (const QVImage< uChar, 1 > &src, QVImage< sInt, 1 > &dst, sInt val, QPoint destROIOffset=QPoint(0, 0))
 Computes the integral image.
void Integral (const QVImage< uChar, 1 > &src, QVImage< sFloat, 1 > &dst, sFloat val, QPoint destROIOffset=QPoint(0, 0))
 Computes the integral image.
void SqrIntegral (const QVImage< uChar, 1 > &src, QVImage< sFloat, 1 > &dst1, QVImageBuffer< sDouble, 1 > &dst2, sFloat val, sDouble valSqr, QPoint destROIOffset=QPoint(0, 0))
 Computes the integral and integral squares images.
void RectStdDev (const QVImage< sFloat, 1 > &src1, const QVImageBuffer< sDouble, 1 > &src2, QVImage< sFloat, 1 > &dst, IppiRect rect, QPoint destROIOffset=QPoint(0, 0))
 Computes the standard deviation of the integral images.
void Mean (const QVImage< uChar > &src, sDouble &value, QPoint destROIOffset=QPoint(0, 0))
 Computes the mean of image pixel values.
void Mean (const QVImage< sShort > &src, sDouble &value, QPoint destROIOffset=QPoint(0, 0))
 Computes the mean of image pixel values.
void Mean (const QVImage< uChar, 3 > &src, sDouble &r, sDouble &g, sDouble &b, QPoint destROIOffset=QPoint(0, 0))
 Computes the mean of image pixel values, by separate planes.
void Mean (const QVImage< sShort, 3 > &src, sDouble &r, sDouble &g, sDouble &b, QPoint destROIOffset=QPoint(0, 0))
 Computes the mean of image pixel values, by separate planes.
void Max (const QVImage< uChar > &src, uChar &value)
 Computes the maximum of image pixel values.
void Max (const QVImage< sShort > &src, sShort &value)
 Computes the maximum of image pixel values.
void Max (const QVImage< sFloat > &src, sFloat &value)
 Computes the maximum of image pixel values.
void Max (const QVImage< uChar, 3 > &src, uChar &r, uChar &g, uChar &b)
 Computes the maximum of image pixel values, by separate planes.
void Max (const QVImage< sShort, 3 > &src, sShort &r, sShort &g, sShort &b)
 Computes the maximum of image pixel values, by separate planes.
void Min (const QVImage< uChar > &src, uChar &value)
 Computes the minimum of image pixel values.
void Min (const QVImage< sShort > &src, sShort &value)
 Computes the minimum of image pixel values.
void Min (const QVImage< sFloat > &src, sFloat &value)
 Computes the minimum of image pixel values.
void Min (const QVImage< uChar, 3 > &src, uChar &r, uChar &g, uChar &b)
 Computes the minimum of image pixel values, by separate planes.
void Min (const QVImage< sShort, 3 > &src, sShort &r, sShort &g, sShort &b)
 Computes the minimum of image pixel values, by separate planes.
void FilterMax (const QVImage< uChar > &src, QVImage< uChar > &dest, uInt colMaskSize, uInt rowMaskSize, QPoint destROIOffset=QPoint(0, 0))
 Applies the max filter to an image.
void FilterMax (const QVImage< sFloat > &src, QVImage< sFloat > &dest, uInt colMaskSize, uInt rowMaskSize, QPoint destROIOffset=QPoint(0, 0))
 Applies the max filter to an image.
void FilterMax (const QVImage< uShort > &src, QVImage< uShort > &dest, uInt colMaskSize, uInt rowMaskSize, QPoint destROIOffset=QPoint(0, 0))
 Applies the max filter to an image.
void FilterMin (const QVImage< uChar > &src, QVImage< uChar > &dest, uInt colMaskSize, uInt rowMaskSize, QPoint destROIOffset=QPoint(0, 0))
 Applies the min filter to an image.
void FilterMin (const QVImage< sFloat > &src, QVImage< sFloat > &dest, uInt colMaskSize, uInt rowMaskSize, QPoint destROIOffset=QPoint(0, 0))
 Applies the min filter to an image.
void FilterMin (const QVImage< sShort > &src, QVImage< sShort > &dest, uInt colMaskSize, uInt rowMaskSize, QPoint destROIOffset=QPoint(0, 0))
 Applies the min filter to an image.
void FilterBox (const QVImage< uChar > &src, QVImage< uChar > &dest, uInt colMaskRadius, uInt rowMaskRadius, QPoint destROIOffset=QPoint(0, 0))
 Blurs an image using a simple box filter.
void FilterBox (const QVImage< sFloat > &src, QVImage< sFloat > &dest, uInt colMaskRadius, uInt rowMaskRadius, QPoint destROIOffset=QPoint(0, 0))
 Blurs an image using a simple box filter.
void FilterGauss (const QVImage< uChar > &src, QVImage< uChar > &dest, uInt maskSize=3, QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a Gaussian kernel.
void FilterGauss (const QVImage< sFloat > &src, QVImage< sFloat > &dest, uInt maskSize=3, QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a Gaussian kernel.
void FilterGauss (const QVImage< uChar, 3 > &src, QVImage< uChar, 3 > &dest, uInt maskSize=3, QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a Gaussian kernel.
void FilterGauss (const QVImage< sFloat, 3 > &src, QVImage< sFloat, 3 > &dest, uInt maskSize=3, QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a Gaussian kernel.
void Filter (const QVImage< sFloat > &src, QVImage< sFloat > &dest, const QVMatrix kernel, const QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a general rectangular kernel.
void FilterColumn (const QVImage< sFloat > &src, QVImage< sFloat > &dest, const QVVector kernel, const QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a spatial kernel that consists of a single column.
void FilterRow (const QVImage< sFloat > &src, QVImage< sFloat > &dest, const QVVector kernel, const QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a spatial kernel that consists of a single row.
void FilterHipass (const QVImage< uChar > &src, QVImage< uChar > &dest, uInt maskSize=3, QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a high-pass filter.
void FilterHipass (const QVImage< sFloat > &src, QVImage< sFloat > &dest, uInt maskSize=3, QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a high-pass filter.
void FilterLowpass (const QVImage< uChar > &src, QVImage< uChar > &dest, uInt maskSize=3, QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a lowpass filter.
void FilterLowpass (const QVImage< sFloat > &src, QVImage< sFloat > &dest, uInt maskSize=3, QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a lowpass filter.
void FilterSharpen (const QVImage< uChar > &src, QVImage< uChar > &dest, QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a sharpening filter.
void FilterSharpen (const QVImage< sFloat > &src, QVImage< sFloat > &dest, QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a sharpening filter.
void FilterSobelHoriz (const QVImage< uChar > &src, QVImage< uChar > &dest, QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a horizontal Sobel kernel.
void FilterSobelHoriz (const QVImage< sShort > &src, QVImage< sShort > &dest, QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a horizontal Sobel kernel.
void FilterSobelHoriz (const QVImage< sFloat > &src, QVImage< sFloat > &dest, QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a horizontal Sobel kernel.
void FilterSobelVert (const QVImage< uChar > &src, QVImage< uChar > &dest, QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a vertical Sobel kernel.
void FilterSobelVert (const QVImage< sShort > &src, QVImage< sShort > &dest, QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a vertical Sobel kernel.
void FilterSobelVert (const QVImage< sFloat > &src, QVImage< sFloat > &dest, QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a vertical Sobel kernel.
void FilterSobelHorizMask (const QVImage< sFloat > &src, QVImage< sFloat > &dest, uInt maskSize=3, QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a horizontal Sobel kernel.
void FilterSobelVertMask (const QVImage< sFloat > &src, QVImage< sFloat > &dest, uInt maskSize=3, QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a vertical Sobel kernel.
void FilterSobelHorizBorder (const QVImage< uChar > &src, QVImage< sShort > &dest, QVImage< uChar > &buffer, uInt maskSize=3, QPoint destROIOffset=QPoint(0, 0))
 Applies horizontal Sobel filter with border.
void FilterSobelNegVertBorder (const QVImage< uChar > &src, QVImage< sShort > &dest, QVImage< uChar > &buffer, uInt maskSize=3, QPoint destROIOffset=QPoint(0, 0))
 Applies vertical Sobel filter with border.
void FilterMedian (const QVImage< uChar > &src, QVImage< uChar > &dest, uInt colMaskRadius=3, uInt rowMaskRadius=3, QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a median filter.
void FilterMedian (const QVImage< sShort > &src, QVImage< sShort > &dest, uInt colMaskRadius=3, uInt rowMaskRadius=3, QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a median filter.
void Resize (const QVImage< uChar > &src, QVImage< uChar > &dest, int interpolation=IPPI_INTER_LINEAR)
 Changes an image size.
void Resize (const QVImage< sFloat > &src, QVImage< sFloat > &dest, int interpolation=IPPI_INTER_LINEAR)
 Changes an image size.
void Resize (const QVImage< uShort > &src, QVImage< uShort > &dest, int interpolation=IPPI_INTER_LINEAR)
 Changes an image size.
void Resize (const QVImage< uChar, 3 > &src, QVImage< uChar, 3 > &dest, int interpolation=IPPI_INTER_LINEAR)
 Changes an image size.
void CannyGetSize (const QVGenericImage &src, QVImage< uChar > &buffer)
 Allocates size in a buffer image for temporary data for function Canny.
void FilterSobelHorizGetBufferSize (const QVGenericImage &src, QVImage< uChar > &buffer, uInt maskSize=3)
 Allocates size in a buffer image for temporary data for function FilterSobelHoriz.
void FilterSobelNegVertGetBufferSize (const QVGenericImage &src, QVImage< uChar > &buffer, uInt maskSize=3)
 Allocates size in a buffer image for temporary data for function FilterSobelNegVert.
void MinEigenValGetBufferSize (const QVGenericImage &src, QVImage< uChar > &buffer, uInt apertureSize=5, uInt avgWindow=5)
 Allocates size in a buffer image for temporary data for function MinEigenValGet.
void FloodFillGetSize (const QVGenericImage &src, QVImage< uChar > &buffer)
 Allocates size in a buffer image for temporary data for function family FloodFill.
void Canny (QVImage< sShort > &dX, QVImage< sShort > &dY, QVImage< uChar > &dest, QVImage< uChar > &buffer, double low=50.0, double high=150.0)
 Performs Canny algorithm for edge detection.
void Canny (QVImage< sFloat > &dX, QVImage< sFloat > &dY, QVImage< uChar > &dest, QVImage< uChar > &buffer, double low=50.0, double high=150.0, QPoint destROIOffset=QPoint(0, 0))
 Performs Canny algorithm for edge detection.
void MinEigenVal (const QVImage< uChar > &src, QVImage< sFloat > &dest, QVImage< uChar > &buffer, uInt apertureSize=3, uInt avgWindow=5, IppiKernelType kernel=ippKernelSobel, QPoint destROIOffset=QPoint(0, 0))
 Calculates the minimal eigen value of image blocks for corner detection.
void FastMarchingGetBufferSize (const QVGenericImage &image, QVImage< uChar > &buffer)
 Allocates size in a buffer image for temporary data for function FastMarching.
void FastMarching (const QVImage< uChar > &mask, QVImage< sFloat > &distances, int radius, QVImage< uChar > &buffer, QPoint destROIOffset=QPoint(0, 0))
 Calculates distance transform to closest zero pixel for all non-zero pixels of source image using fast marching method.
void Inpaint (const QVImage< uChar > &src, const QVImage< uChar > &mask, const QVImage< sFloat > &distances, QVImage< uChar > &dest, int radius=4, IppiInpaintFlag flag=IPP_INPAINT_TELEA, QPoint destROIOffset=QPoint(0, 0))
 Restores unknown image pixels.
void Inpaint (const QVImage< uChar, 3 > &src, const QVImage< uChar > &mask, const QVImage< sFloat > &distances, QVImage< uChar, 3 > &dest, int radius=4, IppiInpaintFlag flag=IPP_INPAINT_TELEA, QPoint destROIOffset=QPoint(0, 0))
 Overload for function Inpaint, for different channel number images.
QMap< sInt, int > HistogramRange (const QVImage< uChar, 1 > &src, QList< uChar > values)
 Calculates frequency histogram for a given set of values, for a QVImage.
QVector< int > HistogramRange (const QVImage< uChar, 1 > &src)
 Calculates frequency histogram for a given set of values, for a QVImage.
void FloodFillRange4Connected (QVImage< uChar > &img, QVImage< uChar > &buffer, uInt seedX, uInt seedY, uChar newVal, uChar minDelta, uChar maxDelta)
 Performs flood filling of pixels with values in the specified range in the connected area on an image.
void FloodFillGradient4Connected (QVImage< uChar > &img, QVImage< uChar > &buffer, uInt seedX, uInt seedY, uChar newVal, uChar minDelta, uChar maxDelta)
 Performs gradient flood filling of connected area on an image.
void FilterGaussBorder (const QVImage< sFloat, 1 > &src, QVImage< sFloat, 1 > &dest, QVImage< uChar > &buffer, sInt kernelSize, sFloat sigma, IppiBorderType borderType=ippBorderConst, sFloat borderValue=0.0, QPoint destROIOffset=QPoint(0, 0))
 Applies Gauss filter with border.
void FilterGaussGetBufferSize (const QVGenericImage &image, QVImage< uChar > &buffer, uInt kernelSize)
 Computes the size of the external buffer for the Gaussian filter with border.
void FindPeaks3x3 (const QVImage< sInt, 1 > &img, QVImage< uChar > &buffer, QList< QPoint > &points, sInt threshold, IppiNorm norm, uInt border, uInt maxPeakCount)
 Finds coordinates of peaks (maximums or minimums) with absolute value exceeding threshold value.
void FindPeaks3x3 (const QVImage< sFloat, 1 > &img, QVImage< uChar > &buffer, QList< QPoint > &points, sFloat threshold, IppiNorm norm, uInt border, uInt maxPeakCount)
 Finds coordinates of peaks (maximums or minimums) with absolute value exceeding threshold value.
void FindPeaks3x3GetBufferSize (const QVImage< sInt, 1 > &image, QVImage< uChar > &buffer)
 Computes the size of the working buffer for the peak search.
void FindPeaks3x3GetBufferSize (const QVImage< sFloat, 1 > &image, QVImage< uChar > &buffer)
 Computes the size of the working buffer for the peak search.
void FilterLaplace (const QVImage< uChar > &src, QVImage< uChar > &dest, uInt maskSize=3, QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a Laplacian kernel.
void FilterLaplace (const QVImage< sShort > &src, QVImage< sShort > &dest, uInt maskSize=3, QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a Laplacian kernel.
void FilterLaplace (const QVImage< sFloat > &src, QVImage< sFloat > &dest, uInt maskSize=3, QPoint destROIOffset=QPoint(0, 0))
 Filters an image using a Laplacian kernel.
void WarpPerspective (const QVImage< uChar > &src, QVImage< uChar > &dest, const QVMatrix &rectifyingHomography, int interpolation=IPPI_INTER_LINEAR, QPoint destROIOffset=QPoint(0, 0))
 Performs perspective warping of the source image using the given transform coefficients.
void WarpPerspective (const QVImage< uChar, 3 > &src, QVImage< uChar, 3 > &dest, const QVMatrix &rectifyingHomography, int interpolation=IPPI_INTER_LINEAR, QPoint destROIOffset=QPoint(0, 0))
 Performs perspective warping of the source image using the given transform coefficients.

Detailed Description

Comprehensive set of wrapper functions for Intel(R) Integrated Performance Primitives (IPP).

The package QVIPP contains direct wrapping functions that map direct functionality from the library Intel IPP. They are intended to have very easy use, simplified naming specifications and use of QVImage objects instead of pointers to image data buffer, to make qvipp a simple interface to the library from Intel.

Signature should be very homogeneous, and should also be related with the name of the function it wraps from the Intel IPP. Thus, for instance the Copy functions are actually wrappers for the functions ippCopy_* from the Intel library. IPP bit-depth function is related to input and output image bit-depth for every function of this package. You can check section Image bit-depth. to check correspondencies between QVImage bit-depth and the respective equivalent bit-depth type name in the IPP library.

Usage of the package

To use these functions you should include in your source the file qvipp.h:
#include <QVIPP>

futhermore, these functions are inside the namespace qvipp, so you should either specify the use of that namespace, like in the below code:

using qvipp;

[...]

Copy(imagen1, imagen2);

or you can call all of these functions using their namespace specificator:

Copy(imagen1, imagen2);

An example of usage: Median filtering

Continuing with the example program from the section The first program, we will adapt it to make it apply a median filter of size 15x15 over every input image from the video, and show it on a QVImageCanvas window.

To the code of the source example.cpp we will add the following header include line:

#include <QVIPP>

This will include all the headers for the functions of package IPP wrapper functions. Then we will change the content of the function iterate() from the class PlayerWorker for the following code:

void iterate()
        {
        QVImage<uChar,1> inputImage = getPropertyValue< QVImage<uChar,1> >("Input image");

        QVImage<uChar,1> outputImage(inputImage.getCols(), inputImage.getRows());

        FilterMedian(inputImage, outputImage, 15, 15);

        setPropertyValue< QVImage<uChar,1> >("Output image", outputImage); 
        }

When compiling and executing the program, it will show each frame of the video input in the image canvas, filtered with a median filter of size 15x15:

penguin_median_15x15.png

Regions of interest

The ROI of an image is stored in the class QVGenericImage as a QRect object. All of the functions in the IPP wrapper functions package, and many functions from the qvdta package take use of the ROI value in their operations. That means they only process the area of the source images contained in the ROI. An example code for this follows:

[...]

QVImage<uChar> sourceImage = tajMajal;
sourceimage.setROI(10,10,90,90);        // This specifies an anchor vector for destination image.

QVImage<uChar> destinationImage(200, 200);
Copy(sourceimage, destinationImage);

[...]

Figure below shows the result of aplying that code to a given picture. On the left is the source image, with the specified ROI depicted as a hollow rectangle. On the right is the destination image as it is left by the code. We see that the content of the ROI area has been copied to the top left corner of the destination image:

tajmajalcopyroi.png

When using functions that operate over an input image and store the result of their operations on an output image of bigger size, it could be convenient to indicate that not all of the pixels in the output image contain values derived from the input image. In other cases for some image functions, mainly filtering functions such as FilterGauss, FilterMedian, even if both input and output images have the same size not all of the pixels of the resulting image have values derived from the input image.

It is denoted by valid data to the set of pixels in the image returned or modified by a function, that depend on the input image (or images) of the function, or were modified by that function, and are considered to contain relevant data.

The main function of the ROI is not restricting manually the working area for image functions, but storing the area that contains valid data in the return image. Any function that returns an image should store in its ROI the rectangular area of valid data that it wrote on the image.

An example of why is useful to keep the ROI in the resulting images after operations follows:

[...]

QVImage<uChar> sourceImage = lena;
sourceImage.setROI(100, 110, 90, 40);   // This specifies an initial ROI for source image.

QVImage<uChar> temporaryImage(256, 256);
FilterGauss(sourceImage, temporaryImage, 5);

QVImage<uChar> destinationImage(256, 256);
FilterGauss(temporaryImage, destinationImage, 5);

[...]

You can see the results of aplying that code to an input image in the following figure:

lenagauss_5_5roi.png

On the left is the source image, with the starting ROI depicted as a hollow rectangle. On the right is the destination image as it is left by the code. In the middle is depicted the temporary image. We see that the function FilterGauss modifes an area of the resulting image that is 4 pixels smaller in width and height than the input image, if used a mask of size 5.

Storing the ROI between calls to that function, in the intermediate images, allows to aboid specifying the valid area size and location in the image for each call to the filtering function.

Destination ROI offset.

Many image filtering functions use an extra parameter named destination ROI offset. It is a pointer to the location at the output image of these functions where they should locate the resulting ROI. The following code ilustrates this:

[...]
tajMajal.setROI(10,10,90,90);           // This specifies an initial ROI for source image.

QVImage<uChar> destinationImage(200, 200);
destinationImage.setAnchor(60,30);              

// Third parameter specifies the location of the ROI in the destination image.
Copy(tajMajal, destinationImage, QVPoint(60,30));
[...]

The following picture depicts the result of using that code with the Taj Majal image from the previous examples:

tajmajalcopyroianchor.png

You can see that the output ROI of the destination image has the top left corner in the pixel pointed by the anchor. Not like the example in section Regions of interest, where the destination ROI started at the top left corner of the image. You can see that you should specify the anchor in the output image for the image function to make use of it.

Combining use of ROI and destination offset

When using multiple image input functions, generally their ROI's must have the same size, but it can be located anywhere in those images:

[...]
// lena is an image of size 256x256. tajMajal is an image of size 200x200.

lena.setROI(45,65,155,85);                      // This specifies an initial ROI for image sourceImage1.
tajMajal.setROI(30,20,155,85);                  // This specifies an initial ROI for image sourceImage2.
                                                // Both ROI's have a dimention of 155x85 pixels
QVImage<uChar> destinationImage(230,230);       // destinationImage is an image of size 230x230
destinationImage.setAnchor(10,20);              // This specifies an anchor vector for image destinationImage.

Add(lena, tajMajal, destinationImage);
[...]

The result of that code is ilustrated in the following picture:

tajmajallenacopyroianchor.png

In this case function Add gets the contents of the ROI's of both input images and writes in the output image, starting at the pixel pointed by the anchor of the output image, the mean of every two pixels in the ROI's of the input images (add function uses by default a factor of 0.5 for the sum of the pixels).

Warning:
The ROI is used by functions in the module IPP wrapper functions. Other image processing functions in the QVision and image pixel access methods described in section Pixel access. are not affected by ROI, unless it is said the contrary.

Function Documentation

void Abs ( const QVImage< sFloat > &  src,
QVImage< sFloat > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Computes absolute pixel values of a source image and places them into the destination image.

See also:
Not(const QVImage<sShort> &, QVImage<sShort> &)

void Abs ( const QVImage< sShort > &  src,
QVImage< sShort > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Computes absolute pixel values of a source image and places them into the destination image.

Parameters:
src source image.
dest destination image.

void AbsDiff ( const QVImage< sFloat > &  src1,
const QVImage< sFloat > &  src2,
QVImage< sFloat > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Calculates absolute difference between two images.

See also:
AbsDiff(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &)

void AbsDiff ( const QVImage< uChar > &  src1,
const QVImage< uChar > &  src2,
QVImage< uChar > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Calculates absolute difference between two images.

This function calculates the absolute pixel-wise difference between two images by the formula:

dest(x,y) = abs(src1(x,y) - src2(x,y)) 

Parameters:
src1 source image to use pixels as first operands in subtraction.
src2 source image to use pixels as second operands in subtraction.
dest destination image to hold result pixels of operation.

Referenced by FilterDoG().

void Add ( const QVImage< sFloat, 3 > &  src1,
const QVImage< sFloat, 3 > &  src2,
QVImage< sFloat, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds pixel values of two images.

See also:
Add(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Add ( const QVImage< sFloat > &  src1,
const QVImage< sFloat > &  src2,
QVImage< sFloat > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds pixel values of two images.

See also:
Add(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Add ( const QVImage< sShort, 3 > &  src1,
const QVImage< sShort, 3 > &  src2,
QVImage< sShort, 3 > &  dest,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds pixel values of two images.

See also:
Add(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Add ( const QVImage< sShort > &  src1,
const QVImage< sShort > &  src2,
QVImage< sShort > &  dest,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds pixel values of two images.

See also:
Add(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Add ( const QVImage< uShort, 3 > &  src1,
const QVImage< uShort, 3 > &  src2,
QVImage< uShort, 3 > &  dest,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds pixel values of two images.

See also:
Add(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Add ( const QVImage< uShort > &  src1,
const QVImage< uShort > &  src2,
QVImage< uShort > &  dest,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds pixel values of two images.

See also:
Add(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Add ( const QVImage< uChar, 3 > &  src1,
const QVImage< uChar, 3 > &  src2,
QVImage< uChar, 3 > &  dest,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds pixel values of two images.

See also:
Add(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Add ( const QVImage< uChar > &  src1,
const QVImage< uChar > &  src2,
QVImage< uChar > &  dest,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds pixel values of two images.

This function adds corresponding pixel values of two source image buffers and places the results in a destination buffer. Saturation and scaling is used for integer data (uChar, sShort, etc...).

Scaling is done by multiplying the output pixel values by 2-scale before the function returns. This helps retain either the output data range or its precision. Usually the scaling with a positive factor is performed by the shift operation. Then, the result is rounded off to the nearest integer number.

Parameters:
src1 source image to use pixels as first operands in add.
src2 source image to use pixels as second operands in add.
dest destination image to hold result pixels of add.
scale value to perform scaling of resulting pixel values, for integer bit depth.

void AddC ( const QVImage< sFloat, 3 > &  src,
QVImage< sFloat, 3 > &  dest,
sFloat  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds a constant to pixel values of an image.

See also:
AddC(const QVImage<uChar> &, QVImage<uChar> &, uChar, int scale)

void AddC ( const QVImage< sShort, 3 > &  src,
QVImage< sShort, 3 > &  dest,
sShort  constant,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds a constant to pixel values of an image.

See also:
AddC(const QVImage<uChar> &, QVImage<uChar> &, uChar, int scale)

void AddC ( const QVImage< uShort, 3 > &  src,
QVImage< uShort, 3 > &  dest,
uShort  constant,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds a constant to pixel values of an image.

See also:
AddC(const QVImage<uChar> &, QVImage<uChar> &, uChar, int scale)

void AddC ( const QVImage< uChar, 3 > &  src,
QVImage< uChar, 3 > &  dest,
uChar  constant,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds a constant to pixel values of an image.

See also:
AddC(const QVImage<uChar> &, QVImage<uChar> &, uChar, int scale)

void AddC ( const QVImage< sFloat > &  src,
QVImage< sFloat > &  dest,
sFloat  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds a constant to pixel values of an image.

See also:
AddC(const QVImage<uChar> &, QVImage<uChar> &, uChar, int scale)

void AddC ( const QVImage< sShort > &  src,
QVImage< sShort > &  dest,
sShort  constant,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds a constant to pixel values of an image.

See also:
AddC(const QVImage<uChar> &, QVImage<uChar> &, uChar, int scale)

void AddC ( const QVImage< uShort > &  src,
QVImage< uShort > &  dest,
uShort  constant,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds a constant to pixel values of an image.

See also:
AddC(const QVImage<uChar> &, QVImage<uChar> &, uChar, int scale)

void AddC ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
uChar  constant,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds a constant to pixel values of an image.

This function changes the image intensity by adding the value to image pixel values. Saturation and scaling is used for integer data (uChar, sShort, etc...).

Scaling is done by multiplying the output pixel values by 2-scale before the function returns. This helps retain either the output data range or its precision. Usually the scaling with a positive factor is performed by the shift operation. Then, the result is rounded off to the nearest integer number.

Parameters:
src source image to use pixels as first operands in add.
dest destination image to hold result pixels of add.
constant value to use as second operand in add.
scale value to perform scaling of resulting pixel values, for integer bit depth.

void AndC ( const QVImage< sInt, 3 > &  src,
QVImage< sInt, 3 > &  dest,
sInt  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs a bit-wise AND operation between each pixel of an image and a constant.

Parameters:
src source image to perform bit-wise AND operation on.
dest destination image to hold result of bit-wise operation.
constant value to perform bit-wise operation with.

void AndC ( const QVImage< sInt > &  src,
QVImage< sInt > &  dest,
sInt  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs a bit-wise AND operation between each pixel of an image and a constant.

Parameters:
src source image to perform bit-wise AND operation on.
dest destination image to hold result of bit-wise operation.
constant value to perform bit-wise operation with.

void AndC ( const QVImage< uShort, 3 > &  src,
QVImage< uShort, 3 > &  dest,
uShort  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs a bit-wise AND operation between each pixel of an image and a constant.

Parameters:
src source image to perform bit-wise AND operation on.
dest destination image to hold result of bit-wise operation.
constant value to perform bit-wise operation with.

void AndC ( const QVImage< uShort > &  src,
QVImage< uShort > &  dest,
uShort  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs a bit-wise AND operation between each pixel of an image and a constant.

Parameters:
src source image to perform bit-wise AND operation on.
dest destination image to hold result of bit-wise operation.
constant value to perform bit-wise operation with.

void AndC ( const QVImage< uChar, 3 > &  src,
QVImage< uChar, 3 > &  dest,
uChar  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs a bit-wise AND operation between each pixel of an image and a constant.

Parameters:
src source image to perform bit-wise AND operation on.
dest destination image to hold result of bit-wise operation.
constant value to perform bit-wise operation with.

void AndC ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
uChar  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs a bit-wise AND operation between each pixel of an image and a constant.

Parameters:
src source image to perform bit-wise AND operation on.
dest destination image to hold result of bit-wise operation.
constant value to perform bit-wise operation with.

void Canny ( QVImage< sFloat > &  dX,
QVImage< sFloat > &  dY,
QVImage< uChar > &  dest,
QVImage< uChar > &  buffer,
double  low = 50.0,
double  high = 150.0,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs Canny algorithm for edge detection.

See also:
Canny(QVImage<sShort> &, QVImage<sShort> &, QVImage<uChar> &, QVImage<uChar> &, double, double)

Definition at line 835 of file qvipp.cpp.

void Canny ( QVImage< sShort > &  dX,
QVImage< sShort > &  dY,
QVImage< uChar > &  dest,
QVImage< uChar > &  buffer,
double  low = 50.0,
double  high = 150.0 
)

Performs Canny algorithm for edge detection.

This function finds edges in the source image ROI and stores them into the output image dest using the Canny algorithm.

The function requires a temporary buffer image, that should have been initialized with CannyGetSize function.

Images dX and dY should be filtered images from the original, from which we desire to obtain the contours, using horizontal and vertical Sobel filters.

A code example of a full canny extractor, given a source image, is described in the code below:

        [...]

        QVImage<sFloat> imageFloat(cols, rows), dX(cols, rows), dY(cols, rows, QPoint destROIOffset = QPoint(0,0));
        QVImage<uChar>  canny(cols, rows), buffer;

        Convert(image, imageFloat, QPoint destROIOffset = QPoint(0,0));
        FilterSobelHorizMask(imageFloat,dY,3);
        FilterSobelVertMask(imageFloat,dX,3);
        CannyGetSize(canny, buffer);
        Canny(dX, dY, canny, buffer);

        [...]

Parameters:
dX source image x-derivative.
dY source image y-derivative.
dest output image of the detected edges.
buffer image to hold temporary data during function operations.
low lower threshold for edges detection.
high upper threshold for edges detection.
See also:
CannyGetSize

FilterSobelHoriz

FilterSobelVert

FilterSobelHorizBorder

FilterSobelNegVertBorder

void CannyGetSize ( const QVGenericImage src,
QVImage< uChar > &  buffer 
)

Allocates size in a buffer image for temporary data for function Canny.

This function should be applied to any QVImage<uChar> image to be used as a buffer image for function Canny. Initializes dimensions for that buffer image, appropriated for canny algorithm.

Parameters:
src source image to apply later Canny operator.
buffer buffer image to initialize for further operations.
See also:
Canny

Definition at line 814 of file qvipp.cpp.

void Compare ( const QVImage< sFloat, 3 > &  src1,
const QVImage< sFloat, 3 > &  src2,
QVImage< uChar > &  dest,
IppCmpOp  ippCmpOp = ippCmpEq,
QPoint  destROIOffset = QPoint(0, 0) 
)

Compares pixel values of two images using a specified compare operation.

See also:
void Compare(const QVImage<uChar> &, const QVImage<uChar> &src2, QVImage<uChar> &, IppCmpOp)

void Compare ( const QVImage< sShort, 3 > &  src1,
const QVImage< sShort, 3 > &  src2,
QVImage< uChar > &  dest,
IppCmpOp  ippCmpOp = ippCmpEq,
QPoint  destROIOffset = QPoint(0, 0) 
)

Compares pixel values of two images using a specified compare operation.

See also:
void Compare(const QVImage<uChar> &, const QVImage<uChar> &src2, QVImage<uChar> &, IppCmpOp)

void Compare ( const QVImage< uShort, 3 > &  src1,
const QVImage< uShort, 3 > &  src2,
QVImage< uChar > &  dest,
IppCmpOp  ippCmpOp = ippCmpEq,
QPoint  destROIOffset = QPoint(0, 0) 
)

Compares pixel values of two images using a specified compare operation.

See also:
void Compare(const QVImage<uChar> &, const QVImage<uChar> &src2, QVImage<uChar> &, IppCmpOp)

void Compare ( const QVImage< uChar, 3 > &  src1,
const QVImage< uChar, 3 > &  src2,
QVImage< uChar > &  dest,
IppCmpOp  ippCmpOp = ippCmpEq,
QPoint  destROIOffset = QPoint(0, 0) 
)

Compares pixel values of two images using a specified compare operation.

See also:
void Compare(const QVImage<uChar> &, const QVImage<uChar> &src2, QVImage<uChar> &, IppCmpOp)

void Compare ( const QVImage< sFloat > &  src1,
const QVImage< sFloat > &  src2,
QVImage< uChar > &  dest,
IppCmpOp  ippCmpOp = ippCmpEq,
QPoint  destROIOffset = QPoint(0, 0) 
)

Compares pixel values of two images using a specified compare operation.

See also:
void Compare(const QVImage<uChar> &, const QVImage<uChar> &src2, QVImage<uChar> &, IppCmpOp)

void Compare ( const QVImage< sShort > &  src1,
const QVImage< sShort > &  src2,
QVImage< uChar > &  dest,
IppCmpOp  ippCmpOp = ippCmpEq,
QPoint  destROIOffset = QPoint(0, 0) 
)

Compares pixel values of two images using a specified compare operation.

See also:
void Compare(const QVImage<uChar> &, const QVImage<uChar> &src2, QVImage<uChar> &, IppCmpOp)

void Compare ( const QVImage< uShort > &  src1,
const QVImage< uShort > &  src2,
QVImage< uChar > &  dest,
IppCmpOp  ippCmpOp = ippCmpEq,
QPoint  destROIOffset = QPoint(0, 0) 
)

Compares pixel values of two images using a specified compare operation.

See also:
void Compare(const QVImage<uChar> &, const QVImage<uChar> &src2, QVImage<uChar> &, IppCmpOp)

void Compare ( const QVImage< uChar > &  src1,
const QVImage< uChar > &  src2,
QVImage< uChar > &  dest,
IppCmpOp  ippCmpOp = ippCmpEq,
QPoint  destROIOffset = QPoint(0, 0) 
)

Compares pixel values of two images using a specified compare operation.

This function compares the corresponding pixels of ROI in two source images src1, src2 using the ippCmpOp compare operation, and writes the results to a 1-channel uChar image dest.

If the result of the compare is true, the corresponding output pixel is set to an IPP_MAX_8U value; otherwise, it is set to 0.

Parameters:
src1 first operand in comparison image.
src2 second operand in comparison image.
dest image to store comparison value pixels.
ippCmpOp Compare operation to be used for comparing the pixel values. Must be one of these enumerated values:
  • ippCmpLess, for less comparison
  • ippCmpLessEq, for less or equal comparison
  • ippCmpEq, for equal comparison
  • ippCmpGreaterEq, for greater or equal comparison
  • ippCmpGreater, for greater comparison

void CompareC ( const QVImage< sFloat > &  src,
QVImage< uChar > &  dest,
sFloat  constant,
IppCmpOp  ippCmpOp = ippCmpEq,
QPoint  destROIOffset = QPoint(0, 0) 
)

Compares pixel values of a source image to a given value using a specified compare operation.

See also:
CompareC(const QVImage<uChar> &, QVImage<uChar> &, uChar, IppCmpOp ippCmpOp)

void CompareC ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
uChar  constant,
IppCmpOp  ippCmpOp = ippCmpEq,
QPoint  destROIOffset = QPoint(0, 0) 
)

Compares pixel values of a source image to a given value using a specified compare operation.

This function compares pixels of the each channel of the source image ROI src to a given value specified for each channel using the ippCmpOp compare operation, and writes the results to a 1-channel Ipp8u image dest.

If the result of the compare is true, that is all pixels of all channels satisfy to the specified condition, then the corresponding output pixel is set to an IPP_MAX_8U value; otherwise, it is set to 0.

Parameters:
src image to compare pixel values.
dest image to store pixel comparison values.
constant value to compare each pixel value.
ippCmpOp Compare operation to be used for comparing the pixel values. Must be one of these enumerated values:
  • ippCmpLess, for less comparison
  • ippCmpLessEq, for less or equal comparison
  • ippCmpEq, for equal comparison
  • ippCmpGreaterEq, for greater or equal comparison
  • ippCmpGreater, for greater comparison

void Convert ( const QVImage< sFloat, 3 > &  src,
QVImage< sShort, 3 > &  dest,
IppRoundMode  roundMode = ippRndNear,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from a floating point bit depth to a integer bit depth, using a given round mode.

See also:
Convert(const QVImage<sFloat, 1> &, QVImage<uChar, 1> &, IppRoundMode)

void Convert ( const QVImage< sFloat, 3 > &  src,
QVImage< uShort, 3 > &  dest,
IppRoundMode  roundMode = ippRndNear,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from a floating point bit depth to a integer bit depth, using a given round mode.

See also:
Convert(const QVImage<sFloat, 1> &, QVImage<uChar, 1> &, IppRoundMode)

void Convert ( const QVImage< sFloat, 3 > &  src,
QVImage< uChar, 3 > &  dest,
IppRoundMode  roundMode = ippRndNear,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from a floating point bit depth to a integer bit depth, using a given round mode.

See also:
Convert(const QVImage<sFloat, 1> &, QVImage<uChar, 1> &, IppRoundMode)

void Convert ( const QVImage< sFloat, 1 > &  src,
QVImage< sShort, 1 > &  dest,
IppRoundMode  roundMode = ippRndNear,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from a floating point bit depth to a integer bit depth, using a given round mode.

See also:
Convert(const QVImage<sFloat, 1> &, QVImage<uChar, 1> &, IppRoundMode)

void Convert ( const QVImage< sFloat, 1 > &  src,
QVImage< uShort, 1 > &  dest,
IppRoundMode  roundMode = ippRndNear,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from a floating point bit depth to a integer bit depth, using a given round mode.

See also:
Convert(const QVImage<sFloat, 1> &, QVImage<uChar, 1> &, IppRoundMode)

void Convert ( const QVImage< sFloat, 1 > &  src,
QVImage< uChar, 1 > &  dest,
IppRoundMode  roundMode = ippRndNear,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from a floating point bit depth to a integer bit depth, using a given round mode.

This function converts pixel values in the source image ROI pSrc to a different bit depth and writes them to the destination image ROI pDst. No scaling is done.

Rounding defined by roundMode is performed, and the result is saturated to the destination data type range.

Parameters:
src image to convert bit depth.
dest image to store resulting bit depth image conversion.
roundMode specified round mode. Possible values for the enumeration are:
  • ippRndZero. Specifies that floating-point values must be truncated toward zero.
  • ippRndNear. Specifies that floating-point values must be rounded to the nearest integer.

void Convert ( const QVImage< sInt, 3 > &  src,
QVImage< uChar, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from one bit depth to another.

See also:
Convert(const QVImage<uChar, 1> &, QVImage<uShort, 1> &)

void Convert ( const QVImage< sShort, 3 > &  src,
QVImage< sFloat, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from one bit depth to another.

See also:
Convert(const QVImage<uChar, 1> &, QVImage<uShort, 1> &)

void Convert ( const QVImage< sShort, 3 > &  src,
QVImage< sInt, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from one bit depth to another.

See also:
Convert(const QVImage<uChar, 1> &, QVImage<uShort, 1> &)

void Convert ( const QVImage< sShort, 3 > &  src,
QVImage< uChar, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from one bit depth to another.

See also:
Convert(const QVImage<uChar, 1> &, QVImage<uShort, 1> &)

void Convert ( const QVImage< uShort, 3 > &  src,
QVImage< sFloat, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from one bit depth to another.

See also:
Convert(const QVImage<uChar, 1> &, QVImage<uShort, 1> &)

void Convert ( const QVImage< uShort, 3 > &  src,
QVImage< sInt, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from one bit depth to another.

See also:
Convert(const QVImage<uChar, 1> &, QVImage<uShort, 1> &)

void Convert ( const QVImage< uShort, 3 > &  src,
QVImage< uChar, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from one bit depth to another.

See also:
Convert(const QVImage<uChar, 1> &, QVImage<uShort, 1> &)

void Convert ( const QVImage< uChar, 3 > &  src,
QVImage< sFloat, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from one bit depth to another.

See also:
Convert(const QVImage<uChar, 1> &, QVImage<uShort, 1> &)

void Convert ( const QVImage< uChar, 3 > &  src,
QVImage< sInt, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from one bit depth to another.

See also:
Convert(const QVImage<uChar, 1> &, QVImage<uShort, 1> &)

void Convert ( const QVImage< uChar, 3 > &  src,
QVImage< sShort, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from one bit depth to another.

See also:
Convert(const QVImage<uChar, 1> &, QVImage<uShort, 1> &)

void Convert ( const QVImage< uChar, 3 > &  src,
QVImage< uShort, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from one bit depth to another.

See also:
Convert(const QVImage<uChar, 1> &, QVImage<uShort, 1> &)

void Convert ( const QVImage< sInt, 1 > &  src,
QVImage< uChar, 1 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from one bit depth to another.

See also:
Convert(const QVImage<uChar, 1> &, QVImage<uShort, 1> &)

void Convert ( const QVImage< sShort, 1 > &  src,
QVImage< sFloat, 1 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from one bit depth to another.

See also:
Convert(const QVImage<uChar, 1> &, QVImage<uShort, 1> &)

void Convert ( const QVImage< sShort, 1 > &  src,
QVImage< sInt, 1 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from one bit depth to another.

See also:
Convert(const QVImage<uChar, 1> &, QVImage<uShort, 1> &)

void Convert ( const QVImage< sShort, 1 > &  src,
QVImage< uChar, 1 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from one bit depth to another.

See also:
Convert(const QVImage<uChar, 1> &, QVImage<uShort, 1> &)

void Convert ( const QVImage< uShort, 1 > &  src,
QVImage< sFloat, 1 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from one bit depth to another.

See also:
Convert(const QVImage<uChar, 1> &, QVImage<uShort, 1> &)

void Convert ( const QVImage< uShort, 1 > &  src,
QVImage< sInt, 1 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from one bit depth to another.

See also:
Convert(const QVImage<uChar, 1> &, QVImage<uShort, 1> &)

void Convert ( const QVImage< uShort, 1 > &  src,
QVImage< uChar, 1 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from one bit depth to another.

See also:
Convert(const QVImage<uChar, 1> &, QVImage<uShort, 1> &)

void Convert ( const QVImage< uChar, 1 > &  src,
QVImage< sFloat, 1 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from one bit depth to another.

See also:
Convert(const QVImage<uChar, 1> &, QVImage<uShort, 1> &)

void Convert ( const QVImage< uChar, 1 > &  src,
QVImage< sInt, 1 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from one bit depth to another.

See also:
Convert(const QVImage<uChar, 1> &, QVImage<uShort, 1> &)

void Convert ( const QVImage< uChar, 1 > &  src,
QVImage< sShort, 1 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from one bit depth to another.

See also:
Convert(const QVImage<uChar, 1> &, QVImage<uShort, 1> &)

void Convert ( const QVImage< uChar, 1 > &  src,
QVImage< uShort, 1 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts a image from one bit depth to another.

This function converts pixel values in the source image ROI pSrc to a different bit depth and writes them to the destination image ROI pDst. No scaling is done.

Parameters:
src image to convert bit depth.
dest image to store resulting bit depth image conversion.

void Copy ( const QVImage< sFloat, 3 > &  src,
QVImage< sFloat, 1 > &  dest,
uChar  channel,
QPoint  destROIOffset = QPoint(0, 0) 
)

Copy a selected channel from a 3-channel image to a 1-channel image.

See also:
Copy(const QVImage<uChar, 3> &, QVImage<uChar, 1> &, uChar)

void Copy ( const QVImage< sInt, 3 > &  src,
QVImage< sInt, 1 > &  dest,
uChar  channel,
QPoint  destROIOffset = QPoint(0, 0) 
)

Copy a selected channel from a 3-channel image to a 1-channel image.

See also:
Copy(const QVImage<uChar, 3> &, QVImage<uChar, 1> &, uChar)

void Copy ( const QVImage< sShort, 3 > &  src,
QVImage< sShort, 1 > &  dest,
uChar  channel,
QPoint  destROIOffset = QPoint(0, 0) 
)

Copy a selected channel from a 3-channel image to a 1-channel image.

See also:
Copy(const QVImage<uChar, 3> &, QVImage<uChar, 1> &, uChar)

void Copy ( const QVImage< uShort, 3 > &  src,
QVImage< uShort, 1 > &  dest,
uChar  channel,
QPoint  destROIOffset = QPoint(0, 0) 
)

Copy a selected channel from a 3-channel image to a 1-channel image.

See also:
Copy(const QVImage<uChar, 3> &, QVImage<uChar, 1> &, uChar)

void Copy ( const QVImage< uChar, 3 > &  src,
QVImage< uChar, 1 > &  dest,
uChar  channel,
QPoint  destROIOffset = QPoint(0, 0) 
)

Copy a selected channel from a 3-channel image to a 1-channel image.

This function converts an RGB image to gray scale.

Parameters:
src source image.
dest destination image.
channel number of channel to copy.

void Copy ( const QVImage< sFloat, 1 > &  src1,
const QVImage< sFloat, 1 > &  src2,
const QVImage< sFloat, 1 > &  src3,
QVImage< sFloat, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Composes color image from separate channel images.

See also:
Copy(const QVImage<uChar, 1> &, const QVImage<uChar, 1> &, const QVImage<uChar, 1> &, QVImage<uChar, 3> &)

void Copy ( const QVImage< sInt, 1 > &  src1,
const QVImage< sInt, 1 > &  src2,
const QVImage< sInt, 1 > &  src3,
QVImage< sInt, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Composes color image from separate channel images.

See also:
Copy(const QVImage<uChar, 1> &, const QVImage<uChar, 1> &, const QVImage<uChar, 1> &, QVImage<uChar, 3> &)

void Copy ( const QVImage< sShort, 1 > &  src1,
const QVImage< sShort, 1 > &  src2,
const QVImage< sShort, 1 > &  src3,
QVImage< sShort, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Composes color image from separate channel images.

See also:
Copy(const QVImage<uChar, 1> &, const QVImage<uChar, 1> &, const QVImage<uChar, 1> &, QVImage<uChar, 3> &)

void Copy ( const QVImage< uShort, 1 > &  src1,
const QVImage< uShort, 1 > &  src2,
const QVImage< uShort, 1 > &  src3,
QVImage< uShort, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Composes color image from separate channel images.

See also:
Copy(const QVImage<uChar, 1> &, const QVImage<uChar, 1> &, const QVImage<uChar, 1> &, QVImage<uChar, 3> &)

void Copy ( const QVImage< uChar, 1 > &  src1,
const QVImage< uChar, 1 > &  src2,
const QVImage< uChar, 1 > &  src3,
QVImage< uChar, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Composes color image from separate channel images.

This function copies data from a source 1-channel image ROI src, to each of the channels of the destination 3-channel image ROI dest.

Parameters:
src1 source image for first channel.
src2 source image for second channel.
src3 source image for third channel.
dest destination image.

void Copy ( const QVImage< sFloat, 1 > &  src,
QVImage< sFloat, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Copy a one-channel image to a multi-channel image.

See also:
Copy(const QVImage<uChar, 1> &, QVImage<uChar, 3> &)

void Copy ( const QVImage< sInt, 1 > &  src,
QVImage< sInt, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Copy a one-channel image to a multi-channel image.

See also:
Copy(const QVImage<uChar, 1> &, QVImage<uChar, 3> &)

void Copy ( const QVImage< sShort, 1 > &  src,
QVImage< sShort, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Copy a one-channel image to a multi-channel image.

See also:
Copy(const QVImage<uChar, 1> &, QVImage<uChar, 3> &)

void Copy ( const QVImage< uShort, 1 > &  src,
QVImage< uShort, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Copy a one-channel image to a multi-channel image.

See also:
Copy(const QVImage<uChar, 1> &, QVImage<uChar, 3> &)

void Copy ( const QVImage< uChar, 1 > &  src,
QVImage< uChar, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Copy a one-channel image to a multi-channel image.

This function copy data from a source 1-channel image ROI src, to each of the channels of the destination 3-channel image ROI dest.

Parameters:
src source image.
dest destination image.

void Copy ( const QVImage< sFloat, 3 > &  src,
QVImage< sFloat, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Copy pixel values between two images.

See also:
Copy(const QVImage<uChar, 1> &, QVImage<uChar, 1> &)

void Copy ( const QVImage< sInt, 3 > &  src,
QVImage< sInt, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Copy pixel values between two images.

See also:
Copy(const QVImage<uChar, 1> &, QVImage<uChar, 1> &)

void Copy ( const QVImage< sShort, 3 > &  src,
QVImage< sShort, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Copy pixel values between two images.

See also:
Copy(const QVImage<uChar, 1> &, QVImage<uChar, 1> &)

void Copy ( const QVImage< uShort, 3 > &  src,
QVImage< uShort, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Copy pixel values between two images.

See also:
Copy(const QVImage<uChar, 1> &, QVImage<uChar, 1> &)

void Copy ( const QVImage< uChar, 3 > &  src,
QVImage< uChar, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Copy pixel values between two images.

See also:
Copy(const QVImage<uChar, 1> &, QVImage<uChar, 1> &)

void Copy ( const QVImage< sFloat, 1 > &  src,
QVImage< sFloat, 1 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Copy pixel values between two images.

See also:
Copy(const QVImage<uChar, 1> &, QVImage<uChar, 1> &)

void Copy ( const QVImage< sInt, 1 > &  src,
QVImage< sInt, 1 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Copy pixel values between two images.

See also:
Copy(const QVImage<uChar, 1> &, QVImage<uChar, 1> &)

void Copy ( const QVImage< sShort, 1 > &  src,
QVImage< sShort, 1 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Copy pixel values between two images.

See also:
Copy(const QVImage<uChar, 1> &, QVImage<uChar, 1> &)

void Copy ( const QVImage< uShort, 1 > &  src,
QVImage< uShort, 1 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Copy pixel values between two images.

See also:
Copy(const QVImage<uChar, 1> &, QVImage<uChar, 1> &)

void Copy ( const QVImage< uChar, 1 > &  src,
QVImage< uChar, 1 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Copies pixel values between two images.

This function copies data from a source image ROI src to the destination image ROI dest.

Parameters:
src source image.
dest destination image.

void Div ( const QVImage< sFloat, 3 > &  src1,
const QVImage< sFloat, 3 > &  src2,
QVImage< sFloat, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Divides pixel values of an image by pixel values of another image.

See also:
Div(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Div ( const QVImage< sFloat > &  src1,
const QVImage< sFloat > &  src2,
QVImage< sFloat > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Divides pixel values of an image by pixel values of another image.

See also:
Div(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Div ( const QVImage< sShort, 3 > &  src1,
const QVImage< sShort, 3 > &  src2,
QVImage< sShort, 3 > &  dest,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Divides pixel values of an image by pixel values of another image.

See also:
Div(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Div ( const QVImage< sShort > &  src1,
const QVImage< sShort > &  src2,
QVImage< sShort > &  dest,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Divides pixel values of an image by pixel values of another image.

See also:
Div(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Div ( const QVImage< uShort, 3 > &  src1,
const QVImage< uShort, 3 > &  src2,
QVImage< uShort, 3 > &  dest,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Divides pixel values of an image by pixel values of another image.

See also:
Div(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Div ( const QVImage< uShort > &  src1,
const QVImage< uShort > &  src2,
QVImage< uShort > &  dest,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Divides pixel values of an image by pixel values of another image.

See also:
Div(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Div ( const QVImage< uChar, 3 > &  src1,
const QVImage< uChar, 3 > &  src2,
QVImage< uChar, 3 > &  dest,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Divides pixel values of an image by pixel values of another image.

See also:
Div(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Div ( const QVImage< uChar > &  src1,
const QVImage< uChar > &  src2,
QVImage< uChar > &  dest,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Divides pixel values of an image by pixel values of another image.

This function divides corresponding pixel values of two source image buffers and places the results in a destination buffer. Saturation and scaling is used for integer data (uChar, sShort, etc...).

Scaling is done by multiplying the output pixel values by 2-scale before the function returns. This helps retain either the output data range or its precision. Usually the scaling with a positive factor is performed by the shift operation. Then, the result is rounded off to the nearest integer number.

Parameters:
src1 source image to use pixels as dividends in division.
src2 source image to use pixels as divisors in division.
dest destination image to hold result pixels of division.
scale value to perform scaling of resulting pixel values, for integer bit depth.

void DivC ( const QVImage< sFloat, 3 > &  src,
QVImage< sFloat, 3 > &  dest,
sFloat  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds a constant to pixel values of an image.

See also:
AddC(const QVImage<uChar> &, QVImage<uChar> &, uChar, int scale)

void DivC ( const QVImage< sShort, 3 > &  src,
QVImage< sShort, 3 > &  dest,
sShort  constant,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds a constant to pixel values of an image.

See also:
AddC(const QVImage<uChar> &, QVImage<uChar> &, uChar, int scale)

void DivC ( const QVImage< uShort, 3 > &  src,
QVImage< uShort, 3 > &  dest,
uShort  constant,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds a constant to pixel values of an image.

See also:
AddC(const QVImage<uChar> &, QVImage<uChar> &, uChar, int scale)

void DivC ( const QVImage< uChar, 3 > &  src,
QVImage< uChar, 3 > &  dest,
uChar  constant,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds a constant to pixel values of an image.

See also:
AddC(const QVImage<uChar> &, QVImage<uChar> &, uChar, int scale)

void DivC ( const QVImage< sFloat > &  src,
QVImage< sFloat > &  dest,
sFloat  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Divides pixel values of an image by a constant.

See also:
DivC(const QVImage<uChar> &, QVImage<uChar> &, uChar, int)

void DivC ( const QVImage< sShort > &  src,
QVImage< sShort > &  dest,
sShort  constant,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Divides pixel values of an image by a constant.

See also:
DivC(const QVImage<uChar> &, QVImage<uChar> &, uChar, int)

void DivC ( const QVImage< uShort > &  src,
QVImage< uShort > &  dest,
uShort  constant,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Divides pixel values of an image by a constant.

See also:
DivC(const QVImage<uChar> &, QVImage<uChar> &, uChar, int)

void DivC ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
uChar  constant,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Divides pixel values of an image by a constant.

This function changes image intensity by dividing pixel values of an image buffer by the constant value. Saturation and scaling is used for integer data (uChar, sShort, etc...).

Scaling is done by multiplying the output pixel values by 2-scale before the function returns. This helps retain either the output data range or its precision. Usually the scaling with a positive factor is performed by the shift operation. Then, the result is rounded off to the nearest integer number.

Parameters:
src source image to use pixels as first operands in multiplication.
dest destination image to hold result pixels of multiplication.
constant value to use as second operand in multiplication.
scale value to perform scaling of resulting pixel values, for integer bit depth.

void FastMarching ( const QVImage< uChar > &  mask,
QVImage< sFloat > &  distances,
int  radius,
QVImage< uChar > &  buffer,
QPoint  destROIOffset = QPoint(0, 0) 
)

Calculates distance transform to closest zero pixel for all non-zero pixels of source image using fast marching method.

This function computes the distance from the closest zero pixel to each image pixel according to the Fast Marching Method (FMM). For further info, see:

A.Telea. An Image Inprinting Technique Based on the Fast Marching Method. Journal of Graphic Tools, vol.9, No.1. ACM Press, 2004.

Parameters:
mask source image to obtain distances to closest zero pixel.
distances image to hold distances to closest zero pixel.
radius Radius of the neighborhood of the marked area.
buffer image to hold temporary data during function operations.
See also:
FastMarchingGetBufferSize

Definition at line 871 of file qvipp.cpp.

void FastMarchingGetBufferSize ( const QVGenericImage image,
QVImage< uChar > &  buffer 
)

Allocates size in a buffer image for temporary data for function FastMarching.

This function should be applied to any QVImage<uChar> image to be used as a buffer image for function FastMarching. Initializes dimensions for that buffer image, appropriated for that algorithm.

Parameters:
image source image to apply Fast Marching algorithm.
buffer buffer image to initialize for further operations.
See also:
FastMarching

Definition at line 864 of file qvipp.cpp.

void Filter ( const QVImage< sFloat > &  src,
QVImage< sFloat > &  dest,
const QVMatrix  kernel,
const QPoint  destROIOffset = QPoint(0, 0) 
)

Filters an image using a general rectangular kernel.

This function applies a high-pass filter to an image ROI. This function uses the general square kernel defined in the matrix kernel to filter an image, using a convolution operation.

Parameters:
src source image to filter.
dest destination image to hold the resulting image after filtering.
kernel matrix containing filter kernel.

Note:
ojo, quizás haya que indicar en IPP_POINT(0,0), el último elemento de la matriz 'kernel', tal y como pasa en las funciones FilterColumn y FilterRow.

Definition at line 1003 of file qvipp.cpp.

void FilterBox ( const QVImage< sFloat > &  src,
QVImage< sFloat > &  dest,
uInt  colMaskRadius,
uInt  rowMaskRadius,
QPoint  destROIOffset = QPoint(0, 0) 
)

Blurs an image using a simple box filter.

See also:
FilterBox(const QVImage<uChar> &, QVImage<uChar> &, uInt, uInt)

void FilterBox ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
uInt  colMaskRadius,
uInt  rowMaskRadius,
QPoint  destROIOffset = QPoint(0, 0) 
)

Blurs an image using a simple box filter.

This function sets each pixel in the output image as the average of all the input image pixels in the rectangular neighborhood of size mask size given.

This has the effect of smoothing or blurring the input image.

Parameters:
src source image to filter.
dest destination image to hold the resulting image after filtering.
colMaskSize mask width.
rowMaskSize mask height.

void FilterColumn ( const QVImage< sFloat > &  src,
QVImage< sFloat > &  dest,
const QVVector  kernel,
const QPoint  destROIOffset 
)

Filters an image using a spatial kernel that consists of a single column.

This function uses the vertical column kernel contained in vector kernel to filter an image ROI.

Parameters:
src source image to filter.
dest destination image to hold the resulting image after filtering.
kernel vector containing the kernel to filter.

Definition at line 1027 of file qvipp.cpp.

void FilterGauss ( const QVImage< sFloat, 3 > &  src,
QVImage< sFloat, 3 > &  dest,
uInt  maskSize = 3,
QPoint  destROIOffset = QPoint(0, 0) 
)

Filters an image using a Gaussian kernel.

See also:
FilterGauss(const QVImage<uChar> &, QVImage<uChar> &, uInt)

void FilterGauss ( const QVImage< uChar, 3 > &  src,
QVImage< uChar, 3 > &  dest,
uInt  maskSize = 3,
QPoint  destROIOffset = QPoint(0, 0) 
)

Filters an image using a Gaussian kernel.

See also:
FilterGauss(const QVImage<uChar> &, QVImage<uChar> &, uInt)

void FilterGauss ( const QVImage< sFloat > &  src,
QVImage< sFloat > &  dest,
uInt  maskSize = 3,
QPoint  destROIOffset = QPoint(0, 0) 
)

Filters an image using a Gaussian kernel.

See also:
FilterGauss(const QVImage<uChar> &, QVImage<uChar> &, uInt)

void FilterGauss ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
uInt  maskSize = 3,
QPoint  destROIOffset = QPoint(0, 0) 
)

Filters an image using a Gaussian kernel.

This function applies a lowpass Gaussian filter to an image ROI. The corresponding kernel is the matrix of either 3x3 or 5x5 size. The 3x3 filter uses the kernel:

$ \left| \begin{array}{ccc} 1/16 & 2/16 & 1/16 \\ 2/16 & 4/16 & 2/16 \\ 1/16 & 2/16 & 1/16 \\ \end{array} \right| $

These filter coefficients correspond to a 2-dimensional Gaussian distribution with standard deviation 0.85.

The 5x5 filter uses the kernel:

$ \left| \begin{array}{ccccc} 2/571 & 7/571 & 12/571 & 7/571 & 2/571 \\ 7/571 & 31/571 & 52/571 & 31/571 & 7/571 \\ 12/571 & 52/571 & 127/571 & 52/571 & 12/571 \\ 7/571 & 31/571 & 52/571 & 31/571 & 7/571 \\ 2/571 & 7/571 & 12/571 & 7/571 & 2/571 \\ \end{array} \right| $

These filter coefficients correspond to a 2-dimensional Gaussian distribution with standard deviation 1.0.

Parameters:
src source image to filter.
dest destination image to hold the resulting image after filtering.
maskSize size of mask. Should be 3 (for mask of size 3x3) or 5 (for mask of size 5x5).

Referenced by FilterDoG().

void FilterGaussBorder ( const QVImage< sFloat, 1 > &  src,
QVImage< sFloat, 1 > &  dest,
QVImage< uChar > &  buffer,
sInt  kernelSize,
sFloat  sigma,
IppiBorderType  borderType = ippBorderConst,
sFloat  borderValue = 0.0,
QPoint  destROIOffset = QPoint(0, 0) 
)

Applies Gauss filter with border.

This function applies the Gaussian filter to the source image ROI pSrc. The kernel of this filter is the matrix of size $ kernelSize x kernelSize $ with the standard deviation $ sigma $. The values of the elements of the Gaussian kernel are calculated according to the formula:

\[ G(i,j) = e^{\displaystyle-\frac{\displaystyle(K/2-i)^2 + (K/2-j)^2}{\displaystyle2\sigma^2}} \]

and then are normalized. The function requires a working image buffer whose size should be computed by the function FilterGaussGetBufferSize beforehand.

Parameters:
src source image to apply filter
dest resulting image.
buffer buffer image initiated beforehand by the function FilterGaussGetBufferSize.
kernelSize specifies the size of the Gaussian kernel, must be odd and greater than or equal to 3.
sigma standard deviation of the Gaussian kernel.
borderType type of border. Following values are possible:
  • ippBorderConst. Values of all border pixels are set to constant.
  • ippBorderRepl. Replicated border is used.
  • ippBorderWrap. Wrapped border is used
  • ippBorderMirror. Mirrored border is used
  • ippBorderMirrorR. Mirrored border with replication is used
borderValue The constant value to assign to the pixels in the constant border (not applicable for other border’s type).
See also:
FilterGaussGetBufferSize

void FilterGaussGetBufferSize ( const QVGenericImage image,
QVImage< uChar > &  buffer,
uInt  kernelSize 
)

Computes the size of the external buffer for the Gaussian filter with border.

This function computes the size of the external buffer that is required for the filter function FilterGaussBorder. This buffer can be used to filter an image whose width and height are equal to or less than param QVGenericImage image, and the kernel size is equal to or less than kernelSize.

Parameters:
src source image to apply later filter.
buffer buffer image to initialize for further operations.
kernelSize Size of the Gaussian kernel, odd, greater than or equal to 3.
See also:
FilterGaussBorder

Definition at line 800 of file qvipp.cpp.

void FilterHipass ( const QVImage< sFloat > &  src,
QVImage< sFloat > &  dest,
uInt  maskSize = 3,
QPoint  destROIOffset = QPoint(0, 0) 
)

Filters an image using a high-pass filter.

See also:
FilterHipass(const QVImage<uChar> &, QVImage<uChar> &, uInt)

void FilterHipass ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
uInt  maskSize = 3,
QPoint  destROIOffset = QPoint(0, 0) 
)

Filters an image using a high-pass filter.

This function applies a high-pass filter to an image ROI. The corresponding kernel is the matrix of either 3x3 or 5x5 size with the following values:

$ \left| \begin{array}{ccc} -1 & -1 & -1 \\ -1 & +8 & -1 \\ -1 & -1 & -1 \\ \end{array} \right| $

for 3x3 size, or

$ \left| \begin{array}{ccccc} -1 & -1 & -1 & -1 & -1 \\ -1 & -1 & -1 & -1 & -1 \\ -1 & -1 & +24 & -1 & -1 \\ -1 & -1 & -1 & -1 & -1 \\ -1 & -1 & -1 & -1 & -1 \\ \end{array} \right| $

For 5x5 size. This filter attenuates low-frequency components and thus sharpens an image.

Parameters:
src source image to filter.
dest destination image to hold the resulting image after filtering.
maskSize size of mask. Should be 3 (for mask of size 3x3) or 5 (for mask of size 5x5).

void FilterLaplace ( const QVImage< sFloat > &  src,
QVImage< sFloat > &  dest,
uInt  maskSize = 3,
QPoint  destROIOffset = QPoint(0, 0) 
)

Filters an image using a Laplacian kernel.

See also:
FilterLaplace(const QVImage<uChar> &, QVImage<uChar> &, uInt)

void FilterLaplace ( const QVImage< sShort > &  src,
QVImage< sShort > &  dest,
uInt  maskSize = 3,
QPoint  destROIOffset = QPoint(0, 0) 
)

Filters an image using a Laplacian kernel.

See also:
FilterLaplace(const QVImage<uChar> &, QVImage<uChar> &, uInt)

void FilterLaplace ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
uInt  maskSize = 3,
QPoint  destROIOffset = QPoint(0, 0) 
)

Filters an image using a Laplacian kernel.

This function applies a highpass Laplacian filter to an image ROI. The corresponding kernel is the matrix of either 3x3 or 5x5 size with the following values: $ \left| \begin{array}{ccc} -1 & -1 & -1 \\ -1 & 8 & -1 \\ -1 & -1 & -1 \\ \end{array} \right| $

for 3x3 size, or

$ \left| \begin{array}{ccccc} -1 & -3 & -4 & -3 & -1 \\ -3 & 0 & 6 & 0 & -3 \\ -4 & 6 & 20 & 6 & -4 \\ -3 & 0 & 6 & 0 & -3 \\ -1 & -3 & -4 & -3 & -1 \\ \end{array} \right| $

For 5x5 size. This filter helps locate zero crossings in an image.

Parameters:
src source image to filter.
dest destination image to hold the resulting image after filtering.
maskSize size of mask. Should be 3 (for mask of size 3x3) or 5 (for mask of size 5x5).

void FilterLowpass ( const QVImage< sFloat > &  src,
QVImage< sFloat > &  dest,
uInt  maskSize = 3,
QPoint  destROIOffset = QPoint(0, 0) 
)

Filters an image using a lowpass filter.

See also:
FilterLowpass(const QVImage<uChar> &, QVImage<uChar> &, uInt)

void FilterLowpass ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
uInt  maskSize = 3,
QPoint  destROIOffset = QPoint(0, 0) 
)

Filters an image using a lowpass filter.

This filter blurs an image by averaging the pixel values over some neighborhood. It works similar to FilterBox function, but uses two fixed mask sizes: 3x3, or 5x5.

Parameters:
src source image to filter.
dest destination image to hold the resulting image after filtering.
maskSize size of mask. Should be 3 (for mask of size 3x3) or 5 (for mask of size 5x5).

void FilterMax ( const QVImage< uShort > &  src,
QVImage< uShort > &  dest,
uInt  colMaskSize,
uInt  rowMaskSize,
QPoint  destROIOffset = QPoint(0, 0) 
)

Applies the max filter to an image.

See also:
FilterMax(const QVImage<uShort> &, QVImage<uShort> &, uInt, uInt)

void FilterMax ( const QVImage< sFloat > &  src,
QVImage< sFloat > &  dest,
uInt  colMaskSize,
uInt  rowMaskSize,
QPoint  destROIOffset = QPoint(0, 0) 
)

Applies the max filter to an image.

See also:
FilterMax(const QVImage<sFloat> &, QVImage<sFloat> &, uInt, uInt)

void FilterMax ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
uInt  colMaskSize,
uInt  rowMaskSize,
QPoint  destROIOffset = QPoint(0, 0) 
)

Applies the max filter to an image.

This function sets each pixel in the destination image to the maximum value of all the source image pixel values in the neighborhood of mask size given.

This has the effect of increasing the contrast in the image.

Parameters:
src source image to filter.
dest destination image to hold the resulting image after filtering.
colMaskSize mask width.
rowMaskSize mask height.

void FilterMedian ( const QVImage< sShort > &  src,
QVImage< sShort > &  dest,
uInt  colMaskRadius = 3,
uInt  rowMaskRadius = 3,
QPoint  destROIOffset = QPoint(0, 0) 
)

Filters an image using a median filter.

See also:
FilterMedian(const QVImage<uChar> &, QVImage<uChar> &, uInt, uInt)

void FilterMedian ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
uInt  colMaskRadius = 3,
uInt  rowMaskRadius = 3,
QPoint  destROIOffset = QPoint(0, 0) 
)

Filters an image using a median filter.

This function sets each pixel in the output buffer as the median value of all the input pixel values taken in the neighborhood of the processed pixel.

This filter removes noise and does not cut out signal brightness drops, as an averaging filter does.

Parameters:
src source image to filter.
dest destination image to hold the resulting image after filtering.
colMaskSize mask width.
rowMaskSize mask height.

void FilterMin ( const QVImage< sShort > &  src,
QVImage< sShort > &  dest,
uInt  colMaskSize,
uInt  rowMaskSize,
QPoint  destROIOffset = QPoint(0, 0) 
)

Applies the min filter to an image.

See also:
FilterMin(const QVImage<sShort> &, QVImage<sShort> &, uInt, uInt)

void FilterMin ( const QVImage< sFloat > &  src,
QVImage< sFloat > &  dest,
uInt  colMaskSize,
uInt  rowMaskSize,
QPoint  destROIOffset = QPoint(0, 0) 
)

Applies the min filter to an image.

See also:
FilterMin(const QVImage<sFloat> &, QVImage<sFloat> &, uInt, uInt)

void FilterMin ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
uInt  colMaskSize,
uInt  rowMaskSize,
QPoint  destROIOffset = QPoint(0, 0) 
)

Applies the min filter to an image.

This function sets each pixel in the destination image to the minimum value of all the source image pixel values in the neighborhood of mask size given.

This has the effect of decreasing the contrast in the image.

Parameters:
src source image to filter.
dest destination image to hold the resulting image after filtering.
colMaskSize mask width.
rowMaskSize mask height.

void FilterRow ( const QVImage< sFloat > &  src,
QVImage< sFloat > &  dest,
const QVVector  kernel,
const QPoint  destROIOffset 
)

Filters an image using a spatial kernel that consists of a single row.

This function uses the vertical column kernel contained in vector kernel to filter an image ROI.

Parameters:
src source image to filter.
dest destination image to hold the resulting image after filtering.
kernel vector containing the kernel to filter.

Definition at line 1046 of file qvipp.cpp.

void FilterSharpen ( const QVImage< sFloat > &  src,
QVImage< sFloat > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Filters an image using a sharpening filter.

See also:
FilterSharpen(const QVImage<uChar> &, QVImage<uChar> &)

void FilterSharpen ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Filters an image using a sharpening filter.

This function applies a sharpening filter to an image ROI. The corresponding kernel is the matrix of 3x3 size with the following values:

$ \left| \begin{array}{ccc} -1/8 & -1/8 & -1/8 \\ -1/8 & 16/8 & -1/8 \\ -1/8 & -1/8 & -1/8 \\ \end{array} \right| $

This filter enhances high-frequency components and thus sharpens an image.

Parameters:
src source image to filter.
dest destination image to hold the resulting image after filtering.

void FilterSobelHoriz ( const QVImage< sFloat > &  src,
QVImage< sFloat > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Filters an image using a horizontal Sobel kernel.

See also:
FilterSobelHoriz(const QVImage<uChar> &, QVImage<uChar> &)

void FilterSobelHoriz ( const QVImage< sShort > &  src,
QVImage< sShort > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Filters an image using a horizontal Sobel kernel.

See also:
FilterSobelHoriz(const QVImage<uChar> &, QVImage<uChar> &)

void FilterSobelHoriz ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Filters an image using a horizontal Sobel kernel.

This function apply a horizontal Sobel operator to an image ROI.

This filter has the effect of both enhancing and smoothing horizontal edges of an image.

Bug:
this function is not working properly. It will be repaired, for now better use function FilterSobelHorizMask
Parameters:
src source image to filter.
dest destination image to hold the resulting image after filtering.

void FilterSobelHorizBorder ( const QVImage< uChar > &  src,
QVImage< sShort > &  dest,
QVImage< uChar > &  buffer,
uInt  maskSize = 3,
QPoint  destROIOffset = QPoint(0, 0) 
)

Applies horizontal Sobel filter with border.

This function is similar to FilterSobelHorizMask, but automatically creates a required border and define appropriate pixel values.

Function FilterSobelHorizGetBufferSize should be used to initialize sizes for a buffer QVImage<uChar> image, which will hold temporary data for the function operations.

Parameters:
src source image to filter.
dest destination image to hold the resulting image after filtering.
buffer buffer image to hold temporal data during function operation.
maskSize size of mask. Should be 3 (for mask of size 3x3) or 5 (for mask of size 5x5).
See also:
FilterSobelHorizGetBufferSize

void FilterSobelHorizGetBufferSize ( const QVGenericImage src,
QVImage< uChar > &  buffer,
uInt  maskSize = 3 
)

Allocates size in a buffer image for temporary data for function FilterSobelHoriz.

This function should be applied to any QVImage<uChar> image to be used as a buffer image for function FilterSobelHoriz. Initializes dimensions for that buffer image, appropriated for that algorithm.

Parameters:
src source image to apply later filter.
buffer buffer image to initialize for further operations.
maskSize size of mask. Should be 3 (for mask of size 3x3) or 5 (for mask of size 5x5).
See also:
FilterSobelHoriz

void FilterSobelHorizMask ( const QVImage< sFloat > &  src,
QVImage< sFloat > &  dest,
uInt  maskSize = 3,
QPoint  destROIOffset = QPoint(0, 0) 
)

Filters an image using a horizontal Sobel kernel.

This function apply a horizontal Sobel operator to an image ROI.

The appropriate kernel is the matrix of 3x3 size, or either 3x3 or 5x5 size in accordance with mask parameter of the corresponding function flavors. The kernels have the following values:

$ \left| \begin{array}{ccc} 1 & 2 & 1 \\ 0 & 0 & 0 \\ -1 & -2 & -1 \\ \end{array} \right| $

for 3x3 size, or

$ \left| \begin{array}{ccccc} 1 & 4 & 6 & 4 & 1 \\ 2 & 8 & 12 & 8 & 2 \\ 0 & 0 & 0 & 0 & 0 \\ -2 & -8 & -12 & -8 & -2 \\ -1 & -4 & -6 & -4 & -1 \\ \end{array} \right| $

For 5x5 size. This filter has the effect of both enhancing and smoothing horizontal edges of an image.

Parameters:
src source image to filter.
dest destination image to hold the resulting image after filtering.
maskSize size of mask. Should be 3 (for mask of size 3x3) or 5 (for mask of size 5x5).

Referenced by FilterHessianCornerResponseImage().

void FilterSobelNegVertBorder ( const QVImage< uChar > &  src,
QVImage< sShort > &  dest,
QVImage< uChar > &  buffer,
uInt  maskSize = 3,
QPoint  destROIOffset = QPoint(0, 0) 
)

Applies vertical Sobel filter with border.

This function is similar to FilterSobelVertMask, but uses negative values for the mask applied, and automatically create a required border and define appropriate pixel values.

Function FilterSobelNegVertGetBufferSize should be used to initialize sizes for a buffer QVImage<uChar> image, which will hold temporary data for the function operations.

Parameters:
src source image to filter.
dest destination image to hold the resulting image after filtering.
buffer buffer image to hold temporal data during function operation.
maskSize size of mask. Should be 3 (for mask of size 3x3) or 5 (for mask of size 5x5).
See also:
FilterSobelNegVertGetBufferSize

void FilterSobelNegVertGetBufferSize ( const QVGenericImage src,
QVImage< uChar > &  buffer,
uInt  maskSize = 3 
)

Allocates size in a buffer image for temporary data for function FilterSobelNegVert.

This function should be applied to any QVImage<uChar> image to be used as a buffer image for function FilterSobelNegVert. Initializes dimensions for that buffer image, appropriated for that algorithm.

Parameters:
src source image to apply later filter.
buffer buffer image to initialize for further operations.
maskSize size of mask. Should be 3 (for mask of size 3x3) or 5 (for mask of size 5x5).
See also:
FilterSobelNegVert

void FilterSobelVert ( const QVImage< sFloat > &  src,
QVImage< sFloat > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Filters an image using a vertical Sobel kernel.

See also:
FilterSobelVert(const QVImage<uChar> &, QVImage<uChar> &)

void FilterSobelVert ( const QVImage< sShort > &  src,
QVImage< sShort > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Filters an image using a vertical Sobel kernel.

See also:
FilterSobelVert(const QVImage<uChar> &, QVImage<uChar> &)

void FilterSobelVert ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Filters an image using a vertical Sobel kernel.

This function apply a vertical Sobel operator to an image ROI.

This filter has the effect of both enhancing and smoothing vertical edges of an image.

Warning: this function is not working properly. It will be repaired, for now better use function FilterSobelVertMask

Parameters:
src source image to filter.
dest destination image to hold the resulting image after filtering.

void FilterSobelVertMask ( const QVImage< sFloat > &  src,
QVImage< sFloat > &  dest,
uInt  maskSize = 3,
QPoint  destROIOffset = QPoint(0, 0) 
)

Filters an image using a vertical Sobel kernel.

This function apply a vertical Sobel operator to an image ROI. The appropriate kernel is the matrix of 3x3 size, or either 3x3 or 5x5 size in accordance with mask parameter of the corresponding function flavors. The kernels have the following values:

$ \left| \begin{array}{ccc} -1 & 0 & 1 \\ -2 & 0 & 2 \\ -1 & 0 & 1 \\ \end{array} \right| $

for 3x3 size, or

$ \left| \begin{array}{ccccc} -1 & -2 & 0 & 2 & 1 \\ -4 & -8 & 0 & 8 & 4 \\ -6 & -12 & 0 & 12 & 6 \\ -4 & -8 & 0 & 8 & 4 \\ -1 & -2 & 0 & 2 & 1 \\ \end{array} \right| $

For 5x5 size. This filter has the effect of both enhancing and smoothing vertical edges of an image.

Parameters:
src source image to filter.
dest destination image to hold the resulting image after filtering.
maskSize size of mask. Should be 3 (for mask of size 3x3) or 5 (for mask of size 5x5).

Referenced by FilterHessianCornerResponseImage().

void FindPeaks3x3 ( const QVImage< sFloat, 1 > &  img,
QVImage< uChar > &  buffer,
QList< QPoint > &  points,
sFloat  threshold,
IppiNorm  norm,
uInt  border,
uInt  maxPeakCount 
)

Finds coordinates of peaks (maximums or minimums) with absolute value exceeding threshold value.

See also:
FindPeaks3x3(const QVImage<sInt, 1> &, QVImage<uChar> &, QList<QPoint> &, sInt, IppiNorm, uInt, uInt)

void FindPeaks3x3 ( const QVImage< sInt, 1 > &  img,
QVImage< uChar > &  buffer,
QList< QPoint > &  points,
sInt  threshold,
IppiNorm  norm,
uInt  border,
uInt  maxPeakCount 
)

Finds coordinates of peaks (maximums or minimums) with absolute value exceeding threshold value.

This function detects local maximum pixels in the source image, and stores their coordinates in the points point list. The neighborhood O(i, j) for the search is defined by the parameter norm. The number of detected maximums is returned in pPeakCount[0]. The operation is stopped The function requires a working image buffer whose size should be computed by the function FindPeaks3x3GetBufferSize beforehand.

Parameters:
img image to obtain from peaks.
buffer buffer image initiated beforehand by the function FindPeaks3x3GetBufferSize.
points QPoint list to store the resulting point list.
threshold threshold value.
norm Specifies type of the norm to form the mask for maximum search:
  • ippiNormInf. Infinity norm (8-connectivity, 3x3 rectangular mask);
  • ippiNormL1. L1 norm (4-connectivity, 3x3 cross mask).
border Border value, only pixel with distance from the edge of the image greater than border are processed.
maxPeakCount Maximum number of peaks.
See also:
FindPeaks3x3GetBufferSize

void FindPeaks3x3GetBufferSize ( const QVImage< sFloat, 1 > &  image,
QVImage< uChar > &  buffer 
)

Computes the size of the working buffer for the peak search.

See also:
FindPeaks3x3GetBufferSize(const QVImage<sInt,1> &, QVImage<uChar> &)

FindPeaks3x3

void FindPeaks3x3GetBufferSize ( const QVImage< sInt, 1 > &  image,
QVImage< uChar > &  buffer 
)

Computes the size of the working buffer for the peak search.

This function computes the size of the working image buffer required for the function FindPeaks3x3. The image buffer can be used to filter images with ROI width that is less than or equal to the image ROI width.

Parameters:
image source image to apply later filter.
buffer buffer image to initialize for further operations.
See also:
FindPeaks3x3(const QVImage<sInt, 1> &, QVImage<uChar> &, sInt, IppiNorm, uInt, QList<QPoint> &)

void FloodFillGetSize ( const QVGenericImage src,
QVImage< uChar > &  buffer 
)

Allocates size in a buffer image for temporary data for function family FloodFill.

This function should be applied to any QVImage<uChar> image to be used as a buffer image for function family FloodFill. Initializes dimensions for that buffer image, appropriated for that algorithm.

Parameters:
src source image to apply later flood fill function.
buffer buffer image to initialize for further operations.
See also:
FloodFillRange

Definition at line 964 of file qvipp.cpp.

void FloodFillGradient4Connected ( QVImage< uChar > &  img,
QVImage< uChar > &  buffer,
uInt  seedX,
uInt  seedY,
uChar  newVal,
uChar  minDelta,
uChar  maxDelta 
)

Performs gradient flood filling of connected area on an image.

This function performs flood filling of the group of connected pixels in the seed pixel neighborhoods whose pixel values v satisfies the following conditions:

$ v_0 – d_{lw} ≤ v ≤ v_0 + d_{up} $

where $ v_0 $ is the value of at least one of the current pixel neighbors, which already belongs to the refilled area, and $ d_{lw} $, dup are minDelta, maxDelta, respectively. Values of these pixel is set to the newVal value.

The function check 4-connected neighborhood of each pixel, i.e., side neighbors.

The function requires a temporary buffer whose size should be computed with the function FloodFillGetSize beforehand.

Parameters:
img image to flood fill.
buffer temporary buffer image previously initialized with FloodFillGetSize.
seedX column coordinate for the seed.
seedY row coordinate for the seed.
newVal Value to fill with for one-channel data.
minDelta Minimum difference between neighbor pixels for one-channel data.
maxDelta Maximum difference between neighbor pixels for one-channel data.
See also:
FloodFillGetSize

void FloodFillRange4Connected ( QVImage< uChar > &  img,
QVImage< uChar > &  buffer,
uInt  seedX,
uInt  seedY,
uChar  newVal,
uChar  minDelta,
uChar  maxDelta 
)

Performs flood filling of pixels with values in the specified range in the connected area on an image.

This function performs flood filling of the group of connected pixels in the seed pixel neighborhoods whose pixel values $ v_i $ satisfies the following condition:

$ v_i - minDelta \leq v_0 \leq v_i + maxDelta $

where $ v_0 $ is the pixel value of the seed point. Values of these pixel is set to the newVal value.

The function check 4-connected neighborhood of each pixel, i.e., side neighbors.

The function requires a temporary buffer whose size should be computed with the function FloodFillGetSize beforehand.

Parameters:
img image to flood fill.
buffer temporary buffer image previously initialized with FloodFillGetSize.
seedX column coordinate for the seed.
seedY row coordinate for the seed.
newVal Value to fill with for one-channel data.
minDelta Minimum difference between neighbor pixels for one-channel data.
maxDelta Maximum difference between neighbor pixels for one-channel data.
See also:
FloodFillGetSize

QVector<int> HistogramRange ( const QVImage< uChar, 1 > &  src  ) 

Calculates frequency histogram for a given set of values, for a QVImage.

This function computes the intensity histogram of an image in the ranges from 0 to 255.

Parameters:
src source image to obtain histogram values.
Returns:
a QVector list of 256 integer values, that maps pixel values, with their frequency of apperance in the image.

Definition at line 917 of file qvipp.cpp.

QMap<sInt, int> HistogramRange ( const QVImage< uChar, 1 > &  src,
QList< uChar >  values 
)

Calculates frequency histogram for a given set of values, for a QVImage.

This function computes the intensity histogram of an image in the ranges specified by the QList 'values'. Default value for this QList is empty list, indicating the set of integer which cover the group of valid values for uChar type (from 0 to 255).

Todo:
fill pLevels array with values from QList 'values'
Parameters:
src source image to obtain histogram values.
values list of QVImage data type values, to obtain frequency in histogram.
Returns:
a QMap variable, that maps pixel values, with their frequency of depicting in the image.

Definition at line 940 of file qvipp.cpp.

void Inpaint ( const QVImage< uChar, 3 > &  src,
const QVImage< uChar > &  mask,
const QVImage< sFloat > &  distances,
QVImage< uChar, 3 > &  dest,
int  radius = 4,
IppiInpaintFlag  flag = IPP_INPAINT_TELEA,
QPoint  destROIOffset = QPoint(0, 0) 
)

Overload for function Inpaint, for different channel number images.

See also:
Inpaint(const QVImage<uChar> &, const QVImage<uChar> &, const QVImage<sFloat> &, QVImage<uChar> &, int, IppiInpaintFlag)

Definition at line 899 of file qvipp.cpp.

void Inpaint ( const QVImage< uChar > &  src,
const QVImage< uChar > &  mask,
const QVImage< sFloat > &  distances,
QVImage< uChar > &  dest,
int  radius = 4,
IppiInpaintFlag  flag = IPP_INPAINT_TELEA,
QPoint  destROIOffset = QPoint(0, 0) 
)

Restores unknown image pixels.

This function reconstructs damaged part of the image, or removes a selected object. The image part to restore is defined by the mask image. Different distant transforms can be used, but the Fast Marching Method (implemented by FastMarching function) provides the best results. The order of pixel restoration is defined by the distance through the initialization the inpainting structure pState by the function ippiInpaintInitAlloc. Pixels are restored in according to the growing of their distance value. When a pixel is inpainted, it is treated as the known one. Two algorithms of direct inpainting are supported

A code example to show the use of this function is below:

 [...]
 
 QVImage<uChar,3> image;        // image to inpaint
 QVImage<uChar> mask;           // mask, indicating unknown pixels for image (0 known, >0 unknown)
 
 [...]
 
 QVImage<uChar> buffer;         // temporary buffer for FastMarching function
 QVImage<sFloat> distances(image.getCols(), image.getRows());   // image to hold distances to zero pixels
 QVImage<uChar,3> inpaint(image.getCols(),image.getRows());     // inpainted image from original
 
 FastMarchingGetBufferSize(mask, buffer);               // initiating buffer image for FastMarching function
 FastMarching(mask, distances, radius, buffer);         // calculating distances to zero pixels for image
 Inpaint(image, mask, distances, inpaint, radius);      // inpainting
 
 [...]

Parameters:
src source image to restore.
mask mask image. Values different from zero indicate unknown pixels.
distances image to hold distances to closest zero pixel. Must have been pre-calculated.
dest destination image to hold restored image.
radius Radius of the neighborhood of the marked area, used for inpainting.
flag indicates the algorithm for direct inpainting:
  • IPP_INPAINT_TELEA. Use weighted sum of approximations by known pixels in the neighborhood.
  • IPP_INPAINT_NS. Use Navier-Stokes equations.

Definition at line 881 of file qvipp.cpp.

void Integral ( const QVImage< uChar, 1 > &  src,
QVImage< sFloat, 1 > &  dst,
sFloat  val,
QPoint  destROIOffset = QPoint(0, 0) 
)

Computes the integral image.

Parameters:
src source image.
dst integral image.
val the value to add to dst image pixels (usually 0).

void Integral ( const QVImage< uChar, 1 > &  src,
QVImage< sInt, 1 > &  dst,
sInt  val,
QPoint  destROIOffset = QPoint(0, 0) 
)

Computes the integral image.

This function transforms a source image Src to the integral image Dst. Pixel values of the destination image Dst are computed using pixel values of the source image Src and the specified value val in accordance with the following formula: $ Dst[i,j]=val+ \sum_{k < i} \sum_{l < j} Src[k,l] $

Parameters:
src source image.
dst integral image.
val the value to add to dst image pixels (usually 0).

void Ln ( const QVImage< sFloat, 3 > &  src,
QVImage< sFloat, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Computes the natural logarithm of pixel values in a source image and writes the results into the destination image.

See also:
Ln(const QVImage<sFloat> &, QVImage<sFloat> &)

void Ln ( const QVImage< sFloat > &  src,
QVImage< sFloat > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Computes the natural logarithm of pixel values in a source image and writes the results into the destination image.

If a source pixel value is zero or negative, the function issues a corresponding warning and continues execution with the corresponding result value.

Parameters:
src source image to perform left shift on.
dest destination image to hold result of left shift.

void LShiftC ( const QVImage< sInt, 3 > &  src,
QVImage< sInt, 3 > &  dest,
sInt  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Shifts bits in pixel values to the left.

Parameters:
src source image to perform left shift on.
dest destination image to hold result of left shift.
constant value to perform left shift with.

void LShiftC ( const QVImage< sInt > &  src,
QVImage< sInt > &  dest,
sInt  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Shifts bits in pixel values to the left.

Parameters:
src source image to perform left shift on.
dest destination image to hold result of left shift.
constant value to perform left shift with.

void LShiftC ( const QVImage< uShort, 3 > &  src,
QVImage< uShort, 3 > &  dest,
uShort  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Shifts bits in pixel values to the left.

Parameters:
src source image to perform left shift on.
dest destination image to hold result of left shift.
constant value to perform left shift with.

void LShiftC ( const QVImage< uShort > &  src,
QVImage< uShort > &  dest,
uShort  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Shifts bits in pixel values to the left.

Parameters:
src source image to perform left shift on.
dest destination image to hold result of left shift.
constant value to perform left shift with.

void LShiftC ( const QVImage< uChar, 3 > &  src,
QVImage< uChar, 3 > &  dest,
uChar  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Shifts bits in pixel values to the left.

Parameters:
src source image to perform left shift on.
dest destination image to hold result of left shift.
constant value to perform left shift with.

void LShiftC ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
uChar  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Shifts bits in pixel values to the left.

Parameters:
src source image to perform left shift on.
dest destination image to hold result of left shift.
constant value to perform left shift with.

void Max ( const QVImage< sShort, 3 > &  src,
sShort &  r,
sShort &  g,
sShort &  b 
)

Computes the maximum of image pixel values, by separate planes.

See also:
Max(const QVImage<uChar,3> &, uChar &, uChar &, uChar &)

void Max ( const QVImage< uChar, 3 > &  src,
uChar &  r,
uChar &  g,
uChar &  b 
)

Computes the maximum of image pixel values, by separate planes.

Parameters:
src source image to compute pixel maximum.
red return value containing the maximum of the values of the pixels of the image for the first channel.
green return value containing the maximum of the values of the pixels of the image for the second channel.
blue return value containing the maximum of the values of the pixels of the image for the third channel.

void Max ( const QVImage< sFloat > &  src,
sFloat &  value 
)

Computes the maximum of image pixel values.

See also:
Max(const QVImage<uChar> &, uChar &)

void Max ( const QVImage< sShort > &  src,
sShort &  value 
)

Computes the maximum of image pixel values.

See also:
Max(const QVImage<uChar> &, uChar &)

void Max ( const QVImage< uChar > &  src,
uChar &  value 
)

Computes the maximum of image pixel values.

Parameters:
src source image to compute pixel maximum.
value return value containing the maximum of the values of the pixels of the image.

void Mean ( const QVImage< sShort, 3 > &  src,
sDouble &  r,
sDouble &  g,
sDouble &  b,
QPoint  destROIOffset = QPoint(0, 0) 
)

Computes the mean of image pixel values, by separate planes.

See also:
Mean(const QVImage<uChar,3> &, sDouble &, sDouble &, sDouble &)

void Mean ( const QVImage< uChar, 3 > &  src,
sDouble &  r,
sDouble &  g,
sDouble &  b,
QPoint  destROIOffset = QPoint(0, 0) 
)

Computes the mean of image pixel values, by separate planes.

Parameters:
src source image to compute pixel mean.
red return value containing the mean of the values of the pixels of the image for the first channel.
green return value containing the mean of the values of the pixels of the image for the second channel.
blue return value containing the mean of the values of the pixels of the image for the third channel.

void Mean ( const QVImage< sShort > &  src,
sDouble &  value,
QPoint  destROIOffset = QPoint(0, 0) 
)

Computes the mean of image pixel values.

See also:
Mean(const QVImage<uChar> &, sDouble &)

void Mean ( const QVImage< uChar > &  src,
sDouble &  value,
QPoint  destROIOffset = QPoint(0, 0) 
)

Computes the mean of image pixel values.

Parameters:
src source image to compute pixel mean.
value return value containing the mean of the values of the pixels of the image.

void Min ( const QVImage< sShort, 3 > &  src,
sShort &  r,
sShort &  g,
sShort &  b 
)

Computes the minimum of image pixel values, by separate planes.

See also:
Min(const QVImage<uChar,3> &, uChar &, uChar &, uChar &)

void Min ( const QVImage< uChar, 3 > &  src,
uChar &  r,
uChar &  g,
uChar &  b 
)

Computes the minimum of image pixel values, by separate planes.

Parameters:
src source image to compute pixel minimum.
red return value containing the minimum of the values of the pixels of the image for the first channel.
green return value containing the minimum of the values of the pixels of the image for the second channel.
blue return value containing the minimum of the values of the pixels of the image for the third channel.

void Min ( const QVImage< sFloat > &  src,
sFloat &  value 
)

Computes the minimum of image pixel values.

See also:
Min(const QVImage<uChar> &, uChar &)

void Min ( const QVImage< sShort > &  src,
sShort &  value 
)

Computes the minimum of image pixel values.

See also:
Min(const QVImage<uChar> &, uChar &)

void Min ( const QVImage< uChar > &  src,
uChar &  value 
)

Computes the minimum of image pixel values.

Parameters:
src source image to compute pixel minimum.
value return value containing the minimum of the values of the pixels of the image.

void MinEigenVal ( const QVImage< uChar > &  src,
QVImage< sFloat > &  dest,
QVImage< uChar > &  buffer,
uInt  apertureSize = 3,
uInt  avgWindow = 5,
IppiKernelType  kernel = ippKernelSobel,
QPoint  destROIOffset = QPoint(0, 0) 
)

Calculates the minimal eigen value of image blocks for corner detection.

This function takes a block around the pixel and computes the first derivatives Dx and Dy.

This operation is performed for every pixel of the image using either Sobel or Scharr kernel in accordance with the kernType parameter.

The size of the Sobel kernel may be specified the parameter apertureSize. If this parameter is set to 3 - the function used 3x3 kernel, if it set to 5 - the function uses 5x5 kernel.

Only 3x3 size is available for the Scharr kernel, therefore the parameter apertureSize must be set to 3 if the Scharr kernel is used.

Parameters:
src source image.
dest destination image to hold the minimal eigen values.
buffer image to hold temporary data during function operations.
apertureSize Size (in pixels) of the derivative operator used by the function, possible values are 3 or 5.
avgWindow Size of the blurring window in pixels, possible values are 3 (3x3 mask size) or 5 (5x5 mask size).
kernel Specifies the type of kernel used to compute derivatives, possible values are:
  • ippKernelSobel. Values for aperture size can be 3, or 5.
  • ippKernelScharr. Value for aperture size can only be 3.
See also:
MinEigenValGetBufferSize

Definition at line 849 of file qvipp.cpp.

void MinEigenValGetBufferSize ( const QVGenericImage src,
QVImage< uChar > &  buffer,
uInt  apertureSize = 5,
uInt  avgWindow = 5 
)

Allocates size in a buffer image for temporary data for function MinEigenValGet.

This function should be applied to any QVImage<uChar> image to be used as a buffer image for function MinEigenVal. Initializes dimensions for that buffer image, appropriated for that algorithm.

Parameters:
src source image to apply later MinEigenVal function.
buffer buffer image to initialize for further operations.
apertureSize Size (in pixels) of the derivative operator used by the function, possible values are 3 or 5.
avgWindow Size of the blurring window in pixels, possible values are 3 or 5.
See also:
MinEigenVal

Definition at line 807 of file qvipp.cpp.

void Mul ( const QVImage< sFloat, 3 > &  src1,
const QVImage< sFloat, 3 > &  src2,
QVImage< sFloat, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Multiplies pixel values of two images.

See also:
Mul(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Mul ( const QVImage< sFloat > &  src1,
const QVImage< sFloat > &  src2,
QVImage< sFloat > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Multiplies pixel values of two images.

See also:
Mul(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Mul ( const QVImage< sShort, 3 > &  src1,
const QVImage< sShort, 3 > &  src2,
QVImage< sShort, 3 > &  dest,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Multiplies pixel values of two images.

See also:
Mul(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Mul ( const QVImage< sShort > &  src1,
const QVImage< sShort > &  src2,
QVImage< sShort > &  dest,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Multiplies pixel values of two images.

See also:
Mul(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Mul ( const QVImage< uShort, 3 > &  src1,
const QVImage< uShort, 3 > &  src2,
QVImage< uShort, 3 > &  dest,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Multiplies pixel values of two images.

See also:
Mul(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Mul ( const QVImage< uShort > &  src1,
const QVImage< uShort > &  src2,
QVImage< uShort > &  dest,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Multiplies pixel values of two images.

See also:
Mul(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Mul ( const QVImage< uChar, 3 > &  src1,
const QVImage< uChar, 3 > &  src2,
QVImage< uChar, 3 > &  dest,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Multiplies pixel values of two images.

See also:
Mul(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Mul ( const QVImage< uChar > &  src1,
const QVImage< uChar > &  src2,
QVImage< uChar > &  dest,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Multiplies pixel values of two images.

This function multiplies corresponding pixel values of two source image buffers and places the results in a destination buffer. Saturation and scaling is used for integer data (uChar, sShort, etc...).

Scaling is done by multiplying the output pixel values by 2-scale before the function returns. This helps retain either the output data range or its precision. Usually the scaling with a positive factor is performed by the shift operation. Then, the result is rounded off to the nearest integer number.

Parameters:
src1 source image to use pixels as first operands in multiplication.
src2 source image to use pixels as second operands in multiplication.
dest destination image to hold result pixels of multiplication.
scale value to perform scaling of resulting pixel values, for integer bit depth.

Referenced by FilterHessianCornerResponseImage().

void MulC ( const QVImage< sFloat, 3 > &  src,
QVImage< sFloat, 3 > &  dest,
sFloat  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds a constant to pixel values of an image.

See also:
AddC(const QVImage<uChar> &, QVImage<uChar> &, uChar, int scale)

void MulC ( const QVImage< sShort, 3 > &  src,
QVImage< sShort, 3 > &  dest,
sShort  constant,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds a constant to pixel values of an image.

See also:
AddC(const QVImage<uChar> &, QVImage<uChar> &, uChar, int scale)

void MulC ( const QVImage< uShort, 3 > &  src,
QVImage< uShort, 3 > &  dest,
uShort  constant,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds a constant to pixel values of an image.

See also:
AddC(const QVImage<uChar> &, QVImage<uChar> &, uChar, int scale)

void MulC ( const QVImage< uChar, 3 > &  src,
QVImage< uChar, 3 > &  dest,
uChar  constant,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds a constant to pixel values of an image.

See also:
AddC(const QVImage<uChar> &, QVImage<uChar> &, uChar, int scale)

void MulC ( const QVImage< sFloat > &  src,
QVImage< sFloat > &  dest,
sFloat  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Multiplies pixel values of an image by a constant.

See also:
MulC(const QVImage<uChar> &, QVImage<uChar> &, uChar constant, int)

void MulC ( const QVImage< sShort > &  src,
QVImage< sShort > &  dest,
sShort  constant,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Multiplies pixel values of an image by a constant.

See also:
MulC(const QVImage<uChar> &, QVImage<uChar> &, uChar constant, int)

void MulC ( const QVImage< uShort > &  src,
QVImage< uShort > &  dest,
uShort  constant,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Multiplies pixel values of an image by a constant.

See also:
MulC(const QVImage<uChar> &, QVImage<uChar> &, uChar constant, int)

void MulC ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
uChar  constant,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Multiplies pixel values of an image by a constant.

This function multiplies pixel values of an image by a constant value. Saturation and scaling is used for integer data (uChar, sShort, etc...).

Scaling is done by multiplying the output pixel values by 2-scale before the function returns. This helps retain either the output data range or its precision. Usually the scaling with a positive factor is performed by the shift operation. Then, the result is rounded off to the nearest integer number.

Parameters:
src source image to use pixels as first operands in multiplication.
dest destination image to hold result pixels of multiplication.
constant value to use as second operand in multiplication.
scale value to perform scaling of resulting pixel values, for integer bit depth.

void MulScale ( const QVImage< uChar, 3 > &  src1,
const QVImage< uChar, 3 > &  src2,
QVImage< uChar, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Multiplies pixel values of two images and scales the products.

See also:
MulScale(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &)

void MulScale ( const QVImage< uChar > &  src1,
const QVImage< uChar > &  src2,
QVImage< uChar > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Multiplies pixel values of two images and scales the products.

This function multiplies corresponding pixel values of two input buffers and scales the products using the following formula:

dest(i,j) = src1(i,j) * src2(i,j) / max_val 

where max_val is the maximum value of the pixel data range.

Parameters:
src1 source image to use pixels as first operands in multiplication.
src2 source image to use pixels as second operands in multiplication.
dest destination image to hold result pixels of multiplication.

void Not ( const QVImage< uChar, 3 > &  src,
QVImage< uChar, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs a bit-wise NOT operation on each pixel of an image.

See also:
Not(const QVImage<uChar> &, QVImage<uChar> &)

void Not ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs a bit-wise NOT operation on each pixel of an image.

Parameters:
src source image to perform bit-wise NOT operation on.
dest destination image to hold result of bit-wise operation.

void OrC ( const QVImage< sInt, 3 > &  src,
QVImage< sInt, 3 > &  dest,
sInt  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs a bit-wise inclusive OR operation between each pixel of an image and a constant.

Parameters:
src source image to perform bit-wise inclusive OR operation on.
dest destination image to hold result of bit-wise operation.
constant value to perform bit-wise operation with.

void OrC ( const QVImage< sInt > &  src,
QVImage< sInt > &  dest,
sInt  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs a bit-wise inclusive OR operation between each pixel of an image and a constant.

Parameters:
src source image to perform bit-wise inclusive OR operation on.
dest destination image to hold result of bit-wise operation.
constant value to perform bit-wise operation with.

void OrC ( const QVImage< uShort, 3 > &  src,
QVImage< uShort, 3 > &  dest,
uShort  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs a bit-wise inclusive OR operation between each pixel of an image and a constant.

Parameters:
src source image to perform bit-wise inclusive OR operation on.
dest destination image to hold result of bit-wise operation.
constant value to perform bit-wise operation with.

void OrC ( const QVImage< uShort > &  src,
QVImage< uShort > &  dest,
uShort  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs a bit-wise inclusive OR operation between each pixel of an image and a constant.

Parameters:
src source image to perform bit-wise inclusive OR operation on.
dest destination image to hold result of bit-wise operation.
constant value to perform bit-wise operation with.

void OrC ( const QVImage< uChar, 3 > &  src,
QVImage< uChar, 3 > &  dest,
uChar  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs a bit-wise inclusive OR operation between each pixel of an image and a constant.

Parameters:
src source image to perform bit-wise inclusive OR operation on.
dest destination image to hold result of bit-wise operation.
constant value to perform bit-wise operation with.

void OrC ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
uChar  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs a bit-wise inclusive OR operation between each pixel of an image and a constant.

Parameters:
src source image to perform bit-wise inclusive OR operation on.
dest destination image to hold result of bit-wise operation.
constant value to perform bit-wise operation with.

void RectStdDev ( const QVImage< sFloat, 1 > &  src1,
const QVImageBuffer< sDouble, 1 > &  src2,
QVImage< sFloat, 1 > &  dst,
IppiRect  rect,
QPoint  destROIOffset = QPoint(0, 0) 
)

Computes the standard deviation of the integral images.

This function computes std dev image from integral and integral of pixel squares representations, for the desired rect rectangle around each input image pixel.

Parameters:
src1 integral image.
src2 integral square image.
dst std dev (output) image.
val the value to add to dst1 image pixels (usually 0).
valSqr the value to add to dst2 image pixels (usually 0).

Definition at line 1077 of file qvipp.cpp.

void Resize ( const QVImage< uChar, 3 > &  src,
QVImage< uChar, 3 > &  dest,
int  interpolation = IPPI_INTER_LINEAR 
)

Changes an image size.

See also:
Resize(const QVImage<uChar> &, QVImage<uChar> &, int)

void Resize ( const QVImage< uShort > &  src,
QVImage< uShort > &  dest,
int  interpolation = IPPI_INTER_LINEAR 
)

Changes an image size.

See also:
Resize(const QVImage<uShort> &, QVImage<uShort> &, int)

void Resize ( const QVImage< sFloat > &  src,
QVImage< sFloat > &  dest,
int  interpolation = IPPI_INTER_LINEAR 
)

Changes an image size.

See also:
Resize(const QVImage<uChar> &, QVImage<uChar> &, int)

void Resize ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
int  interpolation = IPPI_INTER_LINEAR 
)

Changes an image size.

This function copies the content of the ROI in the source image, to the ROI of the destination image, adjusting it's original size to make it fit in the destination size It has the effect of resizing the original image, to fit the destination image, if both ROI's hold the whole of their respective images.

void RGBToGray ( const QVImage< sFloat, 3 > &  src,
QVImage< sFloat, 1 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts an RGB image to gray-scale using fixed transform coefficients.

See also:
RGBToGray(const QVImage<uChar, 3> &, QVImage<uChar, 1> &)

void RGBToGray ( const QVImage< sShort, 3 > &  src,
QVImage< sShort, 1 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts an RGB image to gray-scale using fixed transform coefficients.

See also:
RGBToGray(const QVImage<uChar, 3> &, QVImage<uChar, 1> &)

void RGBToGray ( const QVImage< uShort, 3 > &  src,
QVImage< uShort, 1 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts an RGB image to gray-scale using fixed transform coefficients.

See also:
RGBToGray(const QVImage<uChar, 3> &, QVImage<uChar, 1> &)

void RGBToGray ( const QVImage< uChar, 3 > &  src,
QVImage< uChar, 1 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Converts an RGB image to gray-scale using fixed transform coefficients.

This function converts an RGB image to gray scale (see Figure 6-18) using the following basic equation to compute luminance from nonlinear gamma-corrected red, green, and blue values:

Y = 0.299 * R + 0.587 * G + 0.114 * B 

Note that the transform coefficients conform to the standard for the NTSC red, green, and blue CRT phosphors.

Parameters:
src RGB image to convert to gray scale.
dest resulting gray-scale image.

void RShiftC ( const QVImage< sInt, 3 > &  src,
QVImage< sInt, 3 > &  dest,
sInt  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Shifts bits in pixel values to the right.

Parameters:
src source image to perform right shift on.
dest destination image to hold result of right shift.
constant value to perform right shift with.

void RShiftC ( const QVImage< sInt > &  src,
QVImage< sInt > &  dest,
sInt  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Shifts bits in pixel values to the right.

Parameters:
src source image to perform right shift on.
dest destination image to hold result of right shift.
constant value to perform right shift with.

void RShiftC ( const QVImage< uShort, 3 > &  src,
QVImage< uShort, 3 > &  dest,
uShort  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Shifts bits in pixel values to the right.

Parameters:
src source image to perform right shift on.
dest destination image to hold result of right shift.
constant value to perform right shift with.

void RShiftC ( const QVImage< uShort > &  src,
QVImage< uShort > &  dest,
uShort  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Shifts bits in pixel values to the right.

Parameters:
src source image to perform right shift on.
dest destination image to hold result of right shift.
constant value to perform right shift with.

void RShiftC ( const QVImage< uChar, 3 > &  src,
QVImage< uChar, 3 > &  dest,
uChar  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Shifts bits in pixel values to the right.

Parameters:
src source image to perform right shift on.
dest destination image to hold result of right shift.
constant value to perform right shift with.

void RShiftC ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
uChar  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Shifts bits in pixel values to the right.

Parameters:
src source image to perform right shift on.
dest destination image to hold result of right shift.
constant value to perform right shift with.

void Set ( QVImage< sFloat, 3 > &  img,
sFloat  red,
sFloat  green,
sFloat  blue 
)

Sets pixels of a 3-channel image ROI to a value respective constant value, one for each channel.

See also:
Set(QVImage<uChar, 3> &, uChar, uChar, uChar)

void Set ( QVImage< sInt, 3 > &  img,
sInt  red,
sInt  green,
sInt  blue 
)

Sets pixels of a 3-channel image ROI to a value respective constant value, one for each channel.

See also:
Set(QVImage<uChar, 3> &, uChar, uChar, uChar)

void Set ( QVImage< sShort, 3 > &  img,
sShort  red,
sShort  green,
sShort  blue 
)

Sets pixels of a 3-channel image ROI to a value respective constant value, one for each channel.

See also:
Set(QVImage<uChar, 3> &, uChar, uChar, uChar)

void Set ( QVImage< uShort, 3 > &  img,
uShort  red,
uShort  green,
uShort  blue 
)

Sets pixels of a 3-channel image ROI to a value respective constant value, one for each channel.

See also:
Set(QVImage<uChar, 3> &, uChar, uChar, uChar)

void Set ( QVImage< uChar, 3 > &  img,
uChar  red,
uChar  green,
uChar  blue 
)

Sets pixels of a 3-channel image ROI to a value respective constant value, one for each channel.

This function sets pixels in the destination 3-channel image ROI img to a constant value. Each channel can be set to a different constant value, with a different parameter value.

Parameters:
img destination image to set.
red value to set pixels in first channel of image ROI.
green value to set pixels in second channel of image ROI.
blue value to set pixels in third channel of image ROI.

void Set ( QVImage< sFloat > &  img,
sFloat  constant 
)

Sets pixels of an image ROI to a value.

See also:
Set(QVImage<uChar> &, uChar)

void Set ( QVImage< sInt > &  img,
sInt  constant 
)

Sets pixels of an image ROI to a value.

See also:
Set(QVImage<uChar> &, uChar)

void Set ( QVImage< sShort > &  img,
sShort  constant 
)

Sets pixels of an image ROI to a value.

See also:
Set(QVImage<uChar> &, uChar)

void Set ( QVImage< uShort > &  img,
uShort  constant 
)

Sets pixels of an image ROI to a value.

See also:
Set(QVImage<uChar> &, uChar)

void Set ( QVImage< uChar > &  img,
uChar  constant 
)

Sets pixels of an image ROI to a value.

This function sets pixels in the destination image ROI img to a constant value.

Parameters:
img destination image to set.
constant value to set pixels in image ROI.

Referenced by FilterLocalMax(), getConnectedSetBorderContoursThreshold(), GetMaximalResponsePoints1(), and GetMaximalResponsePoints1bis().

void Sqr ( const QVImage< sFloat, 1 > &  src,
QVImage< sFloat, 1 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Squares pixel values of an image and writes them into the destination image.

See also:
Sqr(const QVImage<sFloat> &, QVImage<sFloat> &)

void SqrIntegral ( const QVImage< uChar, 1 > &  src,
QVImage< sFloat, 1 > &  dst1,
QVImageBuffer< sDouble, 1 > &  dst2,
sFloat  val,
sDouble  valSqr,
QPoint  destROIOffset = QPoint(0, 0) 
)

Computes the integral and integral squares images.

This function transforms an image to integral and integral of pixel squares representations.

Parameters:
src source image.
dst1 integral image.
dst2 integral square image.
val the value to add to dst1 image pixels (usually 0).
valSqr the value to add to dst2 image pixels (usually 0).

Definition at line 1064 of file qvipp.cpp.

void Sub ( const QVImage< sFloat, 3 > &  src1,
const QVImage< sFloat, 3 > &  src2,
QVImage< sFloat, 3 > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Subtracts pixel values of two images.

See also:
Sub(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Sub ( const QVImage< sFloat > &  src1,
const QVImage< sFloat > &  src2,
QVImage< sFloat > &  dest,
QPoint  destROIOffset = QPoint(0, 0) 
)

Subtracts pixel values of two images.

See also:
Sub(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Sub ( const QVImage< sShort, 3 > &  src1,
const QVImage< sShort, 3 > &  src2,
QVImage< sShort, 3 > &  dest,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Subtracts pixel values of two images.

See also:
Sub(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Sub ( const QVImage< sShort > &  src1,
const QVImage< sShort > &  src2,
QVImage< sShort > &  dest,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Subtracts pixel values of two images.

See also:
Sub(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Sub ( const QVImage< uShort, 3 > &  src1,
const QVImage< uShort, 3 > &  src2,
QVImage< uShort, 3 > &  dest,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Subtracts pixel values of two images.

See also:
Sub(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Sub ( const QVImage< uShort > &  src1,
const QVImage< uShort > &  src2,
QVImage< uShort > &  dest,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Subtracts pixel values of two images.

See also:
Sub(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Sub ( const QVImage< uChar, 3 > &  src1,
const QVImage< uChar, 3 > &  src2,
QVImage< uChar, 3 > &  dest,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Subtracts pixel values of two images.

See also:
Sub(const QVImage<uChar> &, const QVImage<uChar> &, QVImage<uChar> &, int)

void Sub ( const QVImage< uChar > &  src1,
const QVImage< uChar > &  src2,
QVImage< uChar > &  dest,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Subtracts pixel values of two images.

This function substracts corresponding pixel values of two source image buffers and places the results in a destination buffer. Saturation and scaling is used for integer data (uChar, sShort, etc...).

Scaling is done by multiplying the output pixel values by 2-scale before the function returns. This helps retain either the output data range or its precision. Usually the scaling with a positive factor is performed by the shift operation. Then, the result is rounded off to the nearest integer number.

Parameters:
src1 source image to use pixels as first operands in subtraction.
src2 source image to use pixels as second operands in subtraction.
dest destination image to hold result pixels of subtraction.
scale value to perform scaling of resulting pixel values, for integer bit depth.

Referenced by FilterHessianCornerResponseImage().

void SubC ( const QVImage< sFloat, 3 > &  src,
QVImage< sFloat, 3 > &  dest,
sFloat  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds a constant to pixel values of an image.

See also:
AddC(const QVImage<uChar> &, QVImage<uChar> &, uChar, int scale)

void SubC ( const QVImage< sShort, 3 > &  src,
QVImage< sShort, 3 > &  dest,
sShort  constant,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds a constant to pixel values of an image.

See also:
AddC(const QVImage<uChar> &, QVImage<uChar> &, uChar, int scale)

void SubC ( const QVImage< uShort, 3 > &  src,
QVImage< uShort, 3 > &  dest,
uShort  constant,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds a constant to pixel values of an image.

See also:
AddC(const QVImage<uChar> &, QVImage<uChar> &, uChar, int scale)

void SubC ( const QVImage< uChar, 3 > &  src,
QVImage< uChar, 3 > &  dest,
uChar  constant,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Adds a constant to pixel values of an image.

See also:
AddC(const QVImage<uChar> &, QVImage<uChar> &, uChar, int scale)

void SubC ( const QVImage< sFloat > &  src,
QVImage< sFloat > &  dest,
sFloat  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Subtracts a constant from pixel values of an image.

See also:
void SubC(const QVImage<uChar> &, QVImage<uChar> &, uChar, int)

void SubC ( const QVImage< sShort > &  src,
QVImage< sShort > &  dest,
sShort  constant,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Subtracts a constant from pixel values of an image.

See also:
void SubC(const QVImage<uChar> &, QVImage<uChar> &, uChar, int)

void SubC ( const QVImage< uShort > &  src,
QVImage< uShort > &  dest,
uShort  constant,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Subtracts a constant from pixel values of an image.

See also:
void SubC(const QVImage<uChar> &, QVImage<uChar> &, uChar, int)

void SubC ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
uChar  constant,
int  scale = 1,
QPoint  destROIOffset = QPoint(0, 0) 
)

Subtracts a constant from pixel values of an image.

This function changes image intensity by subtracting the constant value from pixel values of an image buffer. Saturation and scaling is used for integer data (uChar, sShort, etc...).

Scaling is done by multiplying the output pixel values by 2-scale before the function returns. This helps retain either the output data range or its precision. Usually the scaling with a positive factor is performed by the shift operation. Then, the result is rounded off to the nearest integer number.

Parameters:
src source image to use pixels as first operands in subtraction.
dest destination image to hold result pixels of subtraction.
constant value to use as second operand in subtraction.
scale value to perform scaling of resulting pixel values, for integer bit depth.

void Sum ( const QVImage< sShort, 3 > &  src,
sDouble &  r,
sDouble &  g,
sDouble &  b 
)

Computes the sum of image pixel values, by separate planes.

See also:
Sum(const QVImage<uChar,3> &, sDouble &, sDouble &, sDouble &)

void Sum ( const QVImage< uChar, 3 > &  src,
sDouble &  r,
sDouble &  g,
sDouble &  b 
)

Computes the sum of image pixel values, by separate planes.

Parameters:
src source image to compute pixel sum.
red return value containing the sum of the values of the pixels of the image for the first channel.
green return value containing the sum of the values of the pixels of the image for the second channel.
blue return value containing the sum of the values of the pixels of the image for the third channel.

void Sum ( const QVImage< sShort > &  src,
sDouble &  value 
)

Computes the sum of image pixel values.

See also:
Sum(const QVImage<uChar> &, sDouble &)

void Sum ( const QVImage< uChar > &  src,
sDouble &  value 
)

Computes the sum of image pixel values.

Parameters:
src source image to compute pixel sum.
value return value containing the sum of the values of the pixels of the image.

void Threshold ( QVImage< sFloat > &  src_dest,
sFloat  constant,
IppCmpOp  ippCmpOp = ippCmpEq 
)

Performs inplace (dest=src) thresholding of pixel values in an image buffer.

See also:
Threshold(const QVImage<sFloat> &, QVImage<sFloat> &, sFloat, IppCmpOp ippCmpOp)

void Threshold ( QVImage< sShort > &  src_dest,
sShort  constant,
IppCmpOp  ippCmpOp = ippCmpEq 
)

Performs inplace (dest=src) thresholding of pixel values in an image buffer.

See also:
Threshold(const QVImage<sShort> &, QVImage<sShort> &, sShort, IppCmpOp ippCmpOp)

void Threshold ( QVImage< uChar > &  src_dest,
uChar  constant,
IppCmpOp  ippCmpOp = ippCmpEq 
)

Performs inplace (dest=src) thresholding of pixel values in an image buffer.

See also:
Threshold(const QVImage<uChar> &, QVImage<uChar> &, uChar, IppCmpOp ippCmpOp)

void Threshold ( const QVImage< sFloat > &  src,
QVImage< sFloat > &  dest,
sFloat  constant,
IppCmpOp  ippCmpOp = ippCmpEq,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs thresholding of pixel values in an image buffer.

See also:
Threshold(const QVImage<uChar> &, QVImage<uChar> &, uChar, IppCmpOp ippCmpOp)

void Threshold ( const QVImage< sShort > &  src,
QVImage< sShort > &  dest,
sShort  constant,
IppCmpOp  ippCmpOp = ippCmpEq,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs thresholding of pixel values in an image buffer.

See also:
Threshold(const QVImage<uChar> &, QVImage<uChar> &, uChar, IppCmpOp ippCmpOp)

void Threshold ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
uChar  constant,
IppCmpOp  ippCmpOp = ippCmpEq,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs thresholding of pixel values in an image buffer.

This function thresholds pixels in the source image src using the specified level threshold. Pixel values in the source image are compared to the threshold value using the ippCmpOp comparison operation.

If the result of the compare is true, the corresponding output pixel is set to the threshold value. Otherwise, it is set to the source pixel value.

Parameters:
src image to threshold.
dest image to store thresholded image.
constant value to compare each pixel value.
ippCmpOp Compare operation to be used for thresholding the pixel values. Must be one of these enumerated values:
  • ippCmpLess, for less comparison
  • ippCmpLessEq, for less or equal comparison
  • ippCmpEq, for equal comparison
  • ippCmpGreaterEq, for greater or equal comparison
  • ippCmpGreater, for greater comparison

void Threshold_LTValGTVal ( const QVImage< sFloat > &  src,
QVImage< sFloat > &  dest,
sFloat  thresholdLT,
sFloat  valueLT,
sFloat  thresholdGT,
sFloat  valueGT,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs double thresholding of pixel values in an image buffer.

See also:
Threshold_LTValGTVal(const QVImage<uChar> &src, QVImage<uChar> &dest, uChar thresholdLT, uChar valueLT, uChar thresholdGT, uChar valueGT, QPoint destROIOffset = QPoint(0,0));

void Threshold_LTValGTVal ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
uChar  thresholdLT,
uChar  valueLT,
uChar  thresholdGT,
uChar  valueGT,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs double thresholding of pixel values in an image buffer.

This function thresholds pixels in the source image pSrc using two specified levels thresholdLT and thresholdGT. Pixel values in the source image are compared to these levels. If the pixel value is less than thresholdLT, the corresponding output pixel is set to valueLT. If the pixel value is greater than thresholdGT, the output pixel is set to valueGT. Otherwise, it is set to the source pixel value. The value of thresholdLT should be less than or equal to thresholdGT.

Parameters:
src image to threshold.
dest image to store thresholded image.
thresholdLT lower value to compare each pixel value.
valueLT lower value to set if threshold condition is true.
thresholdGT higher value to compare each pixel value.
valueGT higher value to set if threshold condition is true.

void Threshold_Val ( QVImage< sFloat > &  src_dest,
sFloat  threshold,
sFloat  value,
IppCmpOp  ippCmpOp = ippCmpEq 
)

Performs inplace (dest=src) thresholding of pixel values in an image buffer. Pixels that satisfy the compare condition are set to a specified value.

See also:
Threshold_Val(const QVImage<sFloat> &, QVImage<sFloat> &, sFloat, IppCmpOp ippCmpOp)

void Threshold_Val ( QVImage< sShort > &  src_dest,
sShort  threshold,
sShort  value,
IppCmpOp  ippCmpOp = ippCmpEq 
)

Performs inplace (dest=src) thresholding of pixel values in an image buffer. Pixels that satisfy the compare condition are set to a specified value.

See also:
Threshold_Val(const QVImage<sShort> &, QVImage<sShort> &, sShort, IppCmpOp ippCmpOp)

void Threshold_Val ( QVImage< uChar > &  src_dest,
uChar  threshold,
uChar  value,
IppCmpOp  ippCmpOp = ippCmpEq 
)

Performs inplace (dest=src) thresholding of pixel values in an image buffer. Pixels that satisfy the compare condition are set to a specified value.

See also:
Threshold_Val(const QVImage<uChar> &, QVImage<uChar> &, uChar, IppCmpOp ippCmpOp)

void Threshold_Val ( const QVImage< sFloat > &  src,
QVImage< sFloat > &  dest,
sFloat  threshold,
sFloat  value,
IppCmpOp  ippCmpOp,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs thresholding of pixel values in an image buffer. Pixels that satisfy the compare condition are set to a specified value.

See also:
Threshold_Val(const QVImage<uChar> &, QVImage<uChar> &, uChar, uChar, IppCmpOp)

void Threshold_Val ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
uChar  threshold,
uChar  value,
IppCmpOp  ippCmpOp,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs thresholding of pixel values in an image buffer. Pixels that satisfy the compare condition are set to a specified value.

This function thresholds pixels in the source image src using the specified level threshold. Pixel values in the source image are compared to the threshold value using the ippCmpOp comparison operation. If the result of the compare is true, the corresponding output pixel is set to the specified value. Otherwise, it is set to the source pixel value.

Parameters:
src image to threshold.
dest image to store thresholded image.
threshold value to compare each pixel value.
value value to set if threshold condition is true.
ippCmpOp Compare operation to be used for thresholding the pixel values. Must be one of these enumerated values:
  • ippCmpLess, for less comparison
  • ippCmpLessEq, for less or equal comparison
  • ippCmpEq, for equal comparison
  • ippCmpGreaterEq, for greater or equal comparison
  • ippCmpGreater, for greater comparison

void WarpPerspective ( const QVImage< uChar, 3 > &  src,
QVImage< uChar, 3 > &  dest,
const QVMatrix rectifyingHomography,
int  interpolation = IPPI_INTER_LINEAR,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs perspective warping of the source image using the given transform coefficients.

See also:
WarpPerspective(const QVImage<uChar> &, QVImage<uChar> &, const QVMatrix &, int, QPoint)

void WarpPerspective ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
const QVMatrix rectifyingHomography,
int  interpolation = IPPI_INTER_LINEAR,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs perspective warping of the source image using the given transform coefficients.

Todo:
Document this function
Parameters:
src source image to wrap.
dest destination image to contain wrapped image.
rectifyingHomography homography matrix corresponding to the wrapping.
interpolation interpolation type. Selects the algorithm for interpolate pixel values. Possible values for this parameter are:
  • IPPI_INTER_NN. Nearest neighbor interpolation
  • IPPI_INTER_LINEAR. Linear interpolation
  • IPPI_INTER_CUBIC. Cubic interpolation

void XorC ( const QVImage< sInt, 3 > &  src,
QVImage< sInt, 3 > &  dest,
sInt  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs a bit-wise exclusive OR operation between each pixel of an image and a constant.

Parameters:
src source image to perform bit-wise exclusive OR operation on.
dest destination image to hold result of bit-wise operation.
constant value to perform bit-wise operation with.

void XorC ( const QVImage< sInt > &  src,
QVImage< sInt > &  dest,
sInt  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs a bit-wise exclusive OR operation between each pixel of an image and a constant.

Parameters:
src source image to perform bit-wise exclusive OR operation on.
dest destination image to hold result of bit-wise operation.
constant value to perform bit-wise operation with.

void XorC ( const QVImage< uShort, 3 > &  src,
QVImage< uShort, 3 > &  dest,
uShort  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs a bit-wise exclusive OR operation between each pixel of an image and a constant.

Parameters:
src source image to perform bit-wise exclusive OR operation on.
dest destination image to hold result of bit-wise operation.
constant value to perform bit-wise operation with.

void XorC ( const QVImage< uShort > &  src,
QVImage< uShort > &  dest,
uShort  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs a bit-wise exclusive OR operation between each pixel of an image and a constant.

Parameters:
src source image to perform bit-wise exclusive OR operation on.
dest destination image to hold result of bit-wise operation.
constant value to perform bit-wise operation with.

void XorC ( const QVImage< uChar, 3 > &  src,
QVImage< uChar, 3 > &  dest,
uChar  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs a bit-wise exclusive OR operation between each pixel of an image and a constant.

Parameters:
src source image to perform bit-wise exclusive OR operation on.
dest destination image to hold result of bit-wise operation.
constant value to perform bit-wise operation with.

void XorC ( const QVImage< uChar > &  src,
QVImage< uChar > &  dest,
uChar  constant,
QPoint  destROIOffset = QPoint(0, 0) 
)

Performs a bit-wise exclusive OR operation between each pixel of an image and a constant.

Parameters:
src source image to perform bit-wise exclusive OR operation on.
dest destination image to hold result of bit-wise operation.
constant value to perform bit-wise operation with.


Generated on Thu Jul 17 17:23:29 2008 for QVision by  doxygen 1.5.3