.. _Basic_Linear_Transform:

改变图像的对比度和亮度
***************************************************

目的
=====

本篇教程中，你将学到：

.. container:: enumeratevisibleitemswithsquare

   + 访问像素值 

   + 用0初始化矩阵

   + :saturate_cast:`saturate_cast <>` 是做什么用的，以及它为什么有用

   + 一些有关像素变换的精彩内容

原理
=======
 
.. note::
   以下解释节选自Richard Szeliski所著 `Computer Vision: Algorithms and Applications <http://szeliski.org/Book/>`_ 

图像处理
--------------------

.. container:: enumeratevisibleitemswithsquare

   * 一般来说，图像处理算子是带有一幅或多幅输入图像、产生一幅输出图像的函数。

   * 图像变换可分为以下两种：

     + 点算子（像素变换）
     + 邻域（基于区域的）算子


像素变换
^^^^^^^^^^^^^^^^^

.. container:: enumeratevisibleitemswithsquare

   * 在这一类图像处理变换中，仅仅根据输入像素值（有时可加上某些全局信息或参数）计算相应的输出像素值。

   * 这类算子包括 *亮度和对比度调整* ，以及颜色校正和变换。

亮度和对比度调整
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

.. container:: enumeratevisibleitemswithsquare

   * 两种常用的点过程（即点算子），是用常数对点进行 *乘法* 和 *加法* 运算：

     .. math::
 
        g(x) = \alpha f(x) + \beta
  
   * 两个参数 :math:`\alpha > 0` 和 :math:`\beta` 一般称作 *增益* 和 *偏置* 参数。我们往往用这两个参数来分别控制 *对比度* 和 *亮度* 。

   * 你可以把 :math:`f(x)` 看成源图像像素，把 :math:`g(x)` 看成输出图像像素。这样一来，上面的式子就能写得更清楚些：

     .. math::
   
        g(i,j) = \alpha \cdot f(i,j) + \beta
  
     其中， :math:`i` 和 :math:`j` 表示像素位于 *第i行* 和 *第j列* 。

代码
=====

.. container:: enumeratevisibleitemswithsquare

   * 下列代码执行运算 :math:`g(i,j) = \alpha \cdot f(i,j) + \beta` ：

.. code-block:: cpp

   #include <opencv2/core/core.hpp>
   #include <opencv2/highgui/highgui.hpp>
   #include <iostream>

   using namespace std;
   using namespace cv;

   double alpha; /**< 控制对比度 */
   int beta;  /**< 控制亮度 */

   int main( int argc, char** argv )
   {
       /// 读入用户提供的图像
       Mat image = imread( argv[1] );
       Mat new_image = Mat::zeros( image.size(), image.type() );

       /// 初始化 
       cout << " Basic Linear Transforms " << endl;
       cout << "-------------------------" << endl;
       cout << "* Enter the alpha value [1.0-3.0]: ";
       cin >> alpha;
       cout << "* Enter the beta value [0-100]: ";
       cin >> beta;

       /// 执行运算 new_image(i,j) = alpha*image(i,j) + beta
       for( int y = 0; y < image.rows; y++ )
       {
           for( int x = 0; x < image.cols; x++ )
	   {
	       for( int c = 0; c < 3; c++ )
	       {
	           new_image.at<Vec3b>(y,x)[c] = saturate_cast<uchar>( alpha*( image.at<Vec3b>(y,x)[c] ) + beta );
	       }
	   }
       }

       /// 创建窗口
       namedWindow("Original Image", 1);
       namedWindow("New Image", 1);

       /// 显示图像
       imshow("Original Image", image);
       imshow("New Image", new_image);

       /// 等待用户按键
       waitKey();
       return 0;
   }

说明
============

#. 一上来，我们要建立两个变量，以存储用户输入的 :math:`\alpha` 和 :math:`\beta` ：

   .. code-block:: cpp

      double alpha;
      int beta;


#. 然后，用 :imread:`imread <>` 载入图像，并将其存入一个Mat对象：
   
   .. code-block:: cpp

      Mat image = imread( argv[1] );

#. 此时，因为要对图像进行一些变换，所以我们需要一个新的Mat对象，以存储变换后的图像。我们希望这个Mat对象拥有下面的性质：
   
   .. container:: enumeratevisibleitemswithsquare

      * 像素值初始化为0
      * 与原图像有相同的大小和类型
 
   .. code-block:: cpp

      Mat new_image = Mat::zeros( image.size(), image.type() ); 
 
   注意到， :mat_zeros:`Mat::zeros <>` 采用Matlab风格的初始化方式，用 *image.size()* 和 *image.type()* 来对Mat对象进行0初始化。   

#. 现在，为了执行运算 :math:`g(i,j) = \alpha \cdot f(i,j) + \beta` ，我们要访问图像的每一个像素。因为是对RGB图像进行运算，每个像素有三个值（R、G、B），所以我们要分别访问它们。下面是访问像素的代码片段：

   .. code-block:: cpp
 
      for( int y = 0; y < image.rows; y++ )
      {
          for( int x = 0; x < image.cols; x++ )
	  {
	      for( int c = 0; c < 3; c++ )
	      {
	          new_image.at<Vec3b>(y,x)[c] = saturate_cast<uchar>( alpha*( image.at<Vec3b>(y,x)[c] ) + beta );
	      }
	  }
      }
 
   注意以下两点：

   .. container:: enumeratevisibleitemswithsquare

      * 为了访问图像的每一个像素，我们使用这一语法： *image.at<Vec3b>(y,x)[c]* 其中， *y* 是像素所在的行， *x* 是像素所在的列， *c* 是R、G、B（0、1、2）之一。 

      * 因为 :math:`\alpha \cdot p(i,j) + \beta` 的运算结果可能超出像素取值范围，还可能是非整数（如果 :math:`\alpha` 是浮点数的话），所以我们要用  :saturate_cast:`saturate_cast <>` 对结果进行转换，以确保它为有效值。


#. 最后，用传统方法创建窗口并显示图像。

   .. code-block:: cpp
   
      namedWindow("Original Image", 1);
      namedWindow("New Image", 1);

      imshow("Original Image", image);
      imshow("New Image", new_image);

      waitKey(0);

.. note::
  
   我们可以不用 **for** 循环来访问每个像素，而是直接采用下面这个命令：

   .. code-block:: cpp

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

   这里的 :convert_to:`convertTo <>` 将执行我们想做的 *new_image = a*image + beta* 。然而，我们想展现访问每一个像素的过程，所以选用了for循环的方式。实际上，这两种方式都能返回同样的结果。

结果
=======

* 运行代码，取参数 :math:`\alpha = 2.2` 和 :math:`\beta = 50`

  .. code-block:: bash

     $ ./BasicLinearTransforms lena.jpg
     Basic Linear Transforms
     -------------------------
     * Enter the alpha value [1.0-3.0]: 2.2
     * Enter the beta value [0-100]: 50

* 我们将得到下面的结果：

.. image:: images/Basic_Linear_Transform_Tutorial_Result_0.jpg
   :alt: Basic Linear Transform - Final Result
   :align: center

翻译
=====================
loveisp@OpenCV中文网站 <loveispdvd [at] gmail.com>