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

news2025/4/17 17:09:25
  • 操作系统：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 计算输入矩阵每个元素的按位取反：
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”

函数原型
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 的元素：
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”

函数原型
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 的元素：
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”

函数原型
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 的元素：

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”

函数原型
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 的元素：
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”

函数原型
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 的元素：

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”

函数原型
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 的元素：
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”

函数原型
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]

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2330654.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

批量图片文本识别重命名，批量ocr识别图片重命名，基于WPF和腾讯OCR云部署实，现批量对图片局部提取文字后重命名的操作详细步骤

批量图片文本识别重命名，批量ocr识别图片重命名，基于WPF和腾讯OCR云部署实，现批量对图片局部提取文字后重命名的操作详细步骤

​​1. 项目背景​​ 在日常工作中，我们经常需要处理大量图片文件，这些图片可能包含重要的文字信息。为了提高工作效率，我们需要一种自动化的方式，从图片中提取文字，并根据提取的文字对图片进行重命名。 本项目基于 ​​WPF​​ 框架开发桌面应用程序，结合 ​​腾讯 OCR…
阅读更多...
Linux——冯 • 诺依曼体系结构操作系统初识

Linux——冯 • 诺依曼体系结构操作系统初识

目录 1. 冯 • 诺依曼体系结构 1.1 冯•诺依曼体系结构推导 1.2 内存提高冯•诺依曼体系结构效率的方法 1.3 理解数据流动 2. 初步认识操作系统 2.1 操作系统的概念 2.2 设计OS的目的 3. 操作系统的管理精髓 1. 冯 • 诺依曼体系结构 1.1 冯•诺依曼体系结构推导 计算…
阅读更多...
Vue3 实现进度条组件

Vue3 实现进度条组件

样式如下&#xff0c;代码如下 <script setup> import { computed, defineEmits, defineProps, onMounted, ref, watch } from vue// 定义 props const props defineProps({// 初始百分比initialPercentage: {type: Number,default: 0,}, })// 定义 emits const emits…
阅读更多...
35.[前端开发-JavaScript基础]Day12-for循环中变量-华为商城-商品列表-轮播图

35.[前端开发-JavaScript基础]Day12-for循环中变量-华为商城-商品列表-轮播图

for循环中监听函数中打印变量 <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><meta http-equiv"X-UA-Compatible" content"IEedge"><meta name"viewport" content"wi…
阅读更多...
【蓝桥杯】十五届省赛B组c++

【蓝桥杯】十五届省赛B组c++

目录 前言 握手问题 分析 排列组合写法 枚举 小球反弹 分析 代码 好数 分析 代码 R 格式 分析 代码 宝石组合 分析 代码 数字接龙 分析 代码 拔河 分析 代码 总结 前言 主播这两天做了一套蓝桥杯的省赛题目&#xff08;切实感受到了自己有多菜&#x…
阅读更多...
[Linux系统编程]多线程

[Linux系统编程]多线程

多线程 1. 线程1.1 线程的概念1.2 进程与线程对比1.3 轻量级进程 2. Linux线程控制2.1 POSIX 线程&#xff08;pthread&#xff09;2.2 线程ID、pthread_t、和进程地址空间的关系2.2.1 pthread_self2.2.2 pthread_create2.2.3 pthread_join2.2.4 线程终止的三种方式2.2.5 pthre…
阅读更多...
IntelliJ IDEA下开发FPGA——FPGA开发体验提升__下

IntelliJ IDEA下开发FPGA——FPGA开发体验提升__下

前言 由于Quartus写代码比较费劲&#xff0c;虽然新版已经有了代码补全&#xff0c;但体验上还有所欠缺。于是使用VS Code开发&#xff0c;效果如下所示&#xff0c;代码样式和基本的代码补全已经可以满足开发&#xff0c;其余工作则交由Quartus完成 但VS Code的自带的git功能&…
阅读更多...
odo18实施——销售-仓库-采购-制造-制造外包-整个流程自动化单据功能的演示教程

odo18实施——销售-仓库-采购-制造-制造外包-整个流程自动化单据功能的演示教程

安装模块 安装销售 、库存、采购、制造模块 2.开启外包功能 在进入制造应用点击 配置—>设置 勾选外包&#xff0c;点击保存 添加信息 一、添加客户信息 点击到销售应用 点击订单—>客户 点击新建 创建客户1&#xff0c;及其他客户相关信息&#xff0c;点…
阅读更多...
微信小程序生成某个具体页面的二维码

微信小程序生成某个具体页面的二维码

微信小程序&#xff0c;如果要生成某个具体页面&#xff0c;而非首页的二维码&#xff0c;体验和正式的生成方法如下&#xff1a; 1、体验版二维码&#xff1a; 管理---版本管理---修改页面路径&#xff0c;输入具体页面的路径以及参数&#xff0c;生成的是二维码 2、正式小程…
阅读更多...
鸿蒙开发_ARKTS快速入门_语法说明_组件声明_组件手册查看---纯血鸿蒙HarmonyOS5.0工作笔记010

鸿蒙开发_ARKTS快速入门_语法说明_组件声明_组件手册查看---纯血鸿蒙HarmonyOS5.0工作笔记010

然后我们来看如何使用组件 可以看到组件的组成 可以看到我们使用的组件 然后看一下组件的语法.组件中可以使用子组件. 然后组件中可以有参数,来修改组件的样式等 可以看到{},这种方式可以设置组件参数,当然在下面. 的方式也可以的 然后再来
阅读更多...
接口异常数组基础题

接口异常数组基础题

题目描述 设想你正在构建一个智能家居控制系统。这个系统可以连接多种不同类型的智能设备&#xff0c;如智能灯泡、智能空调和智能门锁。每种设备都有其独特的功能&#xff0c;不过它们也有一些通用的操作&#xff0c;像开启、关闭和获取设备状态等。系统需要提供一个方法来控…
阅读更多...
rustdesk折腾手记

rustdesk折腾手记

背景 我的工作环境&#xff1a;主力电脑是macPro, 另外一台ThinkPad W530作为开发机&#xff0c;装的是LinuxMint&#xff0c;还有一台ThinkPad P15作为服务器。平常显示器接到macPro&#xff0c;在macOS上通过微软的远程桌面连接到另外两台Linux。基本访问比较流畅&#xff0…
阅读更多...
使用el-tab 实现两个tab切换

使用el-tab 实现两个tab切换

1、主页面 index.vue 2、tab1&#xff1a;school.vue 3、tab2&#xff1a;parent.vue 具体代码如下&#xff1a; <template><div class"app-container"><!-- 使用el-tabs 实现两个组件的切换 --><el-tabs v-model"activeName" typ…
阅读更多...
使用Pholcus编写Go爬虫示例

使用Pholcus编写Go爬虫示例

想用Pholcus库来写一个Go的爬虫程序。首先&#xff0c;我得确认Pholcus的当前状态&#xff0c;因为之前听说过它可能已经不再维护了。不过用户可能还是需要基于这个库的示例&#xff0c;所以得先提供一个基本的框架。 首先&#xff0c;我应该回忆一下Pholcus的基本用法。Pholc…
阅读更多...
单片机实现触摸按钮执行自定义任务组件

单片机实现触摸按钮执行自定义任务组件

触摸按钮执行自定义任务组件 项目简介 本项目基于RT8H8K001开发板 RT6809CNN01开发板 TFT显示屏(1024x600) GT911触摸屏实现了一个多功能触摸按钮组件。系统具备按钮控制后执行任务的功能&#xff0c;可用于各类触摸屏人机交互场景。 硬件平台 MCU: STC8H8K64U&#xff0…
阅读更多...
Ai云防护技术解析——服务器数据安全的智能防御体系

Ai云防护技术解析——服务器数据安全的智能防御体系

本文深度解析AI云防护技术如何通过智能流量分析、动态行为建模、自适应防御策略构建服务器安全体系。结合2023年群联科技实战案例，揭示机器学习算法在识别新型DDoS攻击、加密流量检测、零日漏洞防御中的技术突破，并附Gartner最新防护效果验证数据。 AI驱动的流量特征建模技术…
阅读更多...
JSONP跨域访问漏洞

JSONP跨域访问漏洞

一、漏洞一:利用回调GetCookie <?php$conn new mysqli(127.0.0.1,root,root,learn) or die("数据库连接不成功"); $conn->set_charset(utf8); $sql "select articleid,author,viewcount,creattime from learn3 where articleid < 5"; $result…
阅读更多...
图形裁剪算法

图形裁剪算法

1.学习目标 理解区域编码(Region Code&#xff0c;RC) 设计Cohen-Sutherland直线裁剪算法 编程实现Cohen-Sutherland直线裁剪算法 2.具体代码 1.具体算法 /*** Cohen-Sutherland直线裁剪算法 - 优化版* author AI Assistant* license MIT*/// 区域编码常量 - 使用对象枚举…
阅读更多...
R 语言科研绘图第 36 期 --- 饼状图-基础

R 语言科研绘图第 36 期 --- 饼状图-基础

在发表科研论文的过程中&#xff0c;科研绘图是必不可少的&#xff0c;一张好看的图形会是文章很大的加分项。 为了便于使用&#xff0c;本系列文章介绍的所有绘图都已收录到了 sciRplot 项目中&#xff0c;获取方式&#xff1a; R 语言科研绘图模板 --- sciRplothttps://mp.…
阅读更多...
vue 3 从零开始到掌握

vue 3 从零开始到掌握

vue3从零开始一篇文章带你学习 升级vue CLI 使用命令 ## 查看vue/cli版本&#xff0c;确保vue/cli版本在4.5.0以上 vue --version ## 安装或者升级你的vue/cli npm install -g vue/cli ## 创建 vue create vue_test ## 启动 cd vue_test npm run servenvm管理node版本&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023