更改图像的对比度和亮度！

目录

• 目标
• 理论
  • 图像处理
  • 像素变换
  • 亮度和对比度调整
• 代码
• 解释
• 结果
• 实际示例
  • 亮度和对比度调整
  • 伽马校正
  • 校正曝光不足的图像
  • 代码
  • 附加资源

上一教程： 使用 OpenCV 添加（混合）两张图像
下一教程： 离散傅里叶变换

原作者	Ana Huamán
兼容性	OpenCV >= 3.0

目标

在本教程中，您将学习如何：

• 访问像素值
• 用零初始化矩阵
• 了解cv::saturate_cast的作用及其用途
• 获取一些关于像素变换的实用信息
• 通过实际示例改进图像亮度

理论

注意

以下解释来自 Richard Szeliski 编著的书籍 Computer Vision: Algorithms and Applications

图像处理

• 一般的图像处理算子是一个函数，它接受一个或多个输入图像并产生一个输出图像。
• 图像变换可以看作：
  • 点算子（像素变换）
  • 邻域（基于区域）算子

像素变换

• 在这种图像处理变换中，每个输出像素的值仅取决于相应的输入像素值（加上可能的一些全局收集的信息或参数）。
• 此类算子的示例包括亮度和对比度调整以及颜色校正和变换。

亮度和对比度调整

• 两个常用的点过程是与常数的乘法和加法

  \[g(x) = \alpha f(x) + \beta\]

• 参数\(\alpha > 0\)和\(\beta\)通常被称为增益和偏差参数；有时这些参数分别被称为控制对比度和亮度。

• 您可以将\(f(x)\)视为源图像像素，将\(g(x)\)视为输出图像像素。然后，我们可以更方便地将表达式写成

  \[g(i,j) = \alpha \cdot f(i,j) + \beta\]

  其中\(i\)和\(j\)表示像素位于第i行和第j列。

代码

C++

• 可下载代码：点击 此处
• 以下代码执行操作\(g(i,j) = \alpha \cdot f(i,j) + \beta\)

   
  #include "opencv2/imgcodecs.hpp"
  #include "opencv2/highgui.hpp"
  #include <iostream>
   
  // 我们在这里不使用“using namespace std;”，以避免 c++17 中 beta 变量和 std::beta 之间的冲突
  using std::cin;
  using std::cout;
  using std::endl;
  using namespace cv;
   
  int main( int argc, char** argv )
  {
      CommandLineParser parser( argc, argv, "{@input | lena.jpg | input image}" );
      Mat image = imread( samples::findFile( parser.get<String>( "@input" ) ) );
      if( image.empty() )
      {
  cout << "无法打开或找到图像！\n" << endl;
  cout << "用法：" << argv[0] << " <输入图像>" << endl;
        return -1; -1;
      }
   
      Mat new_image = Mat::zeros( image.size(), image.type() );
   
      double alpha = 1.0; /*< 简单对比度控制 */
      int beta = 0; /*< 简单亮度控制 */
   
  cout << " 基本线性变换 " << endl;
  cout << "-------------------------" << endl;
  cout << "* 输入 alpha 值 [1.0-3.0]："; cin >> alpha;
  cout << "* 输入 beta 值 [0-100]："; cin >> beta;
   
      for( int y = 0; y < image.rows; y++ ) {
          for( int x = 0; x < image.cols; x++ ) {
              for( int c = 0; c < image.channels(); c++ ) {
  new_image.at<Vec3b>(y,x)[c] =
  saturate_cast<uchar>( alpha*image.at<Vec3b>(y,x)[c] + beta );
              }
          }
      }
   
      }
      }
   
      }();
      return -1; 0;
  }

Java

• 可下载代码：点击 此处
• 以下代码执行操作\(g(i,j) = \alpha \cdot f(i,j) + \beta\)

  import java.util.Scanner;
   
  import org.opencv.core.Core;
  import org.opencv.core.Mat;
  import org.opencv.highgui.HighGui;
  import org.opencv.imgcodecs.Imgcodecs;
   
  class BasicLinearTransforms {
      private byte saturate(double val) {
          int iVal = (int) Math.round(val);
  iVal = iVal > 255 ? 255 : (iVal < 0 ? 0 : iVal);
          return (byte) iVal;
      }
   
      public void run(String[] args) {
  String imagePath = args.length > 0 ? args[0] : "../data/lena.jpg";
  Mat image = Imgcodecs.imread(imagePath);
          if (image.empty()) {
  System.out.println("空图像: " + imagePath);
  System.exit(0);
          }
   
  Mat newImage = Mat.zeros(image.size(), image.type());
   
          double alpha = 1.0; /*< 简单对比度控制 */
          int beta = 0; /*< 简单亮度控制 */
   
  System.out.println(" 基本线性变换 ");
  System.out.println("-------------------------");
          try (Scanner scanner = new Scanner(System.in)) {
  System.out.print("* 输入 alpha 值 [1.0-3.0]: ");
  alpha = scanner.nextDouble();
  System.out.print("* 输入 beta 值 [0-100]: ");
  beta = scanner.nextInt();
          }
   
          byte[] imageData = new byte[(int) (image.total()*image.channels())];
  image.get(0, 0, imageData);
          byte[] newImageData = new byte[(int) (newImage.total()*newImage.channels())];
          for (int y = 0; y < image.rows(); y++) {
              for (int x = 0; x < image.cols(); x++) {
                  for (int c = 0; c < image.channels(); c++) {
                      double pixelValue = imageData[(y * image.cols() + x) * image.channels() + c];
  pixelValue = pixelValue < 0 ? pixelValue + 256 : pixelValue;
  newImageData[(y * image.cols() + x) * image.channels() + c]
  = saturate(alpha * pixelValue + beta);
                  }
              }
          }
  newImage.put(0, 0, newImageData);
   
  HighGui.imshow("原始图像", image);
  HighGui.imshow("新图像", newImage);
   
  HighGui.waitKey();
  System.exit(0);
      }
  }
   
  public class BasicLinearTransformsDemo {
      public static void main(String[] args) {
          // 加载原生 OpenCV 库
  System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
   
          new BasicLinearTransforms().run(args);
      }
  }

Python

• 可下载代码：点击 此处
• 以下代码执行操作\(g(i,j) = \alpha \cdot f(i,j) + \beta\)

  from __future__ import print_function
  from builtins import input
  import cv2 as cv
  import numpy as np
  import argparse
   
  # 读取用户提供的图像
   
  parser = argparse.ArgumentParser(description='更改图像对比度和亮度的代码！教程。')
  parser.add_argument('--input', help='输入图像路径。', default='lena.jpg')
  args = parser.parse_args()
   
  image = cv.imread(cv.samples.findFile(args.input))
  if image is None
  print('无法打开或找到图像: ', args.input)
  exit(0)
   
   
   
  new_image = np.zeros(image.shape, image.dtype)
   
   
   
  alpha = 1.0 # 简单对比度控制
  beta = 0 # 简单亮度控制
   
  # 初始化值
  print(' 基本线性变换 ')
  print('-------------------------')
  try:
  alpha = float(input('* 输入 alpha 值 [1.0-3.0]: '))
  beta = int(input('* 输入 beta 值 [0-100]: '))
  except ValueError
  print('错误，不是数字')
   
   
  # 执行操作 new_image(i,j) = alpha*image(i,j) + beta
  #  我们本可以使用以下代码代替这些 for 循环
  # new_image = cv.convertScaleAbs(image, alpha=alpha, beta=beta)
  # 但我们想向您展示如何访问像素 :)
   
  for y in range(image.shape[0])
      for x in range(image.shape[1])
          for c in range(image.shape[2])
  new_image[y,x,c] = np.clip(alpha*image[y,x,c] + beta, 0, 255)
   
   
   
  cv.imshow('原始图像', image)
  cv.imshow('新图像', new_image)
   
  # 等待用户按下某个键
  cv.waitKey()
   

解释

• 我们使用 cv::imread 加载图像并将其保存在 Mat 对象中

C++

    CommandLineParser parser( argc, argv, "{@input | lena.jpg | input image}" );
    Mat image = imread( samples::findFile( parser.get<String>( "@input" ) ) );
    if( image.empty() )
    {
cout << "无法打开或找到图像！\n" << endl;
cout << "用法：" << argv[0] << " <输入图像>" << endl;
      return -1; -1;
    }

Java

        String imagePath = args.length > 0 ? args[0] : "../data/lena.jpg";
Mat image = Imgcodecs.imread(imagePath);
        if (image.empty()) {
System.out.println("空图像: " + imagePath);
System.exit(0);
        }

Python

parser = argparse.ArgumentParser(description='更改图像对比度和亮度的代码！教程。')
parser.add_argument('--input', help='输入图像路径。', default='lena.jpg')
args = parser.parse_args()
 
image = cv.imread(cv.samples.findFile(args.input))
if image is None
print('无法打开或找到图像: ', args.input)
exit(0)

• 现在，由于我们将对该图像进行一些变换，因此我们需要一个新的 Mat 对象来存储它。此外，我们希望它具有以下特性：
  • 初始像素值等于零
  • 与原始图像大小和类型相同

C++

    Mat new_image = Mat::zeros( image.size(), image.type() );

Java

Mat newImage = Mat.zeros(image.size(), image.type());

Python

new_image = np.zeros(image.shape, image.dtype)

我们观察到 cv::Mat::zeros 基于 image.size() 和 image.type() 返回一个 Matlab 风格的零初始化器

• 我们现在要求用户输入 \(\alpha\) 和 \(\beta\) 的值

C++

    double alpha = 1.0; /*< 简单对比度控制 */
    int beta = 0; /*< 简单亮度控制 */
 
cout << " 基本线性变换 " << endl;
cout << "-------------------------" << endl;
cout << "* 输入 alpha 值 [1.0-3.0]："; cin >> alpha;
cout << "* 输入 beta 值 [0-100]："; cin >> beta;

Java

        double alpha = 1.0; /*< 简单对比度控制 */
        int beta = 0; /*< 简单亮度控制 */
 
System.out.println(" 基本线性变换 ");
System.out.println("-------------------------");
        try (Scanner scanner = new Scanner(System.in)) {
System.out.print("* 输入 alpha 值 [1.0-3.0]: ");
alpha = scanner.nextDouble();
System.out.print("* 输入 beta 值 [0-100]: ");
beta = scanner.nextInt();
        }

Python

alpha = 1.0 # 简单对比度控制
beta = 0 # 简单亮度控制
 
# 初始化值
print(' 基本线性变换 ')
print('-------------------------')
try:
alpha = float(input('* 输入 alpha 值 [1.0-3.0]: '))
beta = int(input('* 输入 beta 值 [0-100]: '))
except ValueError
print('错误，不是数字')

• 现在，为了执行操作 \(g(i,j) = \alpha \cdot f(i,j) + \beta\)，我们将访问图像中的每个像素。由于我们使用的是 BGR 图像，每个像素将有三个值 (B、G 和 R)，因此我们也将分别访问它们。以下是代码片段：

C++

    for( int y = 0; y < image.rows; y++ ) {
        for( int x = 0; x < image.cols; x++ ) {
            for( int c = 0; c < image.channels(); c++ ) {
new_image.at<Vec3b>(y,x)[c] =
saturate_cast<uchar>( alpha*image.at<Vec3b>(y,x)[c] + beta );
            }
        }
    }

Java

        byte[] imageData = new byte[(int) (image.total()*image.channels())];
image.get(0, 0, imageData);
        byte[] newImageData = new byte[(int) (newImage.total()*newImage.channels())];
        for (int y = 0; y < image.rows(); y++) {
            for (int x = 0; x < image.cols(); x++) {
                for (int c = 0; c < image.channels(); c++) {
                    double pixelValue = imageData[(y * image.cols() + x) * image.channels() + c];
pixelValue = pixelValue < 0 ? pixelValue + 256 : pixelValue;
newImageData[(y * image.cols() + x) * image.channels() + c]
= saturate(alpha * pixelValue + beta);
                }
            }
        }
newImage.put(0, 0, newImageData);

Python

for y in range(image.shape[0])
    for x in range(image.shape[1])
        for c in range(image.shape[2])
new_image[y,x,c] = np.clip(alpha*image[y,x,c] + beta, 0, 255)

注意以下几点 (**仅限 C++ 代码**)

• 访问图像中每个像素点，我们使用以下语法：image.at<Vec3b>(y,x)[c]，其中y表示行，x表示列，c表示B、G或R通道（0、1或2）。
• 由于运算\(\alpha \cdot p(i,j) + \beta\)可能产生超出范围的值或非整数（如果\(\alpha\)为浮点数），我们使用cv::saturate_cast来确保值有效。
• 最后，我们以通常的方式创建窗口并显示图像。

C++

    }
    }
 
    }();

Java

HighGui.imshow("原始图像", image);
HighGui.imshow("新图像", newImage);
 
HighGui.waitKey();

Python

cv.imshow('原始图像', image)
cv.imshow('新图像', new_image)
 
# 等待用户按下某个键
cv.waitKey()

注意

无需使用for循环访问每个像素，我们可以简单地使用以下命令：

C++

image.convertTo(new_image, -1, alpha, beta);

Java

image.convertTo(newImage, -1, alpha, beta);

Python

new_image = cv.convertScaleAbs(image, alpha=alpha, beta=beta)

其中cv::Mat::convertTo将有效地执行*new_image = a*image + beta*。但是，我们想向您展示如何访问每个像素。无论哪种方法，结果都相同，但convertTo方法经过优化，速度更快。

结果

• 运行我们的代码，使用\(\alpha = 2.2\)和\(\beta = 50\)

  $ ./BasicLinearTransforms lena.jpg
  基本线性变换
  -------------------------
  * 输入alpha值 [1.0-3.0]：2.2
  * 输入beta值 [0-100]：50

• 我们得到：

实践示例

在本段中，我们将运用所学知识，通过调整图像的亮度和对比度来校正曝光不足的图像。我们还将看到另一种校正图像亮度的技术，称为伽马校正。

亮度和对比度调整

增加/减少\(\beta\)值将向每个像素添加/减去一个常数值。像素值超出[0；255]范围将被饱和（即，高于255/低于0的像素值将被钳位到255/0）。

浅灰色表示原始图像的直方图，深灰色表示在GIMP中亮度为80时的直方图。

直方图表示对于每个颜色级别，具有该颜色级别的像素数量。暗图像将有很多具有低颜色值的像素，因此直方图在其左侧将出现峰值。添加常数偏差时，直方图将向右移动，因为我们已向所有像素添加了常数偏差。

\(\alpha\)参数将修改级别的扩展方式。如果\( \alpha < 1 \)，颜色级别将被压缩，结果将是对比度较低的图像。

浅灰色表示原始图像的直方图，深灰色表示在GIMP中对比度< 0时的直方图。

请注意，这些直方图是使用GIMP软件中的亮度-对比度工具获得的。亮度工具应与\(\beta\)偏差参数相同，但对比度工具似乎与\(\alpha\)增益不同，其中输出范围在GIMP中似乎居中（正如您在上一个直方图中注意到的那样）。

使用\(\beta\)偏差可能会改善亮度，但同时图像可能会出现轻微的薄雾，因为对比度会降低。\(\alpha\)增益可用于减少这种影响，但由于饱和度，我们将丢失原始明亮区域中的某些细节。

伽马校正

伽马校正可用于通过使用输入值和映射输出值之间的非线性变换来校正图像的亮度。

\[O = \left( \frac{I}{255} \right)^{\gamma} \times 255\]

由于此关系是非线性的，因此对所有像素的影响将不同，并且取决于它们的原始值。

不同伽马值的曲线图

当\( \gamma < 1 \)时，原始暗区将更亮，直方图将向右移动，而当\( \gamma > 1 \)时则相反。

校正曝光不足的图像

下图已使用以下参数进行校正：\( \alpha = 1.3 \) 和 \( \beta = 40 \)。

By Visem (Own work) [CC BY-SA 3.0], via Wikimedia Commons

整体亮度得到了改善，但是您可以注意到，由于所用实现的数值饱和度（在摄影中称为高光剪切），云现在严重饱和。

下图已使用以下参数进行校正：\( \gamma = 0.4 \)。

By Visem (Own work) [CC BY-SA 3.0], via Wikimedia Commons

伽马校正应倾向于减少饱和度效应，因为映射是非线性的，并且与之前的方法不同，不存在数值饱和的可能性。

左：alpha、beta校正后的直方图；中：原始图像的直方图；右：伽马校正后的直方图

上图比较了三张图像的直方图（三个直方图之间的y范围不同）。您可以注意到，对于原始图像，大多数像素值位于直方图的下部。经过\(\alpha\)，\(\beta\)校正后，我们可以观察到由于饱和度而在255处出现一个大峰值，以及向右的偏移。伽马校正后，直方图向右移动，但暗区中的像素移动得更多（参见伽马曲线图）比亮区中的像素。

在本教程中，您已经看到了两种调整图像对比度和亮度的简单方法。这些是基本技术，并非旨在替代光栅图形编辑器！

代码

C++

本教程的代码在此。

Java

本教程的代码在此。

Python

本教程的代码在此。

伽马校正代码

C++

    Mat lookUpTable(1, 256, CV_8U);
    uchar* p = lookUpTable.ptr();
    for (int i = 0; i < 256; ++i)
p[i] = saturate_cast(pow(i / 255.0, gamma_) * 255.0);
 
    Mat res = img.clone();
    LUT(img, lookUpTable, res);

Java

Mat lookUpTable = new Mat(1, 256, CvType.CV_8U);
        byte[] lookUpTableData = new byte[(int) (lookUpTable.total()*lookUpTable.channels())];
        for (int i = 0; i < lookUpTable.cols(); i++) {
lookUpTableData[i] = saturate(Math.pow(i / 255.0, gammaValue) * 255.0);
        }
lookUpTable.put(0, 0, lookUpTableData);
Mat img = new Mat();
Core.LUT(matImgSrc, lookUpTable, img);

Python

lookUpTable = np.empty((1,256), np.uint8)
    for i in range(256)
lookUpTable[0,i] = np.clip(pow(i / 255.0, gamma) * 255.0, 0, 255)
 
res = cv.LUT(img_original, lookUpTable)

使用查找表可以提高计算性能，因为只需要计算一次256个值。

额外资源

• 图形渲染中的伽马校正
• 阴极射线管显示器上显示的图像的伽马校正
• 数字曝光技术