OpenCV
4.6.0dev
Open Source Computer Vision

Functions  
GMat  cv::gapi::bitwise_and (const GMat &src1, const GMat &src2) 
computes bitwise conjunction of the two matrixes (src1 & src2) Calculates the perelement bitwise logical conjunction of two matrices of the same size. More...  
GMat  cv::gapi::bitwise_and (const GMat &src1, const GScalar &src2) 
GMat  cv::gapi::bitwise_not (const GMat &src) 
Inverts every bit of an array. More...  
GMat  cv::gapi::bitwise_or (const GMat &src1, const GMat &src2) 
computes bitwise disjunction of the two matrixes (src1  src2) Calculates the perelement bitwise logical disjunction of two matrices of the same size. More...  
GMat  cv::gapi::bitwise_or (const GMat &src1, const GScalar &src2) 
GMat  cv::gapi::bitwise_xor (const GMat &src1, const GMat &src2) 
computes bitwise logical "exclusive or" of the two matrixes (src1 ^ src2) Calculates the perelement bitwise logical "exclusive or" of two matrices of the same size. More...  
GMat  cv::gapi::bitwise_xor (const GMat &src1, const GScalar &src2) 
GMat  cv::gapi::cmpEQ (const GMat &src1, const GMat &src2) 
Performs the perelement comparison of two matrices checking if elements from first matrix are equal to elements in second. More...  
GMat  cv::gapi::cmpEQ (const GMat &src1, const GScalar &src2) 
GMat  cv::gapi::cmpGE (const GMat &src1, const GMat &src2) 
Performs the perelement comparison of two matrices checking if elements from first matrix are greater or equal compare to elements in second. More...  
GMat  cv::gapi::cmpGE (const GMat &src1, const GScalar &src2) 
GMat  cv::gapi::cmpGT (const GMat &src1, const GMat &src2) 
Performs the perelement comparison of two matrices checking if elements from first matrix are greater compare to elements in second. More...  
GMat  cv::gapi::cmpGT (const GMat &src1, const GScalar &src2) 
GMat  cv::gapi::cmpLE (const GMat &src1, const GMat &src2) 
Performs the perelement comparison of two matrices checking if elements from first matrix are less or equal compare to elements in second. More...  
GMat  cv::gapi::cmpLE (const GMat &src1, const GScalar &src2) 
GMat  cv::gapi::cmpLT (const GMat &src1, const GMat &src2) 
Performs the perelement comparison of two matrices checking if elements from first matrix are less than elements in second. More...  
GMat  cv::gapi::cmpLT (const GMat &src1, const GScalar &src2) 
GMat  cv::gapi::cmpNE (const GMat &src1, const GMat &src2) 
Performs the perelement comparison of two matrices checking if elements from first matrix are not equal to elements in second. More...  
GMat  cv::gapi::cmpNE (const GMat &src1, const GScalar &src2) 
GMat  cv::gapi::select (const GMat &src1, const GMat &src2, const GMat &mask) 
Select values from either first or second of input matrices by given mask. The function set to the output matrix either the value from the first input matrix if corresponding value of mask matrix is 255, or value from the second input matrix (if value of mask matrix set to 0). More...  
gapi_math
GMat cv::gapi::bitwise_and  (  const GMat &  src1, 
const GMat &  src2  
) 
Python:  

cv.gapi.bitwise_and(  src1, src2  ) >  retval 
#include <opencv2/gapi/core.hpp>
computes bitwise conjunction of the two matrixes (src1 & src2) Calculates the perelement bitwise logical conjunction of two matrices of the same size.
In case of floatingpoint matrices, their machinespecific bit representations (usually IEEE754compliant) are used for the operation. In case of multichannel matrices, each channel is processed independently. Output matrix must have the same size and depth as the input matrices.
Supported matrix data types are CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1.
src1  first input matrix. 
src2  second input matrix. 
GMat cv::gapi::bitwise_and  (  const GMat &  src1, 
const GScalar &  src2  
) 
Python:  

cv.gapi.bitwise_and(  src1, src2  ) >  retval 
#include <opencv2/gapi/core.hpp>
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
src1  first input matrix. 
src2  scalar, which will be perlemenetly conjuncted with elements of src1. 
#include <opencv2/gapi/core.hpp>
Inverts every bit of an array.
The function bitwise_not calculates perelement bitwise inversion of the input matrix:
\[\texttt{dst} (I) = \neg \texttt{src} (I)\]
In case of floatingpoint matrices, their machinespecific bit representations (usually IEEE754compliant) are used for the operation. In case of multichannel matrices, each channel is processed independently. Output matrix must have the same size and depth as the input matrix.
Supported matrix data types are CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1.
src  input matrix. 
GMat cv::gapi::bitwise_or  (  const GMat &  src1, 
const GMat &  src2  
) 
Python:  

cv.gapi.bitwise_or(  src1, src2  ) >  retval 
#include <opencv2/gapi/core.hpp>
computes bitwise disjunction of the two matrixes (src1  src2) Calculates the perelement bitwise logical disjunction of two matrices of the same size.
In case of floatingpoint matrices, their machinespecific bit representations (usually IEEE754compliant) are used for the operation. In case of multichannel matrices, each channel is processed independently. Output matrix must have the same size and depth as the input matrices.
Supported matrix data types are CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1.
src1  first input matrix. 
src2  second input matrix. 
GMat cv::gapi::bitwise_or  (  const GMat &  src1, 
const GScalar &  src2  
) 
Python:  

cv.gapi.bitwise_or(  src1, src2  ) >  retval 
#include <opencv2/gapi/core.hpp>
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
src1  first input matrix. 
src2  scalar, which will be perlemenetly disjuncted with elements of src1. 
GMat cv::gapi::bitwise_xor  (  const GMat &  src1, 
const GMat &  src2  
) 
Python:  

cv.gapi.bitwise_xor(  src1, src2  ) >  retval 
#include <opencv2/gapi/core.hpp>
computes bitwise logical "exclusive or" of the two matrixes (src1 ^ src2) Calculates the perelement bitwise logical "exclusive or" of two matrices of the same size.
In case of floatingpoint matrices, their machinespecific bit representations (usually IEEE754compliant) are used for the operation. In case of multichannel matrices, each channel is processed independently. Output matrix must have the same size and depth as the input matrices.
Supported matrix data types are CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1.
src1  first input matrix. 
src2  second input matrix. 
GMat cv::gapi::bitwise_xor  (  const GMat &  src1, 
const GScalar &  src2  
) 
Python:  

cv.gapi.bitwise_xor(  src1, src2  ) >  retval 
#include <opencv2/gapi/core.hpp>
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
src1  first input matrix. 
src2  scalar, for which perlemenet "logical or" operation on elements of src1 will be performed. 
GMat cv::gapi::cmpEQ  (  const GMat &  src1, 
const GMat &  src2  
) 
Python:  

cv.gapi.cmpEQ(  src1, src2  ) >  retval 
#include <opencv2/gapi/core.hpp>
Performs the perelement comparison of two matrices checking if elements from first matrix are equal to elements in second.
The function compares elements of two matrices src1 and src2 of the same size:
\[\texttt{dst} (I) = \texttt{src1} (I) == \texttt{src2} (I)\]
When the comparison result is true, the corresponding element of output array is set to 255. The comparison operations can be replaced with the equivalent matrix expressions:
\[\texttt{dst} = \texttt{src1} == \texttt{src2}\]
Output matrix of depth CV_8U must have the same size and the same number of channels as the input matrices.
Supported input matrix data types are CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1.
src1  first input matrix. 
src2  second input matrix/scalar of the same depth as first input matrix. 
GMat cv::gapi::cmpEQ  (  const GMat &  src1, 
const GScalar &  src2  
) 
Python:  

cv.gapi.cmpEQ(  src1, src2  ) >  retval 
#include <opencv2/gapi/core.hpp>
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
GMat cv::gapi::cmpGE  (  const GMat &  src1, 
const GMat &  src2  
) 
Python:  

cv.gapi.cmpGE(  src1, src2  ) >  retval 
#include <opencv2/gapi/core.hpp>
Performs the perelement comparison of two matrices checking if elements from first matrix are greater or equal compare to elements in second.
The function compares elements of two matrices src1 and src2 of the same size:
\[\texttt{dst} (I) = \texttt{src1} (I) >= \texttt{src2} (I)\]
When the comparison result is true, the corresponding element of output array is set to 255. The comparison operations can be replaced with the equivalent matrix expressions:
\[\texttt{dst} = \texttt{src1} >= \texttt{src2}\]
Output matrix of depth CV_8U must have the same size and the same number of channels as the input matrices.
Supported input matrix data types are CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1.
src1  first input matrix. 
src2  second input matrix/scalar of the same depth as first input matrix. 
GMat cv::gapi::cmpGE  (  const GMat &  src1, 
const GScalar &  src2  
) 
Python:  

cv.gapi.cmpGE(  src1, src2  ) >  retval 
#include <opencv2/gapi/core.hpp>
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
GMat cv::gapi::cmpGT  (  const GMat &  src1, 
const GMat &  src2  
) 
Python:  

cv.gapi.cmpGT(  src1, src2  ) >  retval 
#include <opencv2/gapi/core.hpp>
Performs the perelement comparison of two matrices checking if elements from first matrix are greater compare to elements in second.
The function compares elements of two matrices src1 and src2 of the same size:
\[\texttt{dst} (I) = \texttt{src1} (I) > \texttt{src2} (I)\]
When the comparison result is true, the corresponding element of output array is set to 255. The comparison operations can be replaced with the equivalent matrix expressions:
\[\texttt{dst} = \texttt{src1} > \texttt{src2}\]
Output matrix of depth CV_8U must have the same size and the same number of channels as the input matrices/matrix.
Supported input matrix data types are CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1.
src1  first input matrix. 
src2  second input matrix/scalar of the same depth as first input matrix. 
GMat cv::gapi::cmpGT  (  const GMat &  src1, 
const GScalar &  src2  
) 
Python:  

cv.gapi.cmpGT(  src1, src2  ) >  retval 
#include <opencv2/gapi/core.hpp>
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
GMat cv::gapi::cmpLE  (  const GMat &  src1, 
const GMat &  src2  
) 
Python:  

cv.gapi.cmpLE(  src1, src2  ) >  retval 
#include <opencv2/gapi/core.hpp>
Performs the perelement comparison of two matrices checking if elements from first matrix are less or equal compare to elements in second.
The function compares elements of two matrices src1 and src2 of the same size:
\[\texttt{dst} (I) = \texttt{src1} (I) <= \texttt{src2} (I)\]
When the comparison result is true, the corresponding element of output array is set to 255. The comparison operations can be replaced with the equivalent matrix expressions:
\[\texttt{dst} = \texttt{src1} <= \texttt{src2}\]
Output matrix of depth CV_8U must have the same size and the same number of channels as the input matrices.
Supported input matrix data types are CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1.
src1  first input matrix. 
src2  second input matrix/scalar of the same depth as first input matrix. 
GMat cv::gapi::cmpLE  (  const GMat &  src1, 
const GScalar &  src2  
) 
Python:  

cv.gapi.cmpLE(  src1, src2  ) >  retval 
#include <opencv2/gapi/core.hpp>
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
GMat cv::gapi::cmpLT  (  const GMat &  src1, 
const GMat &  src2  
) 
Python:  

cv.gapi.cmpLT(  src1, src2  ) >  retval 
#include <opencv2/gapi/core.hpp>
Performs the perelement comparison of two matrices checking if elements from first matrix are less than elements in second.
The function compares elements of two matrices src1 and src2 of the same size:
\[\texttt{dst} (I) = \texttt{src1} (I) < \texttt{src2} (I)\]
When the comparison result is true, the corresponding element of output array is set to 255. The comparison operations can be replaced with the equivalent matrix expressions:
\[\texttt{dst} = \texttt{src1} < \texttt{src2}\]
Output matrix of depth CV_8U must have the same size and the same number of channels as the input matrices/matrix.
Supported input matrix data types are CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1.
src1  first input matrix. 
src2  second input matrix/scalar of the same depth as first input matrix. 
GMat cv::gapi::cmpLT  (  const GMat &  src1, 
const GScalar &  src2  
) 
Python:  

cv.gapi.cmpLT(  src1, src2  ) >  retval 
#include <opencv2/gapi/core.hpp>
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
GMat cv::gapi::cmpNE  (  const GMat &  src1, 
const GMat &  src2  
) 
Python:  

cv.gapi.cmpNE(  src1, src2  ) >  retval 
#include <opencv2/gapi/core.hpp>
Performs the perelement comparison of two matrices checking if elements from first matrix are not equal to elements in second.
The function compares elements of two matrices src1 and src2 of the same size:
\[\texttt{dst} (I) = \texttt{src1} (I) != \texttt{src2} (I)\]
When the comparison result is true, the corresponding element of output array is set to 255. The comparison operations can be replaced with the equivalent matrix expressions:
\[\texttt{dst} = \texttt{src1} != \texttt{src2}\]
Output matrix of depth CV_8U must have the same size and the same number of channels as the input matrices.
Supported input matrix data types are CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1.
src1  first input matrix. 
src2  second input matrix/scalar of the same depth as first input matrix. 
GMat cv::gapi::cmpNE  (  const GMat &  src1, 
const GScalar &  src2  
) 
Python:  

cv.gapi.cmpNE(  src1, src2  ) >  retval 
#include <opencv2/gapi/core.hpp>
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
GMat cv::gapi::select  (  const GMat &  src1, 
const GMat &  src2,  
const GMat &  mask  
) 
Python:  

cv.gapi.select(  src1, src2, mask  ) >  retval 
#include <opencv2/gapi/core.hpp>
Select values from either first or second of input matrices by given mask. The function set to the output matrix either the value from the first input matrix if corresponding value of mask matrix is 255, or value from the second input matrix (if value of mask matrix set to 0).
Input mask matrix must be of CV_8UC1 type, two other inout matrices and output matrix should be of the same type. The size should be the same for all input and output matrices. Supported input matrix data types are CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1.
src1  first input matrix. 
src2  second input matrix. 
mask  mask input matrix. 