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

jndingxin2025-04-09 2:31
  • 操作系统：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"

函数原型
cpp 复制代码 
GMat cv::gapi::bitwise_and 	
(
 	const GMat &  	src1,
	const GMat &  	src2 
)
参数：
  • 参数src1: 第一个输入矩阵。
  • 参数src2: 第二个输入矩阵。
代码示例
cpp 复制代码 
#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;
}
运行结果
cpp 复制代码 
Element-wise bitwise AND result: 
[  1,   0,   3;
   4,   5,   4;
   3,   0,   1]

按位非操作函数bitwise_not()

反转数组的每一位。

该函数 bitwise_not 计算输入矩阵每个元素的按位取反：
dst ( I ) = ¬ src ( I ) \texttt{dst} (I) = \neg \texttt{src} (I) dst(I)=¬src(I)

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

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

注意：

该函数的文本ID是 "org.opencv.core.pixelwise.bitwise_not"

函数原型
cpp 复制代码 
GMat cv::gapi::bitwise_not 
(
 	const GMat &src
)
参数：
  • 参数src: 输入矩阵。
代码示例
cpp 复制代码 
#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;
}
运行结果
bash 复制代码 
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"

函数原型
cpp 复制代码 
GMat cv::gapi::bitwise_or 	
(
 	const GMat &  	src1,
	const GMat &  	src2 
)
参数：
  • src1: 第一个输入矩阵。
  • src2: 第二个输入矩阵。
示例代码
cpp 复制代码 
#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;
}
运行结果
bash 复制代码 
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"

函数原型
cpp 复制代码 
GMat cv::gapi::bitwise_xor 
(
 	const GMat &  	src1,
	const GMat &  	src2 
)
参数：
  • 参数src1: 第一个输入矩阵。
  • 参数 src2: 第二个输入矩阵。
代码示例
cpp 复制代码 
#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;
}
运行结果
bash 复制代码 
Element-wise bitwise XOR result: 
[  8,  10,   4;
   2,   0,   2;
   4,  10,   8]

相等比较操作函数cmpEQ()

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

该函数比较两个相同大小的矩阵 src1 和 src2 的元素：
dst ( I ) = src1 ( I ) = = src2 ( I ) \texttt{dst} (I) = \texttt{src1} (I) == \texttt{src2} (I) dst(I)=src1(I)==src2(I)

输出矩阵的深度必须是 CV_8U，并且必须与输入矩阵具有相同的尺寸和通道数。

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

注意：

该函数的文本ID是 "org.opencv.core.pixelwise.compare.cmpEQ"

函数原型
cpp 复制代码 
GMat cv::gapi::cmpEQ 
(
 	const GMat &  	src1,
	const GMat &  	src2 
)
参数：
  • 参数src1: 第一个输入矩阵。
  • 参数src2: 第二个输入矩阵或标量，其深度应与第一个输入矩阵相同。
代码示例
cpp 复制代码 
#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;
}
运行结果
bash 复制代码 
Element-wise equality comparison result: 
[255, 255, 255;
 255,   0, 255;
 255, 255, 255]

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

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

该函数比较两个相同大小的矩阵 src1 和 src2 的元素：
dst ( I ) = src1 ( I ) > = src2 ( I ) \texttt{dst} (I) = \texttt{src1} (I) >= \texttt{src2} (I) dst(I)=src1(I)>=src2(I)

当比较结果为真时，输出数组中相应位置的元素被设置为 255。比较操作可以用等效的矩阵表达式替换：
dst = src1 > = src2 \texttt{dst} = \texttt{src1} >= \texttt{src2} dst=src1>=src2

输出矩阵的深度必须是 CV_8U，并且必须与输入矩阵具有相同的尺寸和通道数。

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

注意：

该函数的文本ID是 "org.opencv.core.pixelwise.compare.cmpGE"

函数原型
cpp 复制代码 
GMat cv::gapi::cmpGE 	
(
 	const GMat &  	src1,
	const GMat &  	src2 
)
参数：
  • 参数 src1: 第一个输入矩阵。
  • 参数 src2: 第二个输入矩阵或标量，其深度应与第一个输入矩阵相同。
代码示例
cpp 复制代码 
#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;
}
运行结果
bash 复制代码 
Element-wise greater or equal comparison result: 
[255, 255, 255;
 255, 255,   0;
   0,   0,   0]

"大于"比较操作函数cmpGT()

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

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

dst ( I ) = src1 ( I ) > src2 ( I ) \texttt{dst} (I) = \texttt{src1} (I) > \texttt{src2} (I) dst(I)=src1(I)>src2(I)

当比较结果为真时，输出数组中相应位置的元素被设置为 255。比较操作可以用等效的矩阵表达式替换：
dst = src1 > src2 \texttt{dst} = \texttt{src1} > \texttt{src2} dst=src1>src2

输出矩阵的深度必须是 CV_8U，并且必须与输入矩阵具有相同的尺寸和通道数。

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

注意：

该函数的文本ID是 "org.opencv.core.pixelwise.compare.cmpGT"

函数原型
cpp 复制代码 
GMat cv::gapi::cmpGT 
(
 	const GMat &  	src1,
	const GMat &  	src2 
)
参数
  • 参数src1: 第一个输入矩阵。
  • 参数src2: 第二个输入矩阵或标量，其深度应与第一个输入矩阵相同。
代码示例
cpp 复制代码 
#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;
}
运行结果
bash 复制代码 
Element-wise greater than comparison result: 
[255, 255, 255;
 255,   0,   0;
   0,   0,   0]

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

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

该函数比较两个相同大小的矩阵 src1 和 src2 的元素：
dst ( I ) = src1 ( I ) < = src2 ( I ) \texttt{dst} (I) = \texttt{src1} (I) <= \texttt{src2} (I) dst(I)=src1(I)<=src2(I)

当比较结果为真时，输出数组中相应位置的元素被设置为 255；否则为 0。比较操作可以用等效的矩阵表达式替换：
dst = src1 < = src2 \texttt{dst} = \texttt{src1} <= \texttt{src2} dst=src1<=src2

输出矩阵的深度必须是 CV_8U，并且必须与输入矩阵具有相同的尺寸和通道数。

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

注意：

该函数的文本ID是 "org.opencv.core.pixelwise.compare.cmpLE"

函数原型
cpp 复制代码 
GMat cv::gapi::cmpLE 	
(
 	const GMat &  	src1,
	const GMat &  	src2 
)
参数：
  • 参数src1: 第一个输入矩阵。
  • 参数src2: 第二个输入矩阵或标量，其深度应与第一个输入矩阵相同。
代码示例
cpp 复制代码 
#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;
}
运行结果
bash 复制代码 
Element-wise less or equal comparison result: 
[255, 255, 255;
 255, 255,   0;
   0,   0,   0]

"小于"比较操作函数cmpLT()

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

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

dst ( I ) = src1 ( I ) < src2 ( I ) \texttt{dst} (I) = \texttt{src1} (I) < \texttt{src2} (I) dst(I)=src1(I)<src2(I)

当比较结果为真时，输出数组中相应位置的元素被设置为 255；否则为 0。比较操作可以用等效的矩阵表达式替换：
dst = src1 < src2 \texttt{dst} = \texttt{src1} < \texttt{src2} dst=src1<src2

输出矩阵的深度必须是 CV_8U，并且必须与输入矩阵具有相同的尺寸和通道数。

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

注意：

该函数的文本ID是 "org.opencv.core.pixelwise.compare.cmpLT"

函数原型
cpp 复制代码 
GMat cv::gapi::cmpLT
(
 	const GMat &  	src1,
	const GMat &  	src2 
)
参数：
  • 参数src1: 第一个输入矩阵。
  • 参数src2: 第二个输入矩阵或标量，其深度应与第一个输入矩阵相同。
代码示例
cpp 复制代码 
#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;
}
运行结果
bash 复制代码 
Element-wise less than comparison result: 
[255, 255, 255;
 255,   0,   0;
   0,   0,   0]

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

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

该函数比较两个相同大小的矩阵 src1 和 src2 的元素：
dst ( I ) = src1 ( I ) ! = src2 ( I ) \texttt{dst} (I) = \texttt{src1} (I) != \texttt{src2} (I) dst(I)=src1(I)!=src2(I)

当比较结果为真时，输出数组中相应位置的元素被设置为 255；否则为 0。比较操作可以用等效的矩阵表达式替换：
dst = src1 ! = src2 \texttt{dst} = \texttt{src1} != \texttt{src2} dst=src1!=src2

输出矩阵的深度必须是 CV_8U，并且必须与输入矩阵具有相同的尺寸和通道数。

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

注意：

该函数的文本ID是 "org.opencv.core.pixelwise.compare.cmpNE"

函数原型
cpp 复制代码 
GMat cv::gapi::cmpNE 	
(
 	const GMat &  	src1,
	const GMat &  	src2 
)
参数：
  • 参数src1: 第一个输入矩阵。
  • 参数src2: 第二个输入矩阵或标量，其深度应与第一个输入矩阵相同。
代码示例
cpp 复制代码 
#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;
}
运行结果
bash 复制代码 
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"

函数原型
cpp 复制代码 
GMat cv::gapi::select 
(
 	const GMat &  	src1,
	const GMat &  	src2,
	const GMat &  	mask 
)
参数
  • 参数src1: 第一个输入矩阵。
  • 参数src2: 第二个输入矩阵。
  • 参数mask: 掩码输入矩阵。
代码示例
cpp 复制代码 
#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;
}
运行结果
bash 复制代码 
Element-wise selection result: 
[  9,   2,   7;
   4,   5,   6;
   3,   8,   1]

..................................................................完结..........................................................................................

相关推荐
新智元11 分钟前
刚刚，AI 破解 50 年未解数学难题！南大校友用 OpenAI 模型完成首个非平凡数学证明
人工智能·openai
美团技术团队17 分钟前
ICLR&CVPR 2025美团技术团队论文精选
人工智能
阿里云大数据AI技术18 分钟前
面向MoE和推理模型时代：阿里云大数据AI产品升级发布
大数据·人工智能·mcp
IT古董21 分钟前
【漫话机器学习系列】202.参数共享（Parameter Sharing）
人工智能
yuhouxiyang38 分钟前
学习海康VisionMaster之四边形查找
学习·计算机视觉
music&movie39 分钟前
调研大语言模型的知识编辑技术
人工智能·语言模型·自然语言处理
御宇w41 分钟前
(即插即用模块-特征处理部分) 三十二、(TGRS 2024) MDAF 多尺度双表示对齐过滤器
深度学习·计算机视觉·即插即用模块
知来者逆43 分钟前
计算机视觉——基于YOLOV8 的人体姿态估计训练与推理
深度学习·yolo·计算机视觉·yolov8·姿态估计
凡人的AI工具箱1 小时前
Pytorch深度学习框架60天进阶学习计划 - 第41天：生成对抗网络进阶（二）
人工智能·pytorch·深度学习·学习·生成对抗网络·自动化
安全方案1 小时前
2025阿里云AI 应用-AI Agent 开发新范式-MCP最佳实践-78页.pptx
人工智能·mcp·大模型上下文协议
热门推荐
01我决定放弃搞 Java 了02RAG 实践- Ollama+RagFlow 部署本地知识库03如何在WPS和Word/Excel中直接使用DeepSeek功能04游戏引擎学习第217天05DeepSeek RAGFlow构建本地知识库系统06DeepSeek各版本说明与优缺点分析07汽车上的各种质量：整备质量、总质量、装载质量、簧上质量、簧下质量08从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑09本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程10第八节：Nodify 编辑器属性