Deleted all trailing whitespace.

Author: Roman Donchenko

3rdparty/ffmpeg/readme.txt

@@ -16,7 +16,7 @@ How to update opencv_ffmpeg.dll and opencv_ffmpeg_64.dll when a new version of F
 2. Install 64-bit MinGW. http://mingw-w64.sourceforge.net/
    Let's assume, it's installed in C:\MSYS64
 3. Copy C:\MSYS32\msys to C:\MSYS64\msys. Edit C:\MSYS64\msys\etc\fstab, change C:\MSYS32 to C:\MSYS64.
-   
+
 4. Now you have working MSYS32 and MSYS64 environments.
    Launch, one by one, C:\MSYS32\msys\msys.bat and C:\MSYS64\msys\msys.bat to create your home directories.
 

3rdparty/readme.txt

@@ -45,13 +45,13 @@ jasper-1.900.1    -   JasPer is a collection of software
                       and manipulation of images.  This software can handle image data in a
                       variety of formats.  One such format supported by JasPer is the JPEG-2000
                       format defined in ISO/IEC 15444-1.
-             
+
                       Copyright (c) 1999-2000 Image Power, Inc.
                       Copyright (c) 1999-2000 The University of British Columbia
                       Copyright (c) 2001-2003 Michael David Adams
 
                       The JasPer license can be found in src/libjasper.
-             
+
                       OpenCV on Windows uses pre-built libjasper library
                       (lib/libjasper*). To get the latest source code,
                       please, visit the project homepage:

cmake/OpenCVFindIPP.cmake

@@ -140,7 +140,7 @@ endfunction()
 # ------------------------------------------------------------------------
 function(set_ipp_new_libraries _LATEST_VERSION)
     set(IPP_PREFIX "ipp")
-    
+
     if(${_LATEST_VERSION} VERSION_LESS "8.0")
         set(IPP_SUFFIX "_l")        # static not threaded libs suffix IPP 7.x
     else()

cmake/OpenCVFindXimea.cmake

@@ -19,7 +19,7 @@ set(XIMEA_LIBRARY_DIR)
 if(WIN32)
   # Try to find the XIMEA API path in registry.
   GET_FILENAME_COMPONENT(XIMEA_PATH "[HKEY_CURRENT_USER\\Software\\XIMEA\\CamSupport\\API;Path]" ABSOLUTE)
- 
+
   if(EXISTS ${XIMEA_PATH})
     set(XIMEA_FOUND 1)
     # set LIB folders

doc/_static/insertIframe.js

@@ -1,4 +1,4 @@
-function insertIframe (elementId, iframeSrc) 
+function insertIframe (elementId, iframeSrc)
 {
   var iframe;
   if (document.createElement && (iframe = document.createElement('iframe')))

doc/packaging.txt

@@ -4,14 +4,14 @@ INSTRUCTIONS TO BUILD WIN32 PACKAGES WITH CMAKE+CPACK
 
 - Install NSIS.
 - Generate OpenCV solutions for MSVC using CMake as usual.
-- In cmake-gui: 
+- In cmake-gui:
 	- Mark BUILD_PACKAGE
 	- Mark BUILD_EXAMPLES (If examples are desired to be shipped as binaries...)
 	- Unmark ENABLE_OPENMP, since this feature seems to have some issues yet...
 	- Mark INSTALL_*_EXAMPLES
 - Open the OpenCV solution and build ALL in Debug and Release.
-- Build PACKAGE, from the Release configuration. An NSIS installer package will be 
+- Build PACKAGE, from the Release configuration. An NSIS installer package will be
   created with both release and debug LIBs and DLLs.
 
-  
+
 Jose Luis Blanco, 2009/JUL/29

doc/tutorials/calib3d/camera_calibration/camera_calibration.rst

@@ -7,16 +7,16 @@ Camera calibration with square chessboard
 
 The goal of this tutorial is to learn how to calibrate a camera given a set of chessboard images.
 
-*Test data*: use images in your data/chess folder. 
+*Test data*: use images in your data/chess folder.
 
 #.
-    Compile opencv with samples by setting ``BUILD_EXAMPLES`` to ``ON`` in cmake configuration. 
+    Compile opencv with samples by setting ``BUILD_EXAMPLES`` to ``ON`` in cmake configuration.
 
 #.
     Go to ``bin`` folder and use ``imagelist_creator`` to create an ``XML/YAML`` list of your images.
-    
+
 #.
-    Then, run ``calibration`` sample to get camera parameters. Use square size equal to 3cm. 
+    Then, run ``calibration`` sample to get camera parameters. Use square size equal to 3cm.
 
 Pose estimation
 ===============
@@ -57,6 +57,6 @@ Now, let us write a code that detects a chessboard in a new image and finds its
                              distCoeffs, rvec, tvec, false);
 
 #.
-    Calculate reprojection error like it is done in ``calibration`` sample (see ``opencv/samples/cpp/calibration.cpp``, function ``computeReprojectionErrors``). 
+    Calculate reprojection error like it is done in ``calibration`` sample (see ``opencv/samples/cpp/calibration.cpp``, function ``computeReprojectionErrors``).
 
-Question: how to calculate the distance from the camera origin to any of the corners? 
+Question: how to calculate the distance from the camera origin to any of the corners?

doc/tutorials/calib3d/camera_calibration_square_chess/camera_calibration_square_chess.rst

@@ -3,11 +3,11 @@
 *calib3d* module. Camera calibration and 3D reconstruction
 -----------------------------------------------------------
 
-Although we got most of our images in a 2D format they do come from a 3D world. Here you will learn how to find out from the 2D images information about the 3D world. 
+Although we got most of our images in a 2D format they do come from a 3D world. Here you will learn how to find out from the 2D images information about the 3D world.
 
-.. include:: ../../definitions/tocDefinitions.rst 
+.. include:: ../../definitions/tocDefinitions.rst
 
-+ 
++
   .. tabularcolumns:: m{100pt} m{300pt}
   .. cssclass:: toctableopencv
 
@@ -26,7 +26,7 @@ Although we got most of our images in a 2D format they do come from a 3D world.
      :height: 90pt
      :width:  90pt
 
-+ 
++
   .. tabularcolumns:: m{100pt} m{300pt}
   .. cssclass:: toctableopencv
 

doc/tutorials/calib3d/table_of_content_calib3d/table_of_content_calib3d.rst

@@ -18,7 +18,7 @@ Theory
 
 .. note::
 
-   The explanation below belongs to the book `Computer Vision: Algorithms and Applications <http://szeliski.org/Book/>`_  by Richard Szeliski 
+   The explanation below belongs to the book `Computer Vision: Algorithms and Applications <http://szeliski.org/Book/>`_  by Richard Szeliski
 
 From our previous tutorial, we know already a bit of *Pixel operators*. An interesting dyadic (two-input) operator is the *linear blend operator*:
 
@@ -43,7 +43,7 @@ As usual, after the not-so-lengthy explanation, let's go to the code:
 
    int main( int argc, char** argv )
    {
-    double alpha = 0.5; double beta; double input; 
+    double alpha = 0.5; double beta; double input;
 
     Mat src1, src2, dst;
 
@@ -69,7 +69,7 @@ As usual, after the not-so-lengthy explanation, let's go to the code:
 
     beta = ( 1.0 - alpha );
     addWeighted( src1, alpha, src2, beta, 0.0, dst);
-  
+
     imshow( "Linear Blend", dst );
 
     waitKey(0);
@@ -99,23 +99,23 @@ Explanation
 #. Now we need to generate the :math:`g(x)` image. For this, the function :add_weighted:`addWeighted <>` comes quite handy:
 
    .. code-block:: cpp
-   
+
       beta = ( 1.0 - alpha );
       addWeighted( src1, alpha, src2, beta, 0.0, dst);
- 
+
    since :add_weighted:`addWeighted <>` produces:
 
    .. math::
 
       dst = \alpha \cdot src1 + \beta \cdot src2 + \gamma
 
    In this case, :math:`\gamma` is the argument :math:`0.0` in the code above.
- 
-#. Create windows, show the images and wait for the user to end the program. 
+
+#. Create windows, show the images and wait for the user to end the program.
 
 Result
 =======
 
 .. image:: images/Adding_Images_Tutorial_Result_0.jpg
    :alt: Blending Images Tutorial - Final Result
-   :align: center 
+   :align: center

doc/tutorials/core/adding_images/adding_images.rst

@@ -10,7 +10,7 @@ In this tutorial you will learn how to:
 
 .. container:: enumeratevisibleitemswithsquare
 
-   + Access pixel values 
+   + Access pixel values
 
    + Initialize a matrix with zeros
 
@@ -20,16 +20,16 @@ In this tutorial you will learn how to:
 
 Theory
 =======
- 
+
 .. note::
-   The explanation below belongs to the book `Computer Vision: Algorithms and Applications <http://szeliski.org/Book/>`_  by Richard Szeliski 
+   The explanation below belongs to the book `Computer Vision: Algorithms and Applications <http://szeliski.org/Book/>`_  by Richard Szeliski
 
 Image Processing
 --------------------
 
 .. container:: enumeratevisibleitemswithsquare
 
-   * A general image processing operator is a function that takes one or more input images and produces an output image. 
+   * A general image processing operator is a function that takes one or more input images and produces an output image.
 
    * Image transforms can be seen as:
 
@@ -54,18 +54,18 @@ Brightness and contrast adjustments
    * Two commonly used point processes are *multiplication* and *addition* with a constant:
 
      .. math::
- 
+
         g(x) = \alpha f(x) + \beta
-  
+
    * The parameters :math:`\alpha > 0` and :math:`\beta` are often called the *gain* and *bias* parameters; sometimes these parameters are said to control *contrast* and *brightness* respectively.
 
    * You can think of :math:`f(x)` as the source image pixels and :math:`g(x)` as the output image pixels. Then, more conveniently we can write the expression as:
 
      .. math::
-   
+
         g(i,j) = \alpha \cdot f(i,j) + \beta
-  
-     where :math:`i` and :math:`j` indicates that the pixel is located in the *i-th* row and *j-th* column. 
+
+     where :math:`i` and :math:`j` indicates that the pixel is located in the *i-th* row and *j-th* column.
 
 Code
 =====
@@ -91,7 +91,7 @@ Code
     Mat image = imread( argv[1] );
     Mat new_image = Mat::zeros( image.size(), image.type() );
 
-    /// Initialize values 
+    /// Initialize values
     std::cout<<" Basic Linear Transforms "<<std::endl;
     std::cout<<"-------------------------"<<std::endl;
     std::cout<<"* Enter the alpha value [1.0-3.0]: ";std::cin>>alpha;
@@ -102,7 +102,7 @@ Code
        { for( int x = 0; x < image.cols; x++ )
             { for( int c = 0; c < 3; c++ )
                  {
-         new_image.at<Vec3b>(y,x)[c] = 
+         new_image.at<Vec3b>(y,x)[c] =
             saturate_cast<uchar>( alpha*( image.at<Vec3b>(y,x)[c] ) + beta );
                 }
        }
@@ -133,49 +133,49 @@ Explanation
 
 
 #. We load an image using :imread:`imread <>` and save it in a Mat object:
-   
+
    .. code-block:: cpp
 
       Mat image = imread( argv[1] );
 
 #. Now, since we will make some transformations to this image, we need a new Mat object to store it. Also, we want this to have the following features:
-   
+
    .. container:: enumeratevisibleitemswithsquare
 
       * Initial pixel values equal to zero
       * Same size and type as the original image
- 
+
    .. code-block:: cpp
 
-      Mat new_image = Mat::zeros( image.size(), image.type() ); 
- 
-   We observe that :mat_zeros:`Mat::zeros <>` returns a Matlab-style zero initializer based on *image.size()* and *image.type()*  
+      Mat new_image = Mat::zeros( image.size(), image.type() );
+
+   We observe that :mat_zeros:`Mat::zeros <>` returns a Matlab-style zero initializer based on *image.size()* and *image.type()*
 
 #. Now, to perform the operation :math:`g(i,j) = \alpha \cdot f(i,j) + \beta` we will access to each pixel in image. Since we are operating with RGB images, we will have three values per pixel (R, G and B), so we will also access them separately. Here is the piece of code:
 
    .. 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] = 
+                   { new_image.at<Vec3b>(y,x)[c] =
                                saturate_cast<uchar>( alpha*( image.at<Vec3b>(y,x)[c] ) + beta ); }
          }
          }
- 
+
    Notice the following:
 
    .. container:: enumeratevisibleitemswithsquare
 
-      * To access each pixel in the images we are using this syntax: *image.at<Vec3b>(y,x)[c]* where *y* is the row, *x* is the column and *c* is R, G or B (0, 1 or 2). 
+      * To access each pixel in the images we are using this syntax: *image.at<Vec3b>(y,x)[c]* where *y* is the row, *x* is the column and *c* is R, G or B (0, 1 or 2).
 
       * Since the operation :math:`\alpha \cdot p(i,j) + \beta` can give values out of range or not integers (if :math:`\alpha` is float), we use :saturate_cast:`saturate_cast <>` to make sure the values are valid.
 
 
 #. Finally, we create windows and show the images, the usual way.
 
    .. code-block:: cpp
-   
+
       namedWindow("Original Image", 1);
       namedWindow("New Image", 1);
 
@@ -185,9 +185,9 @@ Explanation
       waitKey(0);
 
 .. note::
-  
+
    Instead of using the **for** loops to access each pixel, we could have simply used this command:
-  
+
    .. code-block:: cpp
 
       image.convertTo(new_image, -1, alpha, beta);
@@ -211,4 +211,4 @@ Result
 
 .. image:: images/Basic_Linear_Transform_Tutorial_Result_0.jpg
    :alt: Basic Linear Transform - Final Result
-   :align: center 
+   :align: center