OpenCV（cv::multiply()）

• 1. 函数定义
• 2. 功能说明
• 3. 示例
  • 3.1 基础逐元素相乘
  • 3.2 带缩放因子的逐元素相乘
  • 3.3 处理不同数据类型
• 4. 注意事项
• 5. 高级用法
  • 5.1 使用掩码进行选择性相乘
• 总结

cv::multiply() 是 OpenCV 库中用于对两个数组（通常是图像）的对应元素进行逐元素相乘的函数。

1. 函数定义

namespace cv {
    void multiply(
        InputArray src1,
        InputArray src2,
        OutputArray dst,
        double scale = 1,
        int dtype = -1
    );
}

参数说明：

1. src1 (InputArray): 第一个输入数组，可以是多通道图像、单通道图像或多维数组。数据类型可以是 CV_8U, CV_16U, CV_32F 等。

2. src2 (InputArray): 第二个输入数组，必须与 src1 在大小和通道数上兼容。数据类型也可以是 CV_8U, CV_16U, CV_32F 等。

3. dst (OutputArray): 输出数组，用于存储逐元素相乘后的结果。输出数组的大小和类型由 dtype 决定。

4. scale (double, 可选): 缩放因子，默认值为 1。在相乘后，结果会被此因子缩放。例如，如果设置为 0.5，则结果会是相乘后的值的一半。

5. dtype (int, 可选): 输出数组的深度（数据类型）。默认值为 -1，表示输出数组与输入数组 src1 和 src2 的深度相同。可以指定为其他深度，如 CV_32F，以确保计算的精度或避免溢出。

2. 功能说明

cv::multiply() 执行两个输入数组的逐元素相乘，并将结果存储在输出数组中。具体操作为：

dst(I) = src1(I) * src2(I) * scale

其中，I 表示数组的每个索引位置。对于多通道图像，每个通道都会独立进行相乘操作。

3. 示例

以下是一些使用 cv::multiply() 的示例代码，展示了如何在不同场景下应用该函数。

3.1 基础逐元素相乘

#include <opencv2/opencv.hpp>
#include <iostream>

int main() {
    // 创建两个示例图像（单通道，浮点型）
    cv::Mat src1 = (cv::Mat_<float>(2,2) << 1.0, 2.0, 3.0, 4.0);
    cv::Mat src2 = (cv::Mat_<float>(2,2) << 5.0, 6.0, 7.0, 8.0);
    cv::Mat dst;

    // 逐元素相乘
    cv::multiply(src1, src2, dst);

    std::cout << "Result of multiply:\n" << dst << std::endl;

    return 0;
}

输出:

Result of multiply:
[5, 12;
 21, 32]

3.2 带缩放因子的逐元素相乘

#include <opencv2/opencv.hpp>
#include <iostream>

int main() {
    cv::Mat src1 = (cv::Mat_<float>(2,2) << 1.0, 2.0, 3.0, 4.0);
    cv::Mat src2 = (cv::Mat_<float>(2,2) << 5.0, 6.0, 7.0, 8.0);
    cv::Mat dst;

    // 逐元素相乘并缩放结果
    double scale = 0.5;
    cv::multiply(src1, src2, dst, scale);

    std::cout << "Result of multiply with scale 0.5:\n" << dst << std::endl;

    return 0;
}

输出:

Result of multiply with scale 0.5:
[2.5, 6;
 10.5, 16]

3.3 处理不同数据类型

#include <opencv2/opencv.hpp>
#include <iostream>

int main() {
    // 创建两个不同类型的图像
    cv::Mat src1 = (cv::Mat_<uchar>(2,2) << 100, 150, 200, 250);
    cv::Mat src2 = (cv::Mat_<float>(2,2) << 0.5, 0.4, 0.3, 0.2);
    cv::Mat dst;

    // 逐元素相乘，指定输出类型为浮点型
    cv::multiply(src1, src2, dst, 1.0, CV_32F);

    std::cout << "Result of multiply with different types:\n" << dst << std::endl;

    return 0;
}

输出:

Result of multiply with different types:
[50, 60;
 60, 50]

4. 注意事项

1. 数组大小和通道数匹配：输入的 src1 和 src2 必须具有相同的大小和通道数，或者其中一个输入为标量（单值），这种情况下标量会广播到另一个数组的所有元素。

2. 数据类型选择：在进行逐元素相乘时，选择合适的数据类型非常重要。例如，使用 CV_8U 可能导致溢出，因为两个 8 位无符号整数相乘的结果可能超过 255。为了避免溢出，可以选择更高精度的数据类型，如 CV_32F 或 CV_64F。

3. 性能优化：cv::multiply() 通常比手动编写循环进行逐元素相乘更高效，因为 OpenCV 内部对其进行了优化。

4. 替代函数： cv::multiply() 是执行逐元素相乘的一种方式，但 OpenCV 还提供了其他相关函数，如 cv::divide()、cv::add() 和 cv::subtract()，用于执行其他逐元素运算。此外，cv::Mat 类的成员函数 mul() 也可以实现类似的功能，例如：

   cv::Mat dst = src1.mul(src2, scale);
   

   这两种方法在功能上非常相似，选择使用哪种主要取决于编程风格和具体需求。

5. 高级用法

5.1 使用掩码进行选择性相乘

cv::multiply() 不直接支持掩码操作，但可以结合 OpenCV 的其他函数实现。例如，只对满足特定条件的像素进行相乘：

#include <opencv2/opencv.hpp>
#include <iostream>

int main() {
    cv::Mat src1 = (cv::Mat_<float>(3,3) << 1, 2, 3, 4, 5, 6, 7, 8, 9);
    cv::Mat src2 = (cv::Mat_<float>(3,3) << 9, 8, 7, 6, 5, 4, 3, 2, 1);
    cv::Mat mask, dst;

    // 创建掩码：仅乘以 src1 > 4 的元素
    cv::threshold(src1, mask, 4.0, 1.0, cv::THRESH_BINARY);

    // 转换掩码为同类型
    mask.convertTo(mask, src1.type());

    // 执行逐元素相乘
    cv::multiply(src1, src2, dst, 1.0, -1); // dtype = -1, 保持 src1 类型

    // 仅保留掩码为 1 的位置
    dst = dst.mul(mask);

    std::cout << "Result with mask:\n" << dst << std::endl;

    return 0;
}

输出:

Result with mask:
[0, 0, 0;
 0, 5*5=25, 6*4=24;
 7*3=21, 8*2=16, 9*1=9]

在这个示例中，只有 src1 中大于 4 的元素对应的位置会进行相乘，其他位置保持为 0。

总结

cv::multiply() 是一个功能强大的逐元素相乘函数，适用于各种图像处理和数值计算任务。通过合理选择参数和数据类型，可以实现高效且精确的逐元素操作。在实际应用中，结合其他 OpenCV 函数和技术，cv::multiply() 可以帮助开发者实现复杂的图像处理算法和数据分析任务。