[opencvsharp]Cv2.Add和Cv2.AddWeighted区别

函数

  1. 功能:Cv2.Add函数用于执行矩阵或图像的逐元素加法。它支持两张图像的加法,也支持图像与常数值的加法,甚至可以通过掩膜(mask)来限制加法的区域。
  2. 参数:主要参数包括输入图像或矩阵src1和src2(其中src2也可以是标量常数),输出图像或矩阵dst,以及可选的掩膜mask和输出图像的数据类型dtype。
  3. 处理溢出:Cv2.Add函数会自动处理像素值的溢出,确保结果不超过图像数据类型的最大值(例如,对于8位图像,像素值在0到255之间)。如果像素值相加超过这个范围,它会被限制在这个范围内。
  4. 应用场景:适用于需要逐元素相加两张图像或图像与常数的场景,如图像增强、背景去除等。

Cv2.AddWeighted函数

  1. 功能:Cv2.AddWeighted函数用于对两张图像进行加权合成,从而生成一张新的图像。它通过加权和的方式将两张图像进行融合。
  2. 参数:主要参数包括输入图像src1和src2,图像1的权重alpha,图像2的权重beta,加到加权和中的常数gamma,以及输出图像dst。
  3. 工作原理:Cv2.AddWeighted函数执行的是图像加权平均的操作,其数学表达式为dst(x, y) = alpha * src1(x, y) + beta * src2(x, y) + gamma。其中,dst(x, y)是输出图像在位置(x, y)处的像素值,src1(x, y)和src2(x, y)是输入图像在位置(x, y)处的像素值。
  4. 应用场景:适用于图像叠加、调整图像透明度、亮度调整等场景。通过调整alpha和beta的值,可以实现两张图像的平滑过渡和合成效果。

区别总结

  1. 操作类型:Cv2.Add执行的是逐元素加法,而Cv2.AddWeighted执行的是加权平均操作。
  2. 参数差异:Cv2.Add主要参数包括输入图像或矩阵、输出图像或矩阵以及可选的掩膜和数据类型;而Cv2.AddWeighted则包括输入图像、权重、常数偏移量和输出图像。
  3. 应用场景:Cv2.Add适用于需要逐元素相加的场景;而Cv2.AddWeighted则更适用于图像叠加、透明度调整和亮度调整等场景。

综上所述,Cv2.Add和Cv2.AddWeighted在功能、参数和应用场景上存在显著差异,选择哪个函数取决于具体的图像处理需求。

在 OpenCVSharp 中,Cv2.Add() 函数用于执行矩阵或图像的逐元素加法。它不仅支持两张图像的加法,还支持图像与常数值的加法,甚至可以通过掩膜(mask)来限制加法的区域。

Cv2.Add() 函数原型
Cv2.Add(Mat src1, Mat src2, Mat dst, Mat mask = null, int dtype = -1);
    • src1: 输入图像或矩阵1(Mat 类型)。
    • src2: 输入图像或矩阵2(Mat 类型)或者标量常数(Scalar 类型)。
    • dst: 输出图像或矩阵,保存加法结果(Mat 类型)。
    • mask(可选):掩膜,用于指定在图像的哪些区域进行加法操作。掩膜是一个单通道的二值图像,默认值为 null,表示对整个图像进行加法。
    • dtype(可选):输出图像的数据类型,默认为 -1,表示与输入图像相同的数据类型。
    主要功能
    1. 图像与图像相加:两张大小和通道数相同的图像逐元素相加。
    2. 图像与常数相加:图像的每个像素值与一个常数值逐元素相加。
    3. 处理溢出:自动处理像素值的溢出,确保结果不超过图像数据类型的最大值(例如,0-255 范围对于 8 位图像)。
    示例 1:图像与图像相加

    在下面的示例中,我们将加载两张大小相同的图像,并将它们进行逐元素相加:

    using OpenCvSharp;
    
    class Program
    {
        static void Main(string[] args)
        {
            // 加载两张图像
            Mat img1 = Cv2.ImRead("image1.jpg");
            Mat img2 = Cv2.ImRead("image2.jpg");
    
            // 创建一个输出图像
            Mat result = new Mat();
    
            // 图像逐元素相加
            Cv2.Add(img1, img2, result);
    
            // 显示结果
            Cv2.ImShow("Result", result);
            Cv2.WaitKey(0);
            Cv2.DestroyAllWindows();
        }
    }
    
      解释:
      • Cv2.Add(img1, img2, result):执行 img1 和 img2 的逐元素加法,结果保存在 result 中。
      • Cv2.ImShow("Result", result):显示加法结果。
      示例 2:图像与常数相加

      在这个例子中,我们将图像的每个像素值加上一个常数(比如 50)。Scalar 类可以用来定义每个颜色通道上的常数值。

      using OpenCvSharp;
      
      class Program
      {
          static void Main(string[] args)
          {
              // 加载图像
              Mat img = Cv2.ImRead("image.jpg");
      
              // 创建一个常数 Scalar,每个通道加 50
              Scalar scalar = new Scalar(50, 50, 50); // BGR 通道加 50
      
              // 创建输出图像
              Mat result = new Mat();
      
              // 图像与常数相加
              Cv2.Add(img, scalar, result);
      
              // 显示结果
              Cv2.ImShow("Result", result);
              Cv2.WaitKey(0);
              Cv2.DestroyAllWindows();
          }
      }
      
        解释:
        • Scalar(50, 50, 50):这是一个表示每个 BGR 通道加 50 的常量。
        • Cv2.Add(img, scalar, result):将 img 的每个像素与常数 scalar 相加,结果保存在 result 中。
        示例 3:图像加法并处理溢出

        在进行图像加法时,可能会遇到像素值超出有效范围(例如,对于 8 位图像,像素值应该在 0 到 255 之间)。Cv2.Add 会自动处理这种情况,确保输出图像的像素值不会超出该范围。

        假设我们有两张图像,它们的像素值相加后可能会超过 255:

        using OpenCvSharp;
        
        class Program
        {
            static void Main(string[] args)
            {
                // 加载两张图像
                Mat img1 = Cv2.ImRead("image1.jpg");
                Mat img2 = Cv2.ImRead("image2.jpg");
        
                // 创建输出图像
                Mat result = new Mat();
        
                // 图像逐元素相加,可能会有溢出
                Cv2.Add(img1, img2, result);
        
                // 显示结果
                Cv2.ImShow("Result", result);
                Cv2.WaitKey(0);
                Cv2.DestroyAllWindows();
            }
        }
        
          解释:
          • 如果 img1 和 img2 中的某些像素值相加超过 255,Cv2.Add 会将其自动限制在 255。
          示例 4:使用掩膜区域进行加法

          如果你只想在图像的某些区域进行加法,可以使用掩膜(mask)。掩膜是一个单通道图像,它指定了哪些区域参与加法操作。

          using OpenCvSharp;
          
          class Program
          {
              static void Main(string[] args)
              {
                  // 加载图像
                  Mat img = Cv2.ImRead("image.jpg");
          
                  // 创建一个与 img 相同大小的掩膜(全白,表示所有区域都参与加法)
                  Mat mask = Mat.Ones(img.Size(), MatType.CV_8U); // 可以使用其他形状的掩膜
          
                  // 创建一个常数 Scalar
                  Scalar scalar = new Scalar(50, 50, 50);
          
                  // 创建输出图像
                  Mat result = new Mat();
          
                  // 图像与常数相加,并应用掩膜
                  Cv2.Add(img, scalar, result, mask);
          
                  // 显示结果
                  Cv2.ImShow("Result", result);
                  Cv2.WaitKey(0);
                  Cv2.DestroyAllWindows();
              }
          }
          
            解释:
            • Mat.Ones(img.Size(), MatType.CV_8U) 创建了一个与 img 大小相同的掩膜矩阵,所有值为 1(即全白,表示所有像素都参与加法)。
            • Cv2.Add(img, scalar, result, mask):对指定区域(根据掩膜 mask)进行加法。
            总结

            Cv2.Add() 是 OpenCVSharp 中一个非常有用的函数,可以执行图像与图像之间的逐元素加法,或图像与常数之间的加法。它能够自动处理加法过程中的溢出,并且支持使用掩膜对特定区域进行加法。

            Cv2.AddWeighted() 是 OpenCVSharp 中用来对两张图像进行加权合成的函数。它通过加权和的方式将两张图像进行融合,从而生成一张新的图像。此函数的主要用途包括图像叠加、调整图像透明度等。

            函数原型
            Cv2.AddWeighted(
                Mat src1,      // 输入图像 1
                double alpha,  // 图像 1 的权重(透明度)
                Mat src2,      // 输入图像 2
                double beta,   // 图像 2 的权重
                double gamma,  // 加到加权和中的常数
                Mat dst        // 输出图像
            );
            
              参数说明:
              • src1:输入图像 1,类型为 Mat,它将参与加权运算的第一张图像。
              • alpha:浮动类型,图像 1 的权重。它控制图像 1 在加权和中的贡献,取值范围通常在 [0, 1] 之间。如果值较大,则图像 1 的影响较大,图像 2 的影响较小。
              • src2:输入图像 2,类型为 Mat,参与加权运算的第二张图像。
              • beta:浮动类型,图像 2 的权重。它控制图像 2 在加权和中的贡献,取值范围通常在 [0, 1] 之间。如果值较大,则图像 2 的影响较大,图像 1 的影响较小。
              • gamma:浮动类型,常数偏移量。它将在加权和的结果中加上一个常数值 gamma,这个值可以用于调整最终结果的亮度或对比度。
              • dst:输出图像,类型为 Mat,存储最终的加权合成结果。
              函数工作原理

              Cv2.AddWeighted() 执行的是图像加权平均的操作,其数学表达式为:

              [
              dst(x, y) = \alpha \cdot src1(x, y) + \beta \cdot src2(x, y) + \gamma
              ]

              这里:

              • dst(x, y) 是输出图像在位置 (x, y) 处的像素值。
              • src1(x, y) 和 src2(x, y) 是输入图像 1 和输入图像 2 在位置 (x, y) 处的像素值。
              • alpha 和 beta 分别是图像 1 和图像 2 的权重。
              • gamma 是一个常数偏移量,会加到所有像素值的计算结果中。

              通常用于控制两张图像的融合效果,其中:

              • 如果 alpha 为 1,beta 为 0,则结果完全是图像 1。
              • 如果 alpha 为 0,beta 为 1,则结果完全是图像 2。
              • gamma 可以用来调整最终图像的亮度。
              常见应用
              1. 图像融合(Image Blending):通过调整 alpha 和 beta,可以实现两张图像的平滑过渡,生成合成图像。
              2. 透明度调整(Transparency or Opacity adjustment):通过设置权重 alpha 和 beta 来控制图像的透明度或叠加效果。
              3. 亮度调整(Brightness Adjustment):通过调节 gamma 值来增加或减少图像的亮度。
              4. 图像合成(Image Composition):将两张图像叠加在一起,如在合成合成图像时叠加水印。
              使用示例
              示例 1:基本图像加权融合
              using OpenCvSharp;
              
              class Program
              {
                  static void Main(string[] args)
                  {
                      // 加载两张图像
                      Mat img1 = Cv2.ImRead("image1.jpg");
                      Mat img2 = Cv2.ImRead("image2.jpg");
              
                      // 创建输出图像
                      Mat result = new Mat();
              
                      // 设置权重,alpha = 0.7, beta = 0.3
                      double alpha = 0.7;  // 图像1的权重
                      double beta = 0.3;   // 图像2的权重
                      double gamma = 0;    // 常数偏移量
              
                      // 合成图像
                      Cv2.AddWeighted(img1, alpha, img2, beta, gamma, result);
              
                      // 显示结果
                      Cv2.ImShow("Blended Image", result);
                      Cv2.WaitKey(0);
                      Cv2.DestroyAllWindows();
                  }
              }
              
                解释:
                • alpha = 0.7 表示图像 1 对最终结果的贡献占 70%。
                • beta = 0.3 表示图像 2 对最终结果的贡献占 30%。
                • gamma = 0,意味着没有额外的亮度偏移。
                • 结果图像是两张图像按上述比例加权合成的图像。
                示例 2:使用常数偏移量调整亮度
                using OpenCvSharp;
                
                class Program
                {
                    static void Main(string[] args)
                    {
                        // 加载两张图像
                        Mat img1 = Cv2.ImRead("image1.jpg");
                        Mat img2 = Cv2.ImRead("image2.jpg");
                
                        // 创建输出图像
                        Mat result = new Mat();
                
                        // 设置权重,alpha = 0.5, beta = 0.5, gamma = 50
                        double alpha = 0.5;  // 图像1的权重
                        double beta = 0.5;   // 图像2的权重
                        double gamma = 50;   // 常数偏移量(调整亮度)
                
                        // 合成图像
                        Cv2.AddWeighted(img1, alpha, img2, beta, gamma, result);
                
                        // 显示结果
                        Cv2.ImShow("Brightened Image", result);
                        Cv2.WaitKey(0);
                        Cv2.DestroyAllWindows();
                    }
                }
                
                  解释:
                  • gamma = 50,这将所有加权和的像素值增加 50,以便让最终图像变得更亮。这个偏移量可以增加或减少图像的亮度。
                  示例 3:图像透明度调整
                  using OpenCvSharp;
                  
                  class Program
                  {
                      static void Main(string[] args)
                      {
                          // 加载两张图像
                          Mat img1 = Cv2.ImRead("background.jpg");
                          Mat img2 = Cv2.ImRead("overlay.png");
                  
                          // 创建输出图像
                          Mat result = new Mat();
                  
                          // 设置权重,alpha = 0.5, beta = 0.5
                          double alpha = 0.5;  // 背景图像的权重
                          double beta = 0.5;   // 覆盖图像的权重
                          double gamma = 0;    // 常数偏移量
                  
                          // 合成图像
                          Cv2.AddWeighted(img1, alpha, img2, beta, gamma, result);
                  
                          // 显示结果
                          Cv2.ImShow("Transparent Overlay", result);
                          Cv2.WaitKey(0);
                          Cv2.DestroyAllWindows();
                      }
                  }
                  
                  解释:
                  • 在这个示例中,alpha 和 beta 都为 0.5,意味着背景图像和覆盖图像各占 50% 的权重。gamma 为 0,因此没有添加额外的亮度调整。
                  总结

                  Cv2.AddWeighted() 是 OpenCVSharp 中非常实用的图像处理函数,它通过加权平均的方式将两张图像融合在一起,并且可以通过调整权重(alphabeta)和常数偏移量(gamma)来控制最终图像的效果。常见应用包括图像融合、透明度调整、亮度调整等。

                  评论 1
                  添加红包

                  请填写红包祝福语或标题

                  红包个数最小为10个

                  红包金额最低5元

                  当前余额3.43前往充值 >
                  需支付:10.00
                  成就一亿技术人!
                  领取后你会自动成为博主和红包主的粉丝 规则
                  hope_wisdom
                  发出的红包

                  打赏作者

                  FL1623863129

                  你的打赏是我写文章最大的动力

                  ¥1 ¥2 ¥4 ¥6 ¥10 ¥20
                  扫码支付:¥1
                  获取中
                  扫码支付

                  您的余额不足,请更换扫码支付或充值

                  打赏作者

                  实付
                  使用余额支付
                  点击重新获取
                  扫码支付
                  钱包余额 0

                  抵扣说明:

                  1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
                  2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

                  余额充值