OpenCV 图形API（21）逐像素操作

• 操作系统：ubuntu22.04
• OpenCV版本：OpenCV4.9
• IDE:Visual Studio Code
• 编程语言：C++11

算法描述

在OpenCV的G-API模块中，逐像素操作指的是对图像中的每个像素单独进行处理的操作。这些操作可以通过G-API的计算图（Graph API）来高效地执行。G-API提供了一系列用于实现各种图像处理任务的函数，如算术运算、逻辑运算和其他像素级别的变换。

相关函数

以下是关于Graph API中逐像素操作的一些说明和示例：

• 算术运算：包括加法、减法、乘法、除法等，例如cv::gapi::add、cv::gapi::sub、cv::gapi::mul、cv::gapi::div。

• 逻辑运算：如与、或、非、异或等操作，适用于二值图像处理，例如cv::gapi::bitwise_and、cv::gapi::bitwise_or等。

• 其他变换：还包括一些其他的像素级变换，如绝对差值(cv::gapi::absdiff)、位移(cv::gapi::shift)等。

通过使用G-API，你可以构建一个计算图，该图定义了数据如何流动以及各个操作如何串联起来以完成复杂的图像处理任务。这种方法不仅提高了代码的可读性，还能够利用优化后的后端实现加速计算过程。

按位与操作cv::gapi::bitwise_and

cv::gapi::bitwise_and 是 OpenCV G-API 模块中的一个函数，用于执行两个矩阵（图像）之间的逐像素按位与操作。这个操作对于每个对应的像素点，将 src1 和 src2 的像素值进行按位与运算，并将结果存储在输出矩阵中。

• 对于浮点型矩阵，将使用其特定于机器的位表示（通常是符合 IEEE754 标准的）进行操作。
• 对于多通道矩阵，每个通道将独立处理。
• 输出矩阵必须具有与输入矩阵相同的尺寸和深度。

支持的矩阵数据类型包括：CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1。

注意：
该函数的文本ID是 “org.opencv.core.pixelwise.bitwise_and”

函数原型

GMat cv::gapi::bitwise_and 	
(const GMat &  	src1,const GMat &  	src2 
) 	

参数：

• 参数src1: 第一个输入矩阵。
• 参数src2: 第二个输入矩阵。

代码示例

#include <opencv2/gapi.hpp>
#include <opencv2/gapi/core.hpp>
#include <opencv2/opencv.hpp>int main()
{// 创建示例输入矩阵cv::Mat src1 = ( cv::Mat_< uchar >( 3, 3 ) << 1, 2, 3, 4, 5, 6, 7, 8, 9 );cv::Mat src2 = ( cv::Mat_< uchar >( 3, 3 ) << 9, 8, 7, 6, 5, 4, 3, 2, 1 );// 定义G-API计算图cv::GComputation bitwiseAndComp( []() {cv::GMat in1, in2;cv::GMat out = cv::gapi::bitwise_and( in1, in2 );  // 计算逐像素按位与return cv::GComputation( cv::GIn( in1, in2 ), cv::GOut( out ) );} );// 输出矩阵cv::Mat dst;// 执行计算图bitwiseAndComp.apply( cv::gin( src1, src2 ), cv::gout( dst ) );// 打印结果std::cout << "Element-wise bitwise AND result: \n" << dst << std::endl;return 0;
}

运行结果

Element-wise bitwise AND result: 
[  1,   0,   3;4,   5,   4;3,   0,   1]

按位非操作函数bitwise_not()

反转数组的每一位。
该函数 bitwise_not 计算输入矩阵每个元素的按位取反：
$$\text{dst}(I)=\neg \text{src}(I)$$
对于浮点数矩阵，将使用其特定于机器的位表示（通常是符合 IEEE754 标准的）进行操作。对于多通道矩阵，每个通道将独立处理。输出矩阵必须与输入矩阵具有相同的尺寸和深度。

支持的矩阵数据类型包括：CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1。

注意：
该函数的文本ID是 “org.opencv.core.pixelwise.bitwise_not”

函数原型

GMat cv::gapi::bitwise_not 
(const GMat &src
) 	

参数：

• 参数src: 输入矩阵。

代码示例

#include <opencv2/gapi.hpp>
#include <opencv2/gapi/core.hpp>
#include <opencv2/opencv.hpp>int main()
{// 创建示例输入矩阵cv::Mat src = ( cv::Mat_< uchar >( 3, 3 ) << 1, 2, 3, 4, 5, 6, 7, 8, 9 );// 定义G-API计算图cv::GComputation bitwiseNotComp( []() {cv::GMat in;cv::GMat out = cv::gapi::bitwise_not( in );  // 计算逐像素按位取反return cv::GComputation( cv::GIn( in ), cv::GOut( out ) );} );// 输出矩阵cv::Mat dst;// 执行计算图bitwiseNotComp.apply( cv::gin( src ), cv::gout( dst ) );// 打印结果std::cout << "Element-wise bitwise NOT result: \n" << dst << std::endl;return 0;
}

运行结果

Element-wise bitwise NOT result: 
[254, 253, 252;251, 250, 249;248, 247, 246]

按位或操作函数bitwise_or()

计算两个矩阵（src1 | src2）的逐元素按位逻辑或。
该函数计算两个相同大小矩阵的每个元素的按位逻辑或：

• 对于浮点数矩阵，将使用其特定于机器的位表示（通常是符合 IEEE754 标准的）进行操作。
• 对于多通道矩阵，每个通道将独立处理。
• 输出矩阵必须具有与输入矩阵相同的尺寸和深度。

支持的矩阵数据类型包括：CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1。

注意：
该函数的文本ID是 “org.opencv.core.pixelwise.bitwise_or”

函数原型

GMat cv::gapi::bitwise_or 	
(const GMat &  	src1,const GMat &  	src2 
) 	

参数：

• src1: 第一个输入矩阵。
• src2: 第二个输入矩阵。

示例代码

#include <opencv2/gapi.hpp>
#include <opencv2/gapi/core.hpp>
#include <opencv2/opencv.hpp>int main()
{// 创建示例输入矩阵cv::Mat src1 = ( cv::Mat_< uchar >( 3, 3 ) << 1, 2, 3, 4, 5, 6, 7, 8, 9 );cv::Mat src2 = ( cv::Mat_< uchar >( 3, 3 ) << 9, 8, 7, 6, 5, 4, 3, 2, 1 );// 定义G-API计算图cv::GComputation bitwiseOrComp( []() {cv::GMat in1, in2;cv::GMat out = cv::gapi::bitwise_or( in1, in2 );  // 计算逐像素按位或return cv::GComputation( cv::GIn( in1, in2 ), cv::GOut( out ) );} );// 输出矩阵cv::Mat dst;// 执行计算图bitwiseOrComp.apply( cv::gin( src1, src2 ), cv::gout( dst ) );// 打印结果std::cout << "Element-wise bitwise OR result: \n" << dst << std::endl;return 0;
}

运行结果

Element-wise bitwise OR result: 
[  9,  10,   7;6,   5,   6;7,  10,   9]

按位异或操作函数bitwise_xor()

计算两个矩阵（src1 ^ src2）的逐元素按位逻辑“异或”。

该函数计算两个相同大小矩阵的每个元素的按位逻辑“异或”：

• 对于浮点数矩阵，将使用其特定于机器的位表示（通常是符合 IEEE754 标准的）进行操作。
• 对于多通道矩阵，每个通道将独立处理。
• 输出矩阵必须具有与输入矩阵相同的尺寸和深度。

支持的矩阵数据类型包括：CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1。

注意：
该函数的文本ID是 “org.opencv.core.pixelwise.bitwise_xor”

函数原型

GMat cv::gapi::bitwise_xor 
(const GMat &  	src1,const GMat &  	src2 
) 	

参数：

• 参数src1: 第一个输入矩阵。
• 参数 src2: 第二个输入矩阵。

代码示例

#include <opencv2/gapi.hpp>
#include <opencv2/gapi/core.hpp>
#include <opencv2/opencv.hpp>int main()
{// 创建示例输入矩阵cv::Mat src1 = ( cv::Mat_< uchar >( 3, 3 ) << 1, 2, 3, 4, 5, 6, 7, 8, 9 );cv::Mat src2 = ( cv::Mat_< uchar >( 3, 3 ) << 9, 8, 7, 6, 5, 4, 3, 2, 1 );// 定义G-API计算图cv::GComputation bitwiseXorComp( []() {cv::GMat in1, in2;cv::GMat out = cv::gapi::bitwise_xor( in1, in2 );  // 计算逐像素按位异或return cv::GComputation( cv::GIn( in1, in2 ), cv::GOut( out ) );} );// 输出矩阵cv::Mat dst;// 执行计算图bitwiseXorComp.apply( cv::gin( src1, src2 ), cv::gout( dst ) );// 打印结果std::cout << "Element-wise bitwise XOR result: \n" << dst << std::endl;return 0;
}

运行结果

Element-wise bitwise XOR result: 
[  8,  10,   4;2,   0,   2;4,  10,   8]

相等比较操作函数cmpEQ()

对两个矩阵进行逐元素比较，检查第一个矩阵中的元素是否等于第二个矩阵中的元素。

该函数比较两个相同大小的矩阵 src1 和 src2 的元素：
$$\text{dst}(I)=\text{src1}(I)==\text{src2}(I)$$
输出矩阵的深度必须是 CV_8U，并且必须与输入矩阵具有相同的尺寸和通道数。
支持的输入矩阵数据类型包括：CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1。

注意：
该函数的文本ID是 “org.opencv.core.pixelwise.compare.cmpEQ”

函数原型

GMat cv::gapi::cmpEQ 
(const GMat &  	src1,const GMat &  	src2 
) 		

参数：

• 参数src1: 第一个输入矩阵。
• 参数src2: 第二个输入矩阵或标量，其深度应与第一个输入矩阵相同。

代码示例

#include <opencv2/gapi.hpp>
#include <opencv2/gapi/core.hpp>
#include <opencv2/opencv.hpp>int main()
{// 创建示例输入矩阵cv::Mat src1 = ( cv::Mat_< uchar >( 3, 3 ) << 1, 2, 3, 4, 5, 6, 7, 8, 9 );cv::Mat src2 = ( cv::Mat_< uchar >( 3, 3 ) << 1, 2, 3, 4, 0, 6, 7, 8, 9 );// 定义G-API计算图cv::GComputation cmpEQComp( []() {cv::GMat in1, in2;cv::GMat out = cv::gapi::cmpEQ( in1, in2 );  // 计算逐像素相等性比较return cv::GComputation( cv::GIn( in1, in2 ), cv::GOut( out ) );} );// 输出矩阵cv::Mat dst;// 执行计算图cmpEQComp.apply( cv::gin( src1, src2 ), cv::gout( dst ) );// 打印结果std::cout << "Element-wise equality comparison result: \n" << dst << std::endl;return 0;
}

运行结果

Element-wise equality comparison result: 
[255, 255, 255;255,   0, 255;255, 255, 255]

“大于等于”比较操作函数cmpGE()

对两个矩阵进行逐元素比较，检查第一个矩阵中的元素是否大于或等于第二个矩阵中的元素。

该函数比较两个相同大小的矩阵 src1 和 src2 的元素：
$$\text{dst}(I)=\text{src1}(I)>=\text{src2}(I)$$
当比较结果为真时，输出数组中相应位置的元素被设置为 255。比较操作可以用等效的矩阵表达式替换：
$$\text{dst}=\text{src1}>=\text{src2}$$
输出矩阵的深度必须是 CV_8U，并且必须与输入矩阵具有相同的尺寸和通道数。

支持的输入矩阵数据类型包括：CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1。

注意：
该函数的文本ID是 “org.opencv.core.pixelwise.compare.cmpGE”

函数原型

GMat cv::gapi::cmpGE 	
(const GMat &  	src1,const GMat &  	src2 
) 	

参数：

• 参数 src1: 第一个输入矩阵。
• 参数 src2: 第二个输入矩阵或标量，其深度应与第一个输入矩阵相同。

代码示例

#include <opencv2/gapi.hpp>
#include <opencv2/gapi/core.hpp>
#include <opencv2/opencv.hpp>int main()
{// 创建示例输入矩阵cv::Mat src1 = ( cv::Mat_< uchar >( 3, 3 ) << 9, 8, 7, 6, 5, 4, 3, 2, 1 );cv::Mat src2 = ( cv::Mat_< uchar >( 3, 3 ) << 5, 5, 5, 5, 5, 5, 5, 5, 5 );// 定义G-API计算图cv::GComputation cmpGEComp( []() {cv::GMat in1, in2;cv::GMat out = cv::gapi::cmpGE( in1, in2 );  // 计算逐像素“大于等于”比较return cv::GComputation( cv::GIn( in1, in2 ), cv::GOut( out ) );} );// 输出矩阵cv::Mat dst;// 执行计算图cmpGEComp.apply( cv::gin( src1, src2 ), cv::gout( dst ) );// 打印结果std::cout << "Element-wise greater or equal comparison result: \n" << dst << std::endl;return 0;
}

运行结果

Element-wise greater or equal comparison result: 
[255, 255, 255;255, 255,   0;0,   0,   0]

“大于”比较操作函数cmpGT()

对两个矩阵进行逐元素比较，检查第一个矩阵中的元素是否大于第二个矩阵中的元素。

该函数比较两个相同大小的矩阵 src1 和 src2 的元素：

$$\text{dst}(I)=\text{src1}(I)>\text{src2}(I)$$
当比较结果为真时，输出数组中相应位置的元素被设置为 255。比较操作可以用等效的矩阵表达式替换：
$$\text{dst}=\text{src1}>\text{src2}$$
输出矩阵的深度必须是 CV_8U，并且必须与输入矩阵具有相同的尺寸和通道数。

支持的输入矩阵数据类型包括：CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1。

注意：
该函数的文本ID是 “org.opencv.core.pixelwise.compare.cmpGT”

函数原型

GMat cv::gapi::cmpGT 
(const GMat &  	src1,const GMat &  	src2 
) 	

参数

• 参数src1: 第一个输入矩阵。
• 参数src2: 第二个输入矩阵或标量，其深度应与第一个输入矩阵相同。

代码示例

#include <opencv2/gapi.hpp>
#include <opencv2/gapi/core.hpp>
#include <opencv2/opencv.hpp>int main()
{// 创建示例输入矩阵cv::Mat src1 = ( cv::Mat_< uchar >( 3, 3 ) << 9, 8, 7, 6, 5, 4, 3, 2, 1 );cv::Mat src2 = ( cv::Mat_< uchar >( 3, 3 ) << 5, 5, 5, 5, 5, 5, 5, 5, 5 );// 定义G-API计算图cv::GComputation cmpGTComp( []() {cv::GMat in1, in2;cv::GMat out = cv::gapi::cmpGT( in1, in2 );  // 计算逐像素“大于”比较return cv::GComputation( cv::GIn( in1, in2 ), cv::GOut( out ) );} );// 输出矩阵cv::Mat dst;// 执行计算图cmpGTComp.apply( cv::gin( src1, src2 ), cv::gout( dst ) );// 打印结果std::cout << "Element-wise greater than comparison result: \n" << dst << std::endl;return 0;
}

运行结果

Element-wise greater than comparison result: 
[255, 255, 255;255,   0,   0;0,   0,   0]

小于等于”比较操作函数cmpLE()

对两个矩阵进行逐元素比较，检查第一个矩阵中的元素是否小于或等于第二个矩阵中的元素。

该函数比较两个相同大小的矩阵 src1 和 src2 的元素：
$$\text{dst}(I)=\text{src1}(I)<=\text{src2}(I)$$
当比较结果为真时，输出数组中相应位置的元素被设置为 255；否则为 0。比较操作可以用等效的矩阵表达式替换：
$$\text{dst}=\text{src1}<=\text{src2}$$
输出矩阵的深度必须是 CV_8U，并且必须与输入矩阵具有相同的尺寸和通道数。

支持的输入矩阵数据类型包括：CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1。

注意：
该函数的文本ID是 “org.opencv.core.pixelwise.compare.cmpLE”

函数原型

GMat cv::gapi::cmpLE 	
(const GMat &  	src1,const GMat &  	src2 
) 	

参数：

• 参数src1: 第一个输入矩阵。
• 参数src2: 第二个输入矩阵或标量，其深度应与第一个输入矩阵相同。

代码示例

#include <opencv2/gapi.hpp>
#include <opencv2/gapi/core.hpp>
#include <opencv2/opencv.hpp>int main()
{// 创建示例输入矩阵cv::Mat src1 = ( cv::Mat_< uchar >( 3, 3 ) << 1, 2, 3, 4, 5, 6, 7, 8, 9 );cv::Mat src2 = ( cv::Mat_< uchar >( 3, 3 ) << 5, 5, 5, 5, 5, 5, 5, 5, 5 );// 定义G-API计算图cv::GComputation cmpLEComp( []() {cv::GMat in1, in2;cv::GMat out = cv::gapi::cmpLE( in1, in2 );  // 计算逐像素“小于等于”比较return cv::GComputation( cv::GIn( in1, in2 ), cv::GOut( out ) );} );// 输出矩阵cv::Mat dst;// 执行计算图cmpLEComp.apply( cv::gin( src1, src2 ), cv::gout( dst ) );// 打印结果std::cout << "Element-wise less or equal comparison result: \n" << dst << std::endl;return 0;
}

运行结果

Element-wise less or equal comparison result: 
[255, 255, 255;255, 255,   0;0,   0,   0]

“小于”比较操作函数cmpLT()

对两个矩阵进行逐元素比较，检查第一个矩阵中的元素是否小于第二个矩阵中的元素。

该函数比较两个相同大小的矩阵 src1 和 src2 的元素：

$$\text{dst}(I)=\text{src1}(I)<\text{src2}(I)$$
当比较结果为真时，输出数组中相应位置的元素被设置为 255；否则为 0。比较操作可以用等效的矩阵表达式替换：
$$\text{dst}=\text{src1}<\text{src2}$$
输出矩阵的深度必须是 CV_8U，并且必须与输入矩阵具有相同的尺寸和通道数。

支持的输入矩阵数据类型包括：CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1。

注意：
该函数的文本ID是 “org.opencv.core.pixelwise.compare.cmpLT”

函数原型

GMat cv::gapi::cmpLT
(const GMat &  	src1,const GMat &  	src2 
) 	

参数：

• 参数src1: 第一个输入矩阵。
• 参数src2: 第二个输入矩阵或标量，其深度应与第一个输入矩阵相同。

代码示例

#include <opencv2/gapi.hpp>
#include <opencv2/gapi/core.hpp>
#include <opencv2/opencv.hpp>int main()
{// 创建示例输入矩阵cv::Mat src1 = ( cv::Mat_< uchar >( 3, 3 ) << 1, 2, 3, 4, 5, 6, 7, 8, 9 );cv::Mat src2 = ( cv::Mat_< uchar >( 3, 3 ) << 5, 5, 5, 5, 5, 5, 5, 5, 5 );// 定义G-API计算图cv::GComputation cmpLTComp( []() {cv::GMat in1, in2;cv::GMat out = cv::gapi::cmpLT( in1, in2 );  // 计算逐像素“小于”比较return cv::GComputation( cv::GIn( in1, in2 ), cv::GOut( out ) );} );// 输出矩阵cv::Mat dst;// 执行计算图cmpLTComp.apply( cv::gin( src1, src2 ), cv::gout( dst ) );// 打印结果std::cout << "Element-wise less than comparison result: \n" << dst << std::endl;return 0;
}

运行结果

Element-wise less than comparison result: 
[255, 255, 255;255,   0,   0;0,   0,   0]

“不等于”比较操作函数cmpNE()

对两个矩阵进行逐元素比较，检查第一个矩阵中的元素是否不等于第二个矩阵中的元素。

该函数比较两个相同大小的矩阵 src1 和 src2 的元素：
$$\text{dst}(I)=\text{src1}(I)!=\text{src2}(I)$$
当比较结果为真时，输出数组中相应位置的元素被设置为 255；否则为 0。比较操作可以用等效的矩阵表达式替换：
$$\text{dst}=\text{src1}!=\text{src2}$$
输出矩阵的深度必须是 CV_8U，并且必须与输入矩阵具有相同的尺寸和通道数。

支持的输入矩阵数据类型包括：CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1。

注意：
该函数的文本ID是 “org.opencv.core.pixelwise.compare.cmpNE”

函数原型

GMat cv::gapi::cmpNE 	
(const GMat &  	src1,const GMat &  	src2 
) 	

参数：

• 参数src1: 第一个输入矩阵。
• 参数src2: 第二个输入矩阵或标量，其深度应与第一个输入矩阵相同。

代码示例

#include <opencv2/opencv.hpp>
#include <opencv2/gapi.hpp>
#include <opencv2/gapi/core.hpp>int main() {// 创建示例输入矩阵cv::Mat src1 = (cv::Mat_<uchar>(3, 3) << 1, 2, 3,4, 5, 6,7, 8, 9);cv::Mat src2 = (cv::Mat_<uchar>(3, 3) << 5, 5, 5,5, 5, 5,5, 5, 5);// 定义G-API计算图cv::GComputation cmpNEComp([](){cv::GMat in1, in2;cv::GMat out = cv::gapi::cmpNE(in1, in2); // 计算逐像素“不等于”比较return cv::GComputation(cv::GIn(in1, in2), cv::GOut(out));});// 输出矩阵cv::Mat dst;// 执行计算图cmpNEComp.apply(cv::gin(src1, src2), cv::gout(dst));// 打印结果std::cout << "Element-wise not equal comparison result: \n" << dst << std::endl;return 0;
}

运行结果

Element-wise not equal comparison result: 
[255, 255, 255;255,   0, 255;255, 255, 255]

基于掩码从两个矩阵中选择元素的函数select()

根据给定的掩码从第一个或第二个输入矩阵中选择值。该函数将输出矩阵设置为：如果掩码矩阵对应位置的值是 255，则采用第一个输入矩阵中的值；如果掩码矩阵对应位置的值是 0，则采用第二个输入矩阵中的值。

输入掩码矩阵必须是 CV_8UC1 类型，其他两个输入矩阵和输出矩阵应具有相同的类型。所有输入和输出矩阵的尺寸应该相同。支持的输入矩阵数据类型包括：CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1。

注意：
该函数的文本ID是 “org.opencv.core.pixelwise.select”

函数原型

GMat cv::gapi::select 
(const GMat &  	src1,const GMat &  	src2,const GMat &  	mask 
) 	

参数

• 参数src1: 第一个输入矩阵。
• 参数src2: 第二个输入矩阵。
• 参数mask: 掩码输入矩阵。

代码示例

#include <opencv2/opencv.hpp>
#include <opencv2/gapi.hpp>
#include <opencv2/gapi/core.hpp>int main() {// 创建示例输入矩阵cv::Mat src1 = (cv::Mat_<uchar>(3, 3) << 1, 2, 3,4, 5, 6,7, 8, 9);cv::Mat src2 = (cv::Mat_<uchar>(3, 3) << 9, 8, 7,6, 5, 4,3, 2, 1);cv::Mat mask = (cv::Mat_<uchar>(3, 3) << 0, 255, 0,255, 0, 255,0, 255, 0);// 定义G-API计算图cv::GComputation selectComp([](){cv::GMat in1, in2, msk;cv::GMat out = cv::gapi::select(in1, in2, msk); // 根据掩码选择元素return cv::GComputation(cv::GIn(in1, in2, msk), cv::GOut(out));});// 输出矩阵cv::Mat dst;// 执行计算图selectComp.apply(cv::gin(src1, src2, mask), cv::gout(dst));// 打印结果std::cout << "Element-wise selection result: \n" << dst << std::endl;return 0;
}

运行结果

Element-wise selection result: 
[  9,   2,   7;4,   5,   6;3,   8,   1]

…………………………………………………………完结………………………………………………………………………………