1) Converted all images to JPG to reduce size.

2) Added a raw Latex page break directive after each TOC tree. (For the PDF tutorial look).
3) Two finished tutorials: 
   a) one describing how the Mat data structure works and its output capabilities (format function) (demonstration YouTube video included).
   b) one describing image scanning operations plus the LUT function (demonstration YouTube video included). 
   c) a basic filtering approach (plus multi row image scanning demonstration) in the work.

doc/conf.py

@@ -168,9 +168,9 @@ html_use_index = True
 # Output file base name for HTML help builder.
 htmlhelp_basename = 'opencv'
 
-# OpenCV docs use some custom LaTeX macros in the formulae. Make sure we include the definitions
+# OpenCV docs use some custom LaTeX macros in the formula. Make sure we include the definitions
 pngmath_latex_preamble = r"""
-\usepackage{euler}\usepackage[usenames,dvipsnames]{color}\usepackage{amssymb}\usepackage{amsmath}\usepackage{bbm}
+\usepackage{euler}\usepackage[usenames,dvipsnames]{color}\usepackage{amssymb}\usepackage{amsmath}\usepackage{bbm}\usepackage[table]{xcolor}
 \newcommand{\matTT}[9]{
 \[
 \left|\begin{array}{ccc}
@@ -235,6 +235,7 @@ preamble ="""
 \usepackage{euler}
 \usepackage[scaled=0.85]{beramono}
 \usepackage{mymath}\usepackage{amssymb}\usepackage{amsmath}\usepackage{bbm}\setcounter{secnumdepth}{1}
+\usepackage[table]{xcolor}
 """
 
 latex_elements = {'preamble': preamble}
@@ -345,6 +346,10 @@ extlinks = {'cvt_color': ('http://opencv.willowgarage.com/documentation/cpp/imgp
             'moments' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_structural_analysis_and_shape_descriptors.html#cv-moments%s', None),
             'contour_area' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_structural_analysis_and_shape_descriptors.html#cv-contourarea%s', None),
             'arc_length' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_structural_analysis_and_shape_descriptors.html#cv-arclength%s', None),
+            'basicstructures' : ('http://opencv.itseez.com/modules/core/doc/basic_structures.html#%s', None),
+            'readwriteimagevideo' : ('http://opencv.itseez.com/modules/highgui/doc/reading_and_writing_images_and_video.html#%s', None),
+            'operationsonarrays' : ('http://opencv.itseez.com/modules/core/doc/operations_on_arrays.html#%s', None),
+            'utilitysystemfunctions':('http://opencv.itseez.com/modules/core/doc/utility_and_system_functions_and_macros.html%s', None),
             'point_polygon_test' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_structural_analysis_and_shape_descriptors.html#cv-pointpolygontest%s', None)
            }
 

doc/tutorials/calib3d/table_of_content_calib3d/table_of_content_calib3d.rst

@@ -6,3 +6,7 @@
 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/noContent.rst
+
+.. raw:: latex
+
+   \pagebreak

doc/tutorials/core/adding_images/adding_images.rst

@@ -114,6 +114,6 @@ Explanation
 Result
 =======
 
-.. image:: images/Adding_Images_Tutorial_Result_0.png
+.. image:: images/Adding_Images_Tutorial_Result_0.jpg
    :alt: Blending Images Tutorial - Final Result
    :align: center 

doc/tutorials/core/basic_geometric_drawing/basic_geometric_drawing.rst

@@ -260,6 +260,6 @@ Result
 
 Compiling and running your program should give you a result like this:
 
-.. image:: images/Drawing_1_Tutorial_Result_0.png
+.. image:: images/Drawing_1_Tutorial_Result_0.jpg
    :alt: Drawing Tutorial 1 - Final Result
    :align: center 

doc/tutorials/core/basic_linear_transform/basic_linear_transform.rst

@@ -185,7 +185,7 @@ Result
 
   .. code-block:: bash
 
-     $ ./BasicLinearTransforms lena.png
+     $ ./BasicLinearTransforms lena.jpg
      Basic Linear Transforms
      -------------------------
      * Enter the alpha value [1.0-3.0]: 2.2
@@ -193,7 +193,7 @@ Result
 
 * We get this:
 
-.. image:: images/Basic_Linear_Transform_Tutorial_Result_0.png
+.. image:: images/Basic_Linear_Transform_Tutorial_Result_0.jpg
    :height: 400px
    :alt: Basic Linear Transform - Final Result
    :align: center 

doc/tutorials/core/how_to_scan_images/how_to_scan_images.rst

+.. _howToScanImagesOpenCV:
+
+How to scan images, lookup tables and time measurement with OpenCV
+*******************************************************************
+
+Goal
+==== 
+
+We'll seek answers for the following questions: 
+
+.. container:: enumeratevisibleitemswithsquare
+
+   + How to go through each and every pixel of an image?
+   + How is OpenCV matrix values stored?
+   + How to measure the performance of our algorithm?
+   + What are lookup tables and why use them?
+
+Our test case
+=============
+
+Let us consider a simple color reduction method. Using the unsigned char C and C++ type for matrix item storing a channel of pixel may have up to 256 different values. For a three channel image this can allow the formation of way too many colors (16 million to be exact). Working with so many color shades may give a heavy blow to our algorithm performance. However, sometimes it is enough to work with a lot less of them to get the same final result. 
+
+In this cases it's common that we make a *color space reduction*. This means that we divide the color space current value with a new input value to end up with fewer colors. For instance every value between zero and nine takes the new value zero, every value between ten and nineteen the value ten and so on. 
+
+When you divide an *uchar* (unsigned char - aka values between zero and 255) value with an *int* value the result will be also *char*. These values may only be char values. Therefore, any fraction will be rounded down. Taking advantage of this fact the upper operation in the *uchar* domain may be expressed as: 
+
+.. math::
+
+   I_{new} = (\frac{I_{old}}{10}) * 10
+
+A simple color space reduction algorithm would consist of just passing through every pixel of an image matrix and applying this formula. It's worth noting that we do a divide and a multiplication operation. These operations are bloody expensive for a system. If possible it's worth avoiding them by using cheaper operations such as a few subtractions, addition or in best case a simple assignment. Furthermore, note that we only have a limited number of input values for the upper operation. In case of the *uchar* system this is 256 to be exact.
+
+Therefore, for larger images it would be wise to calculate all possible values beforehand and during the assignment just make the assignment, by using a lookup table. Lookup tables are simple arrays (having one or more dimensions) that for a given input value variation holds the final output value. Its strength lies that we do not need to make the calculation, we just need to read the result. 
+
+Our test case program (and the sample presented here) will do the following: read in a console line argument image (that may be either color or gray scale - console line argument too) and apply the reduction with the given console line argument integer value. In OpenCV, at the moment they are three major ways of going through an image pixel by pixel. To make things a little more interesting will make the scanning for each image using all of these methods, and print out how long it took. 
+
+You can download the full source code :download:`here <../../../../samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp>` or look it up in the samples directory of OpenCV at the cpp tutorial code for the core section. Its basic usage is: 
+
+.. code-block:: bash
+
+   how_to_scan_images imageName.jpg intValueToReduce [G]
+
+The final argument is optional. If given the image will be loaded in gray scale format, otherwise the RGB color way is used. The first thing is to calculate the lookup table.
+
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp
+   :language: cpp
+   :tab-width: 4
+   :lines: 48-60 
+
+Here we first use the C++ *stringstream* class to convert the third command line argument from text to an integer format. Then we use a simple look and the upper formula to calculate the lookup table. No OpenCV specific stuff here.
+
+Another issue is how do we measure time? Well OpenCV offers two simple functions to achieve this :UtilitySystemFunctions:`getTickCount() <gettickcount>` and :UtilitySystemFunctions:`getTickFrequency() <gettickfrequency>`. The first returns the number of ticks of your systems CPU from a certain event (like since you booted your system). The second returns how many times your CPU emits a tick during a second. So to measure in seconds the number of time elapsed between two operations is easy as: 
+
+.. code-block:: cpp
+
+   double t = (double)getTickCount();
+   // do something ...
+   t = ((double)getTickCount() - t)/getTickFrequency(); 
+   cout << "Times passed in seconds: " << t << endl;
+
+How the image matrix is stored in the memory?
+=============================================
+
+As you could already read in my :ref:`matTheBasicImageContainer` tutorial the size of the matrix depends of the color system used. More accurately, it depends from the number of channels used. In case of a gray scale image we have something like: 
+
+.. math::
+
+   \newcommand{\tabItG}[1] { \textcolor{black}{#1} \cellcolor{gray}}
+   \begin{tabular} {ccccc}
+   ~ & \multicolumn{1}{c}{Column 0} &   \multicolumn{1}{c}{Column 1} &   \multicolumn{1}{c}{Column ...} & \multicolumn{1}{c}{Column m}\\
+   Row 0 & \tabItG{0,0} & \tabItG{0,1} & \tabItG{...}  & \tabItG{0, m} \\
+   Row 1 & \tabItG{1,0} & \tabItG{1,1} & \tabItG{...}  & \tabItG{1, m} \\
+   Row ... & \tabItG{...,0} & \tabItG{...,1} & \tabItG{...} & \tabItG{..., m} \\
+   Row n & \tabItG{n,0} & \tabItG{n,1} & \tabItG{n,...} & \tabItG{n, m} \\
+   \end{tabular}
+
+For multichannel images the columns contain as many sub columns as the number of channels. For example in case of an RGB color system:
+
+.. math::
+
+   \newcommand{\tabIt}[1] { \textcolor{yellow}{#1} \cellcolor{blue} &  \textcolor{black}{#1} \cellcolor{green} & \textcolor{black}{#1} \cellcolor{red}}
+   \begin{tabular} {ccccccccccccc}
+   ~ & \multicolumn{3}{c}{Column 0} &   \multicolumn{3}{c}{Column 1} &   \multicolumn{3}{c}{Column ...} & \multicolumn{3}{c}{Column m}\\
+   Row 0 & \tabIt{0,0} & \tabIt{0,1} & \tabIt{...}  & \tabIt{0, m} \\
+   Row 1 & \tabIt{1,0} & \tabIt{1,1} & \tabIt{...}  & \tabIt{1, m} \\
+   Row ... & \tabIt{...,0} & \tabIt{...,1} & \tabIt{...} & \tabIt{..., m} \\
+   Row n & \tabIt{n,0} & \tabIt{n,1} & \tabIt{n,...} & \tabIt{n, m} \\
+   \end{tabular}
+
+Note that the order of the channels is inverse: BGR instead of RGB. Because in many cases the memory is large enough to store the rows in a successive fashion the rows may follow one after another, creating a single long row. Because everything is in a single place following one after another this may help to speed up the scanning process. We can use the :basicstructures:`isContinuous() <mat-iscontinuous>` function to *ask* the matrix if this is the case. Continue on to the next section to find an example.
+
+The efficient way
+=================
+
+When it comes to performance you cannot beat the classic C style operator[] (pointer) access. Therefore, the most efficient method we can recommend for making the assignment is: 
+
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp
+   :language: cpp
+   :tab-width: 4
+   :lines: 116-143
+
+Here we basically just acquire a pointer to the start of each row and go through it until it ends. In the special case that the matrix is stored in a continues manner we only need to request the pointer a single time and go all the way to the end. We need to look out for color images: we have three channels so we need to pass through three times more items in each row. 
+
+There's another way of this. The *data* data member of a *Mat* object returns the pointer to the first row, first column. If this pointer is null you have no valid input in that object. Checking this is the simplest method to check if your image loading was a success. In case the storage is continues we can use this to go through the whole data pointer. In case of a gray scale image this would look like:
+
+.. code-block:: cpp
+
+   uchar* p = I.data;
+
+   for( unsigned int i =0; i < ncol*nrows; ++i)
+       *p++ = table[*p];
+
+You would get the same result. However, this code is a lot harder to read later on. It gets even harder if you have some more advanced technique there. Moreover, in practice I've observed you'll get the same performance result (as most of the modern compilers will probably make this small optimization trick automatically for you).
+
+The iterator (safe) method 
+==========================
+
+In case of the efficient way making sure that you pass through the right amount of *uchar* fields and to skip the gaps that may occur between the rows was your responsibility. The iterator method is considered a safer way as it takes over these tasks from the user. All you need to do is ask the begin and the end of the image matrix and then just increase the begin iterator until you reach the end. To acquire the value *pointed* by the iterator use the * operator (add it before it). 
+
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp
+   :language: cpp
+   :tab-width: 4
+   :lines: 145-173
+
+In case of color images we have three uchar items per column. This may be considered a short vector of uchar items, that has been baptized in OpenCV with the *Vec3b* name. To access the n-th sub column we use simple operator[] access. It's important to remember that OpenCV iterators go through the columns and automatically skip to the next row. Therefore in case of color images if you use a simple *uchar* iterator you'll be able to access only the blue channel values. 
+
+Random Pixel Access
+===================
+
+The final method isn't recommended for scanning. It was made to acquire or modify random elements in the image. Its basic usage is to specify the row and column number of the item you want to access. During our earlier scanning methods you could already observe that is important through what type we are looking at the image. It's no different here as you need manually to specify what type to use at the automatic lookup. You can observe this in case of the gray scale images for the following source code (the usage of the + :basicstructures:`at() <mat-at>` function):
+
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp
+   :language: cpp
+   :tab-width: 4
+   :lines: 175-207
+
+If you need to multiple lookups using this method for an image it may be troublesome and time consuming to enter the type and the at keyword for each of the accesses. To solve this problem OpenCV has a :basicstructures:`Mat_ <id3>` data type. It's the same as Mat with the extra need that at definition you need to specify the data type through what to look at the data matrix, however in return you can use the operator() for fast access of items. To make things even better this is easily convertible from and to the usual :basicstructures:`Mat <id3>` data type. A sample usage of this you can see in case of the color images of the upper function. Nevertheless, it's important to note that the same operation (with the same runtime speed) could have been done with the :basicstructures:`at() <mat-at>` function. It's just a less to write for the lazy programmer trick.
+
+The Core Function
+=================
+
+This is a bonus method of achieving lookup table modification in an image. Because in image processing it's quite common that you want to replace all of a given image value to some other value OpenCV has a function that makes the modification without the need from you to write the scanning of the image. We use the :operationsOnArrays:`LUT() <lut>` function of the core module. First we build a Mat type of the lookup table:
+
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp
+   :language: cpp
+   :tab-width: 4
+   :lines: 98-101
+
+Finally call the function (I is our input image and J the output one):
+
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp
+   :language: cpp
+   :tab-width: 4
+   :lines: 106
+
+Performance Difference
+======================
+
+For the best result compile the program and run it on your own speed. For showing off better the differences I've used a quite large (2560 X 1600) image. The performance presented here are for color images. For a more accurate value I've averaged the value I got from the call of the function for hundred times.
+
+============= ====================
+Efficient Way 79.4717 milliseconds
+
+Iterator      83.7201 milliseconds
+
+Random Access 93.7878 milliseconds
+
+LUT function  32.5759 milliseconds
+============= ====================
+
+We can conclude a couple of things. If possible, use the already made functions of OpenCV (instead reinventing these). The fastest method turns out to be the LUT function. This is because the OpenCV library is multi-thread enabled via Intel Threaded Building Blocks. However, if you need to write a simple image scan prefer the pointer method. The iterator is a safer bet, however quite slower. Using the random access method for full image scan is the most costly. Your compiler might observe what you want to do and optimize it out somewhat, however in general case this approach is with a little slower than the iterator method.
+
+Finally, you may watch a sample run of the program on the `video posted <https://www.youtube.com/watch?v=fB3AN5fjgwc>`_ on our YouTube channel.
+
+.. raw:: html
+
+  <div align="center">
+  <iframe title="Install OpenCV by using its source files - Part 1" width="560" height="349" src="http://www.youtube.com/embed/fB3AN5fjgwc?rel=0&loop=1" frameborder="0" allowfullscreen align="middle"></iframe>
+  </div>

doc/tutorials/core/mat - the basic image container/mat - the basic image container.rst

+.. _matTheBasicImageContainer:
+
+Mat - The Basic Image Container
+*******************************
+
+Goal
+====
+
+We have multiple ways to acquire digital images from the real world: digital cameras, scanners, computed tomography or magnetic resonance imaging to just name a few. In every case what we (humans) see are images. However, when transforming this to our digital devices what we record are numerical values for each of the points of the image.
+
+.. image:: images/MatBasicImageForComputer.jpg
+   :alt: A matrix of the mirror of a car
+   :align: center
+
+For example in the above image you can see that the mirror of the care is nothing more than a matrix containing all the intensity values of the pixel points. Now, how we get and store the pixels values may vary according to what fits best our need, in the end all images inside a computer world may be reduced to numerical matrices and some other information's describing the matric itself. *OpenCV* is a computer vision library whose main focus is to process and manipulate these information to find out further ones. Therefore, the first thing you need to learn and get accommodated with is how OpenCV stores and handles images.
+
+*Mat*
+=====
+
+OpenCV has been around ever since 2001. In those days the library was built around a *C* interface. In those days to store the image in the memory they used a C structure entitled *IplImage*. This is the one you'll see in most of the older tutorials and educational materials. The problem with this is that it brings to the table all the minuses of the C language. The biggest issue is the manual management. It builds on the assumption that the user is responsible for taking care of memory allocation and deallocation. While this is no issue in case of smaller programs once your code base start to grove larger and larger it will be more and more a struggle to handle all this rather than focusing on actually solving your development goal.
+
+Luckily C++ came around and introduced the concept of classes making possible to build another road for the user: automatic memory management (more or less). The good news is that C++ if fully compatible with C so no compatibility issues can arise from making the change. Therefore, OpenCV with its 2.0 version introduced a new C++ interface that by taking advantage of these offers a new way of doing things. A way, in which you do not need to fiddle with memory management; making your code concise (less to write, to achieve more). The only main downside of the C++ interface is that many embedded development systems at the moment support only C. Therefore, unless you are targeting this platform, there's no point on using the *old* methods (unless you're a masochist programmer and you're asking for trouble). 
+
+The first thing you need to know about *Mat* is that you no longer need to manually allocate its size and release it as soon as you do not need it. While doing this is still a possibility, most of the OpenCV functions will allocate its output data manually. As a nice bonus if you pass on an already existing *Mat* object, what already has allocated the required space for the matrix, this will be reused. In other words we use at all times only as much memory as much we must to perform the task.
+
+*Mat* is basically a class having two data parts: the matrix header (containing information such as the size of the matrix, the method used for storing, at which address is the matrix stored and so on) and a pointer to the matrix containing the pixel values (may take any dimensionality depending on the method chosen for storing) . The matrix header size is constant. However, the size of the matrix itself may vary from image to image and usually is larger by order of magnitudes. Therefore, when you're passing on images in your program and at some point you need to create a copy of the image the big price you will need to build is for the matrix itself rather than its header. OpenCV is an image processing library. It contains a large collection of image processing functions. To solve a computational challenge most of the time you will end up using multiple functions of the library. Due to this passing on images to functions is a common practice. We should not forget that we are talking about image processing algorithms, which tend to be quite computational heavy. The last thing we want to do is to further decrease the speed of your program by making unnecessary copies of potentially *large* images.
+
+To tackle this issue OpenCV uses a reference counting system. The idea is that each *Mat* object has its own header, however the matrix may be shared between two instance of them by having their matrix pointer point to the same address. Moreover, the copy operators **will only copy the headers**, and as also copy the pointer to the large matrix too, however not the matrix itself. 
+
+.. code-block:: cpp
+   :linenos:
+
+   Mat A, C;                                 // creates just the header parts
+   A = imread(argv[1], CV_LOAD_IMAGE_COLOR); // here we'll know the method used (allocate matrix)
+
+   Mat B(A);                                 // Use the copy constructor
+
+   C = A;                                    // Assignment operator
+
+All the above objects, in the end point to the same single data matrix. Their headers are different, however making any modification using either one of them will affect all the other ones too. In practice the different objects just provide different access method to the same underlying data. Nevertheless, their header parts are different. The real interesting part comes that you can create headers that refer only to a subsection of the full data. For example, to create a region of interest (*ROI*) in an image you just create a new header with the new boundaries: 
+
+.. code-block:: cpp
+   :linenos:
+
+   Mat D (A, Rect(10, 10, 100, 100) ); // using a rectangle
+   Mat E = A(Range:all(), Range(1,3)); // using row and column boundaries 
+
+Now you may ask if the matrix itself may belong to multiple *Mat* objects who will take responsibility for its cleaning when it's no longer needed. The short answer is: the last object that used it. For this a reference counting mechanism is used. Whenever somebody copies a header of a *Mat* object a counter is increased for the matrix. Whenever a header is cleaned this counter is decreased. When the counter reaches zero the matrix too is freed. Because, sometimes you will still want to copy the matrix itself too, there exists the :basicstructures:`clone() <mat-clone>` or the :basicstructures:`copyTo() <mat-copyto>` function.
+
+.. code-block:: cpp
+   :linenos:
+
+   Mat F = A.clone(); 
+   Mat G; 
+   A.copyTo(G);
+
+Now modifying *F* or *G* will not affect the matrix pointed by the *Mat* header. What you need to remember from all this is that:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * Output image allocation for OpenCV functions is automatic (unless specified otherwise).
+   * No need to think about memory freeing with OpenCVs C++ interface.
+   * The assignment operator and the copy constructor (*ctor*)copies only the header.
+   * Use the :basicstructures:`clone()<mat-clone>` or the :basicstructures:`copyTo() <mat-copyto>` function to copy the underlying matrix of an image.
+
+*Storing* methods
+================= 
+
+This is about how you store the pixel values. You can select the color space and the data type used. The color space refers to how we combine color components in order to code a given color. The simplest one is the gray scale. Here the colors at our disposal are black and white. The combination of these allows us to create many shades of gray. 
+
+For *colorful* ways we have a lot more of methods to choose from. However, every one of them breaks it down to three or four basic components and the combination of this will give all others. The most popular one of this is RGB, mainly because this is also how our eye builds up colors in our eyes. Its base colors are red, green and blue. To code the transparency of a color sometimes a fourth element: alpha (A) is added. 
+
+However, they are many color systems each with their own advantages:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * RGB is the most common as our eyes use something similar, our display systems also compose colors using these.
+   * The HSV and HLS decompose colors into their hue, saturation and value/luminance components, which is a more natural way for us to describe colors. Using you may for example dismiss the last component, making your algorithm less sensible to light conditions of the input image. 
+   * YCrCb is used by the popular JPEG image format. 
+   * CIE L*a*b* is a perceptually uniform color space, which comes handy if you need to measure the *distance* of a given color to another color.
+
+Now each of the building components has their own valid domains. This leads to the data type used. How we store a component defines just how fine control we have over its domain. The smallest data type possible is *char*, which means one byte or 8 bits. This may be signed (so can store values from 0 to 255) or unsigned (values from -127 to +127). Although in case of three components this already gives 16 million possible colors to represent (like in case of RGB) we may acquire an even finer control by using the float (4 byte = 32 bit) or double (8 byte = 64 bit) data types for each component. Nevertheless, remember that increasing the size of a component also increases the size of the whole picture in the memory. 
+
+Creating explicitly a *Mat* object
+==================================
+
+In the :ref:`Load_Save_Image` tutorial you could already see how to write a matrix to an image file by using the :readWriteImageVideo:` imwrite() <imwrite>` function. However, for debugging purposes it's much more convenient to see the actual values. You can achieve this via the << operator of *Mat*. However, be aware that this only works for two dimensional matrices. 
+
+Although *Mat* is a great class as image container it is also a general matrix class. Therefore, it is possible to create and manipulate multidimensional matrices. You can create a Mat object in multiple ways:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   + :basicstructures:`Mat() <mat-mat>` Constructor 
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+        :language: cpp
+        :tab-width: 4
+        :lines:  27-28
+
+    .. image:: images/MatBasicContainerOut1.jpg
+       :alt: Demo image of the matrix output
+       :align: center
+
+    For two dimensional and multichannel images we first define their size: row and column count wise.
+
+    Then we need to specify the data type to use for storing the elements and the number of channels per matrix point. To do this we have multiple definitions made according to the following convention: 
+
+    .. code-block:: cpp
+
+       CV_[The number of bits per item][Signed or Unsigned][Type Prefix]C[The channel number]
+
+    For instance, *CV_8UC3* means we use unsigned char types that are 8 bit long and each pixel has three items of this to form the three channels. This are predefined for up to four channel numbers. The :basicstructures:`Scalar <scalar>` is four element short vector. Specify this and you can initialize all matrix points with a custom value. However if you need more you can create the type with the upper macro and putting the channel number in parenthesis as you can see below.
+
+   + Use C\\C++ arrays and initialize via constructor
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+        :language: cpp
+        :tab-width: 4
+        :lines:  35-36
+
+     The upper example shows how to create a matrix with more than two dimensions. Specify its dimension, then pass a pointer containing the size for each dimension and the rest remains the same.      
+
+
+   + Create a header for an already existing IplImage pointer:
+
+     .. code-block:: cpp
+
+        IplImage* img = cvLoadImage("greatwave.jpg", 1);
+        Mat mtx(img); // convert IplImage* -> Mat
+
+   + :basicstructures:`Create() <mat-create>` function:
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+        :language: cpp
+        :tab-width: 4
+        :lines:  31-32
+
+    .. image:: images/MatBasicContainerOut2.jpg
+       :alt: Demo image of the matrix output
+       :align: center
+
+    You cannot initialize the matrix values with this construction. It will only reallocate its matrix data memory if the new size will not fit into the old one.
+
+   + MATLAB style initializer: :basicstructures:`zeros() <mat-zeros>`, :basicstructures:`ones() <mat-ones>`, ::basicstructures:`eyes() <mat-eye>`. Specify size and data type to use:
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+        :language: cpp
+        :tab-width: 4
+        :lines:  40-47
+
+    .. image:: images/MatBasicContainerOut3.jpg
+       :alt: Demo image of the matrix output
+       :align: center
+
+   + For small matrices you may use comma separated initializers:
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+        :language: cpp
+        :tab-width: 4
+        :lines:  50-51
+
+    .. image:: images/MatBasicContainerOut6.jpg
+       :alt: Demo image of the matrix output
+       :align: center
+
+   + Create a new header for an existing *Mat* object and :basicstructures:`clone() <mat-clone>` or :basicstructures:`copyTo() <mat-copyto>` it.
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+        :language: cpp
+        :tab-width: 4
+        :lines:  53-54
+
+     .. image:: images/MatBasicContainerOut7.jpg
+        :alt: Demo image of the matrix output
+        :align: center
+
+Print out formatting
+====================
+
+.. note:: 
+
+   You can fill out a matrix with random values using the :operationsOnArrays:`randu() <randu>` function. You need to give the lover and upper value between what you want the random values:
+
+   .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+      :language: cpp
+      :tab-width: 4
+      :lines:  57-58
+
+In the above examples you could see the default formatting option. Nevertheless, OpenCV allows you to format your matrix output format to fit the rules of: 
+
+.. container:: enumeratevisibleitemswithsquare
+
+   + Default 
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+       :language: cpp
+       :tab-width: 4
+       :lines: 61
+
+     .. image:: images/MatBasicContainerOut8.jpg
+        :alt: Default Output
+        :align: center
+
+   + Python
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+       :language: cpp
+       :tab-width: 4
+       :lines: 62
+
+     .. image:: images/MatBasicContainerOut16.jpg
+        :alt: Default Output
+        :align: center
+
+   + Comma separated values (CSV) 
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+       :language: cpp
+       :tab-width: 4
+       :lines: 64
+
+     .. image:: images/MatBasicContainerOut10.jpg
+        :alt: Default Output
+        :align: center
+
+   + Numpy
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+       :language: cpp
+       :tab-width: 4
+       :lines: 63
+
+     .. image:: images/MatBasicContainerOut9.jpg
+        :alt: Default Output
+        :align: center
+
+   + C
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+       :language: cpp
+       :tab-width: 4
+       :lines: 65
+
+     .. image:: images/MatBasicContainerOut11.jpg
+        :alt: Default Output
+        :align: center
+
+Print for other common items
+============================
+
+OpenCV offers support for print of other common OpenCV data structures too via the << operator like:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   + 2D Point 
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+       :language: cpp
+       :tab-width: 4
+       :lines: 67-68
+
+     .. image:: images/MatBasicContainerOut12.jpg
+        :alt: Default Output
+        :align: center
+
+
+   + 3D Point
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+       :language: cpp
+       :tab-width: 4
+       :lines: 70-71
+
+     .. image:: images/MatBasicContainerOut13.jpg
+        :alt: Default Output
+        :align: center
+
+   + std::vector via cv::Mat
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+       :language: cpp
+       :tab-width: 4
+       :lines: 74-77
+
+     .. image:: images/MatBasicContainerOut14.jpg
+        :alt: Default Output
+        :align: center
+
+   + std::vector of points
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+       :language: cpp
+       :tab-width: 4
+       :lines: 79-83
+
+     .. image:: images/MatBasicContainerOut15.jpg
+        :alt: Default Output
+        :align: center
+
+Most of the samples here have been included into a small console application. You can download it from :download:`here <../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp>` or in the core section of the cpp samples.
+
+A quick video demonstration of this you can find on `YouTube <https://www.youtube.com/watch?v=1tibU7vGWpk>`_.
+
+.. raw:: html
+
+  <div align="center">
+  <iframe title="Install OpenCV by using its source files - Part 1" width="560" height="349" src="http://www.youtube.com/embed/1tibU7vGWpk?rel=0&loop=1" frameborder="0" allowfullscreen align="middle"></iframe>
+  </div>

doc/tutorials/core/mat-mask-operations/mat-mask-operations.rst

+.. _maskOperations:
+
+Mask operations on matrixes
+***************************
+
+Mask operations on matrixes are quite simple. The idea is that we recalculate each pixels value in an image according to a matrix mask. This mask holds values that will just how much influence have neighbor pixel values (and the pixel value itself) to the new pixel value. From a mathematical point of view we make a weighted average, with our specified values. 
+
+Our test case
+=============
+
+Let us consider the issue of an image contrast enchancement method. Basically we want to apply for every pixel of the image the following formula: 
+
+.. math::
+
+   I(i,j) = 5*I(i,j) - [ I(i-1,j) + I(i+1,j) + I(i,j-1) + I(i,j+1)] 
+
+	\iff I(i,j)*M, \text{where }
+	M = \bordermatrix{ _i\backslash ^j  & -1 &  0 & -1 \cr
+						-1 &  0 & -1 &  0 \cr
+						 0 & -1 &  5 & -1 \cr
+						+1 &  0 & -1 &  0 \cr
+					  }
+
+The first notation is by using a formula, while the second is a compacted version of the first by using a mask. You use the mask by puting the center of the mask matrix (in the upper case noted by the zero-zero index) on the pixel you want to calculate and sum up the pixel values multiplicated with the overlapped matrix values. It's the same thing, however in case of large matrices the later notation is a lot easier to look over. 

doc/tutorials/core/random_generator_and_text/random_generator_and_text.rst

@@ -229,56 +229,56 @@ As you just saw in the Code section, the program will sequentially execute diver
 
 #. First a random set of *NUMBER* lines will appear on screen such as it can be seen in this screenshot:
 
-   .. image:: images/Drawing_2_Tutorial_Result_0.png
+   .. image:: images/Drawing_2_Tutorial_Result_0.jpg
       :height: 300px
       :alt: Drawing Tutorial 2 - Final Result 0
       :align: center 
 
 #. Then, a new set of figures, these time *rectangles* will follow:
 
-   .. image:: images/Drawing_2_Tutorial_Result_1.png
+   .. image:: images/Drawing_2_Tutorial_Result_1.jpg
       :height: 300px
       :alt: Drawing Tutorial 2 - Final Result 1
       :align: center 
 
 #. Now some ellipses will appear, each of them with random position, size, thickness and arc length:
 
-   .. image:: images/Drawing_2_Tutorial_Result_2.png
+   .. image:: images/Drawing_2_Tutorial_Result_2.jpg
       :height: 300px
       :alt: Drawing Tutorial 2 - Final Result 2
       :align: center 
 
 #. Now, *polylines* with 03 segments will appear on screen, again in random configurations.
 
-   .. image:: images/Drawing_2_Tutorial_Result_3.png
+   .. image:: images/Drawing_2_Tutorial_Result_3.jpg
       :height: 300px
       :alt: Drawing Tutorial 2 - Final Result 3
       :align: center 
 
 #. Filled polygons (in this example triangles) will follow:
 
-   .. image:: images/Drawing_2_Tutorial_Result_4.png
+   .. image:: images/Drawing_2_Tutorial_Result_4.jpg
       :height: 300px
       :alt: Drawing Tutorial 2 - Final Result 4
       :align: center 
 
 #. The last geometric figure to appear: circles!
 
-   .. image:: images/Drawing_2_Tutorial_Result_5.png
+   .. image:: images/Drawing_2_Tutorial_Result_5.jpg
       :height: 300px
       :alt: Drawing Tutorial 2 - Final Result 5
       :align: center 
 
 #. Near the end, the text *"Testing Text Rendering"* will appear in a variety of fonts, sizes, colors and positions.
 
-   .. image:: images/Drawing_2_Tutorial_Result_6.png
+   .. image:: images/Drawing_2_Tutorial_Result_6.jpg
       :height: 300px
       :alt: Drawing Tutorial 2 - Final Result 6
       :align: center 
 
 #. And the big end (which by the way expresses a big truth too):
 
-   .. image:: images/Drawing_2_Tutorial_Result_7.png
+   .. image:: images/Drawing_2_Tutorial_Result_7.jpg
       :height: 300px
       :alt: Drawing Tutorial 2 - Final Result 7
       :align: center 

doc/tutorials/core/table_of_content_core/table_of_content_core.rst

@@ -7,6 +7,45 @@ Here you will learn the about the basic building blocks of the library. A must r
 
 .. include:: ../../definitions/tocDefinitions.rst
 
++
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+
+  =============== ======================================================
+   |MatBasicIma|  **Title:** :ref:`matTheBasicImageContainer`
+
+                  *Compatibility:* > OpenCV 2.0
+
+                  *Author:* |Author_BernatG|
+
+                  You will learn how to store images in the memory and how to print out their content to the console.
+
+  =============== ======================================================
+
+  .. |MatBasicIma| image:: images/matTheBasicImageStructure.jpg
+                   :height: 90pt
+                   :width:  90pt
+
++
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+
+  =============== ======================================================
+   |HowScanImag|  **Title:** :ref:`howToScanImagesOpenCV`
+
+                  *Compatibility:* > OpenCV 2.0
+
+                  *Author:* |Author_BernatG|
+
+                  You'll find out how to scan images (go through each of the image pixels) with OpenCV. Bonus: time measurement with OpenCV.
+
+  =============== ======================================================
+
+  .. |HowScanImag| image:: images/howToScanImages.jpg
+                   :height: 90pt
+                   :width:  90pt
+                   
+
 +
   .. tabularcolumns:: m{100pt} m{300pt}
   .. cssclass:: toctableopencv
@@ -22,7 +61,7 @@ Here you will learn the about the basic building blocks of the library. A must r
 
   =============== ======================================================
 
-  .. |Beginners_4| image:: images/Adding_Images_Tutorial_Result_0.png
+  .. |Beginners_4| image:: images/Adding_Images_Tutorial_Result_0.jpg
                    :height: 90pt
                    :width:  90pt
 
@@ -41,7 +80,7 @@ Here you will learn the about the basic building blocks of the library. A must r
 
   =============== ====================================================
 
-  .. |Bas_Lin_Tran| image:: images/Basic_Linear_Transform_Tutorial_Result_0.png
+  .. |Bas_Lin_Tran| image:: images/Basic_Linear_Transform_Tutorial_Result_0.jpg
                               :height: 90pt
                               :width:  90pt
 
@@ -62,7 +101,7 @@ Here you will learn the about the basic building blocks of the library. A must r
 
   =============== ======================================================
 
-  .. |Beginners_6| image:: images/Drawing_1_Tutorial_Result_0.png
+  .. |Beginners_6| image:: images/Drawing_1_Tutorial_Result_0.jpg
                    :height: 90pt
                    :width:  90pt
 
@@ -81,14 +120,21 @@ Here you will learn the about the basic building blocks of the library. A must r
 
   =============== ======================================================
 
-  .. |Beginners_7| image:: images/Drawing_2_Tutorial_Result_7.png
+  .. |Beginners_7| image:: images/Drawing_2_Tutorial_Result_7.jpg
                    :height: 90pt
                    :width:  90pt
 
+.. raw:: latex
+
+   \pagebreak
+
 .. toctree::
    :hidden:
    
+   ../mat - the basic image container/mat - the basic image container
+   ../how_to_scan_images/how_to_scan_images
    ../adding_images/adding_images
    ../basic_linear_transform/basic_linear_transform
    ../basic_geometric_drawing/basic_geometric_drawing
    ../random_generator_and_text/random_generator_and_text
+   ../mat-mask-operations/mat-mask-operations.rst
\ No newline at end of file

doc/tutorials/features2d/table_of_content_features2d/table_of_content_features2d.rst

@@ -86,6 +86,10 @@ Learn about how to use the feature points  detectors, descriptors and matching f
                      :height: 90pt
                      :width:  90pt
 
+.. raw:: latex
+
+   \pagebreak
+
 .. toctree::
    :hidden:
 

doc/tutorials/general/table_of_content_general/table_of_content_general.rst

@@ -6,3 +6,8 @@ General tutorials
 These tutorials are the bottom of the iceberg as they link together multiple of the modules presented above in order to solve complex problems.
 
 .. include:: ../../definitions/noContent.rst
+
+.. raw:: latex
+
+   \pagebreak
+

doc/tutorials/gpu/table_of_content_gpu/table_of_content_gpu.rst

@@ -6,3 +6,7 @@
 Squeeze out every little computation power from your system by using the power of your video card to run the OpenCV algorithms.
 
 .. include:: ../../definitions/noContent.rst
+
+.. raw:: latex
+
+   \pagebreak

doc/tutorials/highgui/table_of_content_highgui/table_of_content_highgui.rst

@@ -5,11 +5,6 @@
 
 This section contains valuable tutorials about how to read/save your image/video files and how to use the built-in graphical user interface of the library. 
 
-.. toctree::
-   :hidden:
-   
-   ../trackbar/trackbar
-
 * :ref:`Adding_Trackbars`
 
      =============== ======================================================
@@ -21,6 +16,15 @@ This section contains valuable tutorials about how to read/save your image/video
     
      =============== ======================================================
     
-     .. |Beginners_5| image:: images/Adding_Trackbars_Tutorial_Cover.png
+     .. |Beginners_5| image:: images/Adding_Trackbars_Tutorial_Cover.jpg
                       :height: 100pt
                       :width:  100pt
+
+.. raw:: latex
+
+   \pagebreak
+
+.. toctree::
+   :hidden:
+
+   ../trackbar/trackbar

doc/tutorials/highgui/trackbar/trackbar.rst

@@ -7,7 +7,7 @@ Adding a Trackbar to our applications!
 
 * Well, it is time to use some fancy GUI tools. OpenCV provides some GUI utilities (*highgui.h*) for you. An example of this is a **Trackbar** 
 
-  .. image:: images/Adding_Trackbars_Tutorial_Trackbar.png
+  .. image:: images/Adding_Trackbars_Tutorial_Trackbar.jpg
      :alt: Trackbar example
      :align: center 
 
@@ -145,13 +145,13 @@ Result
 
 * Our program produces the following output:
 
-  .. image:: images/Adding_Trackbars_Tutorial_Result_0.png
+  .. image:: images/Adding_Trackbars_Tutorial_Result_0.jpg
      :alt: Adding Trackbars - Windows Linux
      :align: center 
 
 * As a manner of practice, you can also add 02 trackbars for the program made in :ref:`Basic_Linear_Transform`. One trackbar to set :math:`\alpha` and another for :math:`\beta`. The output might look like:
 
-  .. image:: images/Adding_Trackbars_Tutorial_Result_1.png
+  .. image:: images/Adding_Trackbars_Tutorial_Result_1.jpg
      :alt: Adding Trackbars - Lena
      :height: 500px
      :align: center 

doc/tutorials/imgproc/erosion_dilatation/erosion_dilatation.rst

@@ -34,7 +34,7 @@ Morphological Operations
 
 * We will explain dilation and erosion briefly, using the following image as an example:
 
-  .. image:: images/Morphology_1_Tutorial_Theory_Original_Image.png
+  .. image:: images/Morphology_1_Tutorial_Theory_Original_Image.jpg
      :alt: Original image
      :height: 100px
      :align: center 
@@ -48,7 +48,7 @@ Dilation
 
 * As the kernel :math:`B` is scanned over the image, we compute the maximal pixel value overlapped by :math:`B` and replace the image pixel in the anchor point position with that maximal value. As you can deduce, this maximizing operation causes bright regions within an image to "grow" (therefore the name *dilation*). Take as an example the image above. Applying dilation we can get:
 
-  .. image:: images/Morphology_1_Tutorial_Theory_Dilation.png
+  .. image:: images/Morphology_1_Tutorial_Theory_Dilation.jpg
      :alt: Dilation result - Theory example
      :height: 100px
      :align: center 
@@ -64,7 +64,7 @@ Erosion
 
 * Analagously to the example for dilation, we can apply the erosion operator to the original image (shown above). You can see in the result below that the bright areas of the image (the background, apparently), get thinner, whereas the dark zones (the "writing"( gets bigger.
 
-  .. image:: images/Morphology_1_Tutorial_Theory_Erosion.png
+  .. image:: images/Morphology_1_Tutorial_Theory_Erosion.jpg
      :alt: Erosion result - Theory example
      :height: 100px
      :align: center 
@@ -266,14 +266,14 @@ Results
 
 * Compile the code above and execute it with an image as argument. For instance, using this image:
 
-  .. image:: images/Morphology_1_Tutorial_Original_Image.png
+  .. image:: images/Morphology_1_Tutorial_Original_Image.jpg
      :alt: Original image
      :height: 200px
      :align: center 
 
   We get the results below. Varying the indices in the Trackbars give different output images, naturally. Try them out! You can even try to add a third Trackbar to control the number of iterations.
 
-  .. image:: images/Morphology_1_Tutorial_Cover.png
+  .. image:: images/Morphology_1_Tutorial_Cover.jpg
      :alt: Dilation and Erosion application
      :height: 400px
      :align: center 

doc/tutorials/imgproc/gausian_median_blur_bilateral_filter/gausian_median_blur_bilateral_filter.rst

@@ -149,7 +149,7 @@ Code
       namedWindow( window_name, CV_WINDOW_AUTOSIZE );
 
       /// Load the source image
-      src = imread( "../images/lena.png", 1 ); 
+      src = imread( "../images/lena.jpg", 1 ); 
 
       if( display_caption( "Original Image" ) != 0 ) { return 0; }
 
@@ -318,7 +318,7 @@ Results
 
 .. container:: enumeratevisibleitemswithsquare
 
-   * The code opens an image (in this case *lena.png*) and display it under the effects of the 4 filters explained. 
+   * The code opens an image (in this case *lena.jpg*) and display it under the effects of the 4 filters explained. 
 
    * Here is a snapshot of the image smoothed using *medianBlur*:
 

doc/tutorials/imgproc/imgtrans/filter_2d/filter_2d.rst

@@ -25,7 +25,7 @@ What is a kernel?
 ------------------
 A kernel is essentially a fixed size array of numerical coefficeints along with an *anchor point* in that array, which is tipically located at the center. 
 
-.. image:: images/filter_2d_tutorial_kernel_theory.png
+.. image:: images/filter_2d_tutorial_kernel_theory.jpg
         :alt: kernel example
         :align: center 
 
@@ -194,6 +194,6 @@ Results
 
 #. After compiling the code above, you  can execute it giving as argument the path of an image. The result should be a window that shows an image blurred by a normalized filter. Each 0.5 seconds the kernel size should change, as can be seen in the series of snapshots below:
 
-   .. image:: images/filter_2d_tutorial_result.png
+   .. image:: images/filter_2d_tutorial_result.jpg
            :alt: kernel example
            :align: center

doc/tutorials/imgproc/imgtrans/hough_lines/hough_lines.rst

@@ -91,13 +91,19 @@ b. **The Probabilistic Hough Line Transform**
 Code
 ======
 
+.. |TutorialHoughLinesSimpleDownload| replace:: here
+.. _TutorialHoughLinesSimpleDownload: https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/houghlines.cpp
+.. |TutorialHoughLinesFancyDownload| replace:: here
+.. _TutorialHoughLinesFancyDownload: https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/ImgTrans/HoughLines_Demo.cpp
+
+
 #. **What does this program do?**
  
    * Loads an image
    * Applies either a *Standard Hough Line Transform* or a *Probabilistic Line Transform*. 
    * Display the original image and the detected line in two windows.
 
-#. The sample code that we will explain can be downloaded from `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/houghlines.cpp>`_. A slightly fancier version (which shows both Hough standard and probabilistic with trackbars for changing the threshold values) can be found  `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/ImgTrans/HoughLines_Demo.cpp>`_
+#. The sample code that we will explain can be downloaded from  |TutorialHoughLinesSimpleDownload|_. A slightly fancier version (which shows both Hough standard and probabilistic with trackbars for changing the threshold values) can be found  |TutorialHoughLinesFancyDownload|_.
 
 .. code-block:: cpp 
 
@@ -113,12 +119,12 @@ Code
    {
     cout << "\nThis program demonstrates line finding with the Hough transform.\n"
             "Usage:\n"
-            "./houghlines <image_name>, Default is pic1.png\n" << endl;
+            "./houghlines <image_name>, Default is pic1.jpg\n" << endl;
    }
 
    int main(int argc, char** argv)
    {
-    const char* filename = argc >= 2 ? argv[1] : "pic1.png";
+    const char* filename = argc >= 2 ? argv[1] : "pic1.jpg";
 
     Mat src = imread(filename, 0);
     if(src.empty())

doc/tutorials/imgproc/opening_closing_hats/opening_closing_hats.rst

@@ -43,7 +43,7 @@ Opening
 
 * For instance, check out the example below. The image at the left is the original and the image at the right is the result after applying the opening transformation. We can observe that the small spaces in the corners of the letter tend to dissapear.
 
-  .. image:: images/Morphology_2_Tutorial_Theory_Opening.png
+  .. image:: images/Morphology_2_Tutorial_Theory_Opening.jpg
      :height: 150pt
      :alt: Opening
      :align: center  
@@ -59,7 +59,7 @@ Closing
 
 * Useful to remove small holes (dark regions). 
 
-  .. image:: images/Morphology_2_Tutorial_Theory_Closing.png
+  .. image:: images/Morphology_2_Tutorial_Theory_Closing.jpg
      :height: 150pt
      :alt: Closing example
      :align: center  
@@ -76,7 +76,7 @@ Morphological Gradient
 
 * It is useful for finding the outline of an object as can be seen below:
 
-  .. image:: images/Morphology_2_Tutorial_Theory_Gradient.png
+  .. image:: images/Morphology_2_Tutorial_Theory_Gradient.jpg
      :height: 150pt
      :alt: Gradient
      :align: center  
@@ -91,7 +91,7 @@ Top Hat
    
      dst = tophat( src, element ) = src - open( src, element )
 
-  .. image:: images/Morphology_2_Tutorial_Theory_TopHat.png
+  .. image:: images/Morphology_2_Tutorial_Theory_TopHat.jpg
      :height: 150pt
      :alt: Top Hat
      :align: center  
@@ -105,7 +105,7 @@ Black Hat
  
      dst = blackhat( src, element ) = close( src, element ) - src
 
-  .. image:: images/Morphology_2_Tutorial_Theory_BlackHat.png
+  .. image:: images/Morphology_2_Tutorial_Theory_BlackHat.jpg
      :height: 150pt
      :alt: Black Hat
      :align: center    
@@ -279,7 +279,7 @@ Results
 
 * And here are two snapshots of the display window. The first picture shows the output after using the operator **Opening** with a cross kernel. The second picture (right side, shows the result of using a **Blackhat** operator with an ellipse kernel.
  
-  .. image:: images/Morphology_2_Tutorial_Cover.png
+  .. image:: images/Morphology_2_Tutorial_Cover.jpg
      :height: 300pt
      :alt: Morphology 2: Result sample
      :align: center 

doc/tutorials/imgproc/pyramids/pyramids.rst

@@ -41,7 +41,7 @@ Gaussian Pyramid
 
 * Imagine the pyramid as a set of layers in which the higher the layer, the smaller the size. 
 
-  .. image:: images/Pyramids_Tutorial_Pyramid_Theory.png
+  .. image:: images/Pyramids_Tutorial_Pyramid_Theory.jpg
      :alt: Pyramid figure
      :align: center 
 
@@ -103,7 +103,7 @@ This tutorial code's is shown lines below. You can also download it from `here <
      printf( " * [ESC] -> Close program \n \n" );
 
      /// Test image - Make sure it s divisible by 2^{n}
-     src = imread( "../images/chicky_512.png" );
+     src = imread( "../images/chicky_512.jpg" );
      if( !src.data )
        { printf(" No data! -- Exiting the program \n");
          return -1; }
@@ -148,7 +148,7 @@ Explanation
      .. code-block:: cpp
 
         /// Test image - Make sure it s divisible by 2^{n}
-        src = imread( "../images/chicky_512.png" );
+        src = imread( "../images/chicky_512.jpg" );
         if( !src.data )
           { printf(" No data! -- Exiting the program \n");
             return -1; }
@@ -235,21 +235,21 @@ Explanation
 Results
 ========
 
-* After compiling the code above we can test it. The program calls an image **chicky_512.png** that comes in the *tutorial_code/image* folder. Notice that this image is :math:`512 \times 512`, hence a downsample won't generate any error (:math:`512 = 2^{9}`). The original image is shown below:
+* After compiling the code above we can test it. The program calls an image **chicky_512.jpg** that comes in the *tutorial_code/image* folder. Notice that this image is :math:`512 \times 512`, hence a downsample won't generate any error (:math:`512 = 2^{9}`). The original image is shown below:
 
-  .. image:: images/Pyramids_Tutorial_Original_Image.png
+  .. image:: images/Pyramids_Tutorial_Original_Image.jpg
      :alt: Pyramids: Original image	
      :align: center 
 
 * First we apply two successive :pyr_down:`pyrDown <>` operations by pressing 'd'. Our output is:
  
-  .. image:: images/Pyramids_Tutorial_PyrDown_Result.png
+  .. image:: images/Pyramids_Tutorial_PyrDown_Result.jpg
      :alt: Pyramids: PyrDown Result
      :align: center 
 
 * Note that we should have lost some resolution due to the fact that we are diminishing the size of the image. This is evident after we apply :pyr_up:`pyrUp <>` twice (by pressing 'u'). Our output is now:
  
-  .. image:: images/Pyramids_Tutorial_PyrUp_Result.png
+  .. image:: images/Pyramids_Tutorial_PyrUp_Result.jpg
      :alt: Pyramids: PyrUp Result
      :align: center 
 

doc/tutorials/imgproc/table_of_content_imgproc/table_of_content_imgproc.rst

@@ -42,7 +42,7 @@ In this section you will learn about the image processing (manipulation) functio
   
   ===================== ==============================================
   
-  .. |ImageProcessing_2| image:: images/Morphology_1_Tutorial_Cover.png
+  .. |ImageProcessing_2| image:: images/Morphology_1_Tutorial_Cover.jpg
                          :height: 90pt
                          :width:  90pt
      
@@ -61,7 +61,7 @@ In this section you will learn about the image processing (manipulation) functio
   
   ================= ==================================================
   
-  .. |Morphology_2| image:: images/Morphology_2_Tutorial_Cover.png
+  .. |Morphology_2| image:: images/Morphology_2_Tutorial_Cover.jpg
                      :height: 90pt
                      :width:  90pt
   
@@ -81,7 +81,7 @@ In this section you will learn about the image processing (manipulation) functio
   
   ===================== ==============================================
   
-  .. |Pyramids| image:: images/Pyramids_Tutorial_Cover.png
+  .. |Pyramids| image:: images/Pyramids_Tutorial_Cover.jpg
                       :height: 90pt
                       :width:  90pt
   
@@ -101,7 +101,7 @@ In this section you will learn about the image processing (manipulation) functio
   
   ===================== ==============================================
   
-  .. |Threshold| image:: images/Threshold_Tutorial_Cover.png
+  .. |Threshold| image:: images/Threshold_Tutorial_Cover.jpg
                       :height: 90pt
                       :width:  90pt
   
@@ -507,7 +507,9 @@ In this section you will learn about the image processing (manipulation) functio
                 :height: 90pt
                 :width:  90pt
 
+.. raw:: latex
 
+   \pagebreak
 
 .. toctree::
    :hidden:

doc/tutorials/imgproc/threshold/threshold.rst

@@ -28,7 +28,7 @@ What is Thresholding?
 
 * Once we have separated properly the important pixels, we can set them with a determined value to identify them (i.e. we can assign them a value of :math:`0` (black), :math:`255` (white) or any value  that suits your needs).
 
-  .. image:: images/Threshold_Tutorial_Theory_Example.png
+  .. image:: images/Threshold_Tutorial_Theory_Example.jpg
      :alt: Threshold simple example
      :height: 150pt
      :align: center 
@@ -42,7 +42,7 @@ Types of Thresholding
 
 * To illustrate how these thresholding processes work, let's consider that we have a source image with pixels with intensity values :math:`src(x,y)`. The plot below depicts this. The horizontal blue line represents the threshold :math:`thresh` (fixed).
 
-  .. image:: images/Threshold_Tutorial_Theory_Base_Figure.png
+  .. image:: images/Threshold_Tutorial_Theory_Base_Figure.jpg
      :alt: Threshold Binary
      :height: 100pt
      :align: center 
@@ -58,7 +58,7 @@ Threshold Binary
  
 * So, if the intensity of the pixel :math:`src(x,y)` is higher than :math:`thresh`, then the new pixel intensity is set to a :math:`MaxVal`. Otherwise, the pixels are set to :math:`0`.
 
-  .. image:: images/Threshold_Tutorial_Theory_Binary.png
+  .. image:: images/Threshold_Tutorial_Theory_Binary.jpg
      :alt: Threshold Binary
      :height: 100pt
      :align: center 
@@ -75,7 +75,7 @@ Threshold Binary, Inverted
 
 * If the intensity of the pixel :math:`src(x,y)` is higher than :math:`thresh`, then the new pixel intensity is set to a :math:`0`. Otherwise, it is set to :math:`MaxVal`.
         
-  .. image:: images/Threshold_Tutorial_Theory_Binary_Inverted.png
+  .. image:: images/Threshold_Tutorial_Theory_Binary_Inverted.jpg
      :alt: Threshold Binary Inverted
      :height: 100pt
      :align: center 
@@ -91,7 +91,7 @@ Truncate
        
 * The maximum intensity value for the pixels is :math:`thresh`, if :math:`src(x,y)` is greater, then its value is *truncated*. See figure below:
  
-  .. image:: images/Threshold_Tutorial_Theory_Truncate.png
+  .. image:: images/Threshold_Tutorial_Theory_Truncate.jpg
      :alt: Threshold Truncate
      :height: 100pt
      :align: center 
@@ -109,7 +109,7 @@ Threshold to Zero
 
 * If :math:`src(x,y)` is lower than :math:`thresh`, the new pixel value will be set to :math:`0`.
 
-  .. image:: images/Threshold_Tutorial_Theory_Zero.png
+  .. image:: images/Threshold_Tutorial_Theory_Zero.jpg
      :alt: Threshold Zero
      :height: 100pt
      :align: center 
@@ -126,7 +126,7 @@ Threshold to Zero, Inverted
 
 * If  :math:`src(x,y)` is greater than :math:`thresh`, the new pixel value will be set to :math:`0`.
 
-  .. image:: images/Threshold_Tutorial_Theory_Zero_Inverted.png
+  .. image:: images/Threshold_Tutorial_Theory_Zero_Inverted.jpg
      :alt: Threshold Zero Inverted
      :height: 100pt
      :align: center 
@@ -296,7 +296,7 @@ Results
 #. After compiling this program, run it giving a path to an image as argument. For instance, for an input image as:
 
 
-   .. image:: images/Threshold_Tutorial_Original_Image.png
+   .. image:: images/Threshold_Tutorial_Original_Image.jpg
       :alt: Threshold Original Image
       :height: 200pt
       :align: center 
@@ -304,7 +304,7 @@ Results
 #. First, we try to threshold our image with a *binary threhold inverted*. We expect that the pixels brighter than the :math:`thresh` will turn dark, which is what actually happens, as we can see in the snapshot below (notice from the original image, that the doggie's tongue and eyes are particularly bright in comparison with the image, this is reflected in the output image).
 
 
-   .. image:: images/Threshold_Tutorial_Result_Binary_Inverted.png
+   .. image:: images/Threshold_Tutorial_Result_Binary_Inverted.jpg
       :alt: Threshold Result Binary Inverted
       :height: 200pt
       :align: center 
@@ -312,7 +312,7 @@ Results
 
 #. Now we try with the *threshold to zero*. With this, we expect that the darkest pixels (below the threshold) will become completely black, whereas the pixels with value greater than the threshold will keep its original value. This is verified by the following snapshot of the output image:
 
-   .. image:: images/Threshold_Tutorial_Result_Zero.png
+   .. image:: images/Threshold_Tutorial_Result_Zero.jpg
       :alt: Threshold Result Zero
       :height: 200pt
       :align: center 

doc/tutorials/introduction/display_image/display_image.rst

@@ -116,7 +116,7 @@ Result
 
 * You should get a nice window as the one shown below:
 
-  .. image:: images/Display_Image_Tutorial_Result.png
+  .. image:: images/Display_Image_Tutorial_Result.jpg
      :alt: Display Image Tutorial - Final Result
      :align: center 
 

doc/tutorials/introduction/linux_eclipse/linux_eclipse.rst

@@ -24,28 +24,28 @@ Making a project
 
 #. Go to **File -> New -> C/C++ Project**
 
-   .. image:: images/a0.png
+   .. image:: images/a0.jpg
       :height: 400px 
       :alt: Eclipse Tutorial Screenshot 0
       :align: center
 
 #. Choose a name for your project (i.e. DisplayImage). An **Empty Project** should be okay for this example. 
 
-   .. image:: images/a1.png
+   .. image:: images/a1.jpg
       :height: 400px 
       :alt: Eclipse Tutorial Screenshot 1
       :align: center
 
 #. Leave everything else by default. Press **Finish**. 
 
-   .. image:: images/a2.png
+   .. image:: images/a2.jpg
       :height: 400px 
       :alt: Eclipse Tutorial Screenshot 2
       :align: center
 
 #. Your project (in this case DisplayImage) should appear in the **Project Navigator** (usually at the left side of your window).
 
-   .. image:: images/a3.png
+   .. image:: images/a3.jpg
       :height: 400px 
       :alt: Eclipse Tutorial Screenshot 3
       :align: center
@@ -55,28 +55,28 @@ Making a project
 
    * Right click on **DisplayImage** (in the Navigator). **New -> Folder** . 
 
-     .. image:: images/a4.png
+     .. image:: images/a4.jpg
         :height: 400px 
         :alt: Eclipse Tutorial Screenshot 4
         :align: center
 
    * Name your folder **src** and then hit **Finish**
 
-     .. image:: images/a5.png
+     .. image:: images/a5.jpg
         :height: 400px 
         :alt: Eclipse Tutorial Screenshot 5
         :align: center
 
    * Right click on your newly created **src** folder. Choose **New source file**:
 
-     .. image:: images/a6.png
+     .. image:: images/a6.jpg
         :height: 400px 
         :alt: Eclipse Tutorial Screenshot 6
         :align: center
 
    * Call it **DisplayImage.cpp**. Hit **Finish**
 
-     .. image:: images/a7.png
+     .. image:: images/a7.jpg
         :height: 400px 
         :alt: Eclipse Tutorial Screenshot 7
         :align: center
@@ -113,7 +113,7 @@ Making a project
 
     * Go to  **Project-->Properties**
 
-     .. image:: images/a8.png
+     .. image:: images/a8.jpg
         :height: 400px 
         :alt: Eclipse Tutorial Screenshot 8
         :align: center
@@ -122,7 +122,7 @@ Making a project
 
       a. In **GCC C++ Compiler**, go to **Includes**. In **Include paths(-l)** you should include the path of the folder where opencv was installed. In our example, this is ``/usr/local/include/opencv``.
 
-         .. image:: images/a9.png
+         .. image:: images/a9.jpg
             :height: 400px 
             :alt: Eclipse Tutorial Screenshot 9
             :align: center
@@ -163,7 +163,7 @@ Making a project
          opencv_legacy    
          opencv_flann
 
-         .. image:: images/a10.png
+         .. image:: images/a10.jpg
              :height: 400px 
              :alt: Eclipse Tutorial Screenshot 10
              :align: center 
@@ -184,14 +184,14 @@ Making a project
 
     * Your project should be ready to be built. For this, go to **Project->Build all**   
 
-      .. image:: images/a11.png
+      .. image:: images/a11.jpg
          :height: 400px 
          :alt: Eclipse Tutorial Screenshot 11
          :align: center 
 
       In the Console you should get something like 
 
-      .. image:: images/a12.png
+      .. image:: images/a12.jpg
          :height: 200px 
          :alt: Eclipse Tutorial Screenshot 12
          :align: center 
@@ -214,7 +214,7 @@ Assuming that the image to use as the argument would be located in <DisplayImage
 
 #. Go to **Run->Run Configurations** 
 
-   .. image:: images/a13.png
+   .. image:: images/a13.jpg
       :height: 300px 
       :alt: Eclipse Tutorial Screenshot 13
       :align: center 
@@ -223,14 +223,14 @@ Assuming that the image to use as the argument would be located in <DisplayImage
 
 #. Now, in the right side of the window, choose the **Arguments** Tab. Write the path of the image file we want to open (path relative to the workspace/DisplayImage folder). Let's use **HappyLittleFish.jpg**:
 
-   .. image:: images/a14.png
+   .. image:: images/a14.jpg
       :height: 300px 
       :alt: Eclipse Tutorial Screenshot 14
       :align: center 
 
 #. Click on the **Apply** button and then in Run. An OpenCV window should pop up with the fish image (or whatever you used).
 
-   .. image:: images/a15.png
+   .. image:: images/a15.jpg
       :alt: Eclipse Tutorial Screenshot 15
       :align: center 
 

doc/tutorials/introduction/linux_gcc_cmake/linux_gcc_cmake.rst

@@ -78,6 +78,6 @@ By now you should have an executable (called DisplayImage in this case). You jus
 
 You should get a nice window as the one shown below:
 
-.. image:: images/GCC_CMake_Example_Tutorial.png
+.. image:: images/GCC_CMake_Example_Tutorial.jpg
    :alt: Display Image - Lena
    :align: center

doc/tutorials/introduction/load_save_image/load_save_image.rst

@@ -5,19 +5,18 @@ Load, Modify, and Save an Image
 
 .. note::
 
-   We assume that by now you know:
-
-   * Load an image using :imread:`imread <>`
-   * Display an image in an OpenCV window (using :imshow:`imshow <>`)
+   We assume that by now you know how to load an image using :imread:`imread <>` and to display it in a window (using :imshow:`imshow <>`). Read the :ref:`Display_Image` tutorial otherwise. 
  
 Goals
 ======
 
 In this tutorial you will learn how to:
 
-* Load an image using :imread:`imread <>`
-* Transform an image from RGB to Grayscale format by using :cvt_color:`cvtColor <>`
-* Save your transformed image in a file on disk (using :imwrite:`imwrite <>`)
+.. container:: enumeratevisibleitemswithsquare
+
+   * Load an image using :imread:`imread <>`
+   * Transform an image from RGB to Grayscale format by using :cvt_color:`cvtColor <>`
+   * Save your transformed image in a file on disk (using :imwrite:`imwrite <>`)
 
 Code
 ======
@@ -48,7 +47,7 @@ Here it is:
     Mat gray_image;
     cvtColor( image, gray_image, CV_RGB2GRAY );
 
-    imwrite( "../../images/Gray_Image.png", gray_image );
+    imwrite( "../../images/Gray_Image.jpg", gray_image );
 
     namedWindow( imageName, CV_WINDOW_AUTOSIZE );
     namedWindow( "Gray image", CV_WINDOW_AUTOSIZE );
@@ -77,20 +76,21 @@ Explanation
 
    As you can see, :cvt_color:`cvtColor <>` takes as arguments:
 
+   .. container:: enumeratevisibleitemswithsquare
+
       * a source image (*image*) 
       * a destination image (*gray_image*), in which we will save the converted image.
-
-   And an additional parameter that indicates what kind of transformation will be performed. In this case we use **CV_RGB2GRAY** (self-explanatory).
+      * an additional parameter that indicates what kind of transformation will be performed. In this case we use **CV_RGB2GRAY** (self-explanatory).
 
 #. So now we have our new *gray_image* and want to save it on disk (otherwise it will get lost after the program ends). To save it, we will use a function analagous to :imread:`imread <>`: :imwrite:`imwrite <>`
 
    .. code-block:: cpp
 
-      imwrite( "../../images/Gray_Image.png", gray_image );   
+      imwrite( "../../images/Gray_Image.jpg", gray_image );   
 
-   Which will save our *gray_image* as *Gray_Image.png* in the folder *images* located two levels up of my current location.
+   Which will save our *gray_image* as *Gray_Image.jpg* in the folder *images* located two levels up of my current location.
 
-#. Finally, let's check out the images. We create 02 windows and use them to show the original image as well as the new one:
+#. Finally, let's check out the images. We create two windows and use them to show the original image as well as the new one:
 
    .. code-block:: cpp
 
@@ -100,7 +100,7 @@ Explanation
       imshow( imageName, image );
       imshow( "Gray image", gray_image );
 
-#. Add the usual *waitKey(0)* for the program to wait forever until the user presses a key.
+#. Add add the *waitKey(0)* function call for the program to wait forever for an user key press.
 
 
 Result
@@ -108,14 +108,14 @@ Result
 
 When you run your program you should get something like this:
 
- .. image:: images/Load_Save_Image_Result_1.png
+ .. image:: images/Load_Save_Image_Result_1.jpg
     :alt: Load Save Image Result 1
     :height: 400px
     :align: center
 
-And if you check in your folder (in my case *images*), you should have a newly .png file named *Gray_Image.png*:
+And if you check in your folder (in my case *images*), you should have a newly .jpg file named *Gray_Image.jpg*:
 
- .. image:: images/Load_Save_Image_Result_2.png
+ .. image:: images/Load_Save_Image_Result_2.jpg
     :alt: Load Save Image Result 2
     :height: 250px
     :align: center

doc/tutorials/introduction/table_of_content_introduction/table_of_content_introduction.rst

@@ -41,7 +41,7 @@ Here you can read tutorials about how to set up your computer to work with the O
 
   =========== ======================================================
 
-  .. |Usage_1| image:: images/gccegg-65.png
+  .. |Usage_1| image:: images/gccegg-65.jpg
                :height: 90pt
                :width:  90pt
 
@@ -137,7 +137,7 @@ Here you can read tutorials about how to set up your computer to work with the O
 
   ============= ======================================================
 
-  .. |Beginners_1| image:: images/Display_Image_Tutorial_Result.png
+  .. |Beginners_1| image:: images/Display_Image_Tutorial_Result.jpg
                    :height: 90pt
                    :width:  90pt
 
@@ -155,10 +155,14 @@ Here you can read tutorials about how to set up your computer to work with the O
 
   =============== ======================================================
 
-  .. |Beginners_2| image:: images/Load_Save_Image_Result_1.png
+  .. |Beginners_2| image:: images/Load_Save_Image_Result_1.jpg
                    :height: 90pt
                    :width:  90pt
 
+.. raw:: latex
+
+   \pagebreak
+
 .. We use a custom table of content format and as the table of content only imforms Sphinx about the hierarchy of the files, no need to show it.
 .. toctree::
    :hidden:                

doc/tutorials/ml/table_of_content_ml/table_of_content_ml.rst

@@ -6,3 +6,7 @@
 Use the powerfull machine learning classes for statistical classification, regression and clustering of data.
 
 .. include:: ../../definitions/noContent.rst
+
+.. raw:: latex
+
+   \pagebreak

doc/tutorials/tutorials.rst

@@ -16,7 +16,7 @@ As always, we would be happy to hear your comments and receive your contribution
   
    =========== =======================================================
   
-   .. |Introduct| image:: images/introduction.png
+   .. |Introduct| image:: images/introduction.jpg
                  :height: 80pt
                  :width:  80pt
                  :alt: Introduction Icon
@@ -31,7 +31,7 @@ As always, we would be happy to hear your comments and receive your contribution
   
    =========== =======================================================
   
-   .. |Core| image:: images/core.png
+   .. |Core| image:: images/core.jpg
                  :height: 80pt
                  :width:  80pt
                  :alt: core Icon
@@ -46,7 +46,7 @@ As always, we would be happy to hear your comments and receive your contribution
   
    =========== =======================================================
   
-   .. |ImgProc| image:: images/imgproc.png
+   .. |ImgProc| image:: images/imgproc.jpg
                  :height: 80pt
                  :width:  80pt
                  :alt: imgproc Icon
@@ -61,7 +61,7 @@ As always, we would be happy to hear your comments and receive your contribution
   
    =========== =======================================================
   
-   .. |HighGui| image:: images/highgui.png
+   .. |HighGui| image:: images/highgui.jpg
                  :height: 80pt
                  :width:  80pt
                  :alt: highgui Icon
@@ -76,7 +76,7 @@ As always, we would be happy to hear your comments and receive your contribution
   
    =========== =======================================================
   
-   .. |Calib3D| image:: images/calib3d.png
+   .. |Calib3D| image:: images/calib3d.jpg
                  :height: 80pt
                  :width:  80pt
                  :alt: calib3d Icon
@@ -91,7 +91,7 @@ As always, we would be happy to hear your comments and receive your contribution
   
    =========== =======================================================
   
-   .. |Featur2D| image:: images/feature2D.png
+   .. |Featur2D| image:: images/feature2D.jpg
                  :height: 80pt
                  :width:  80pt
                  :alt: feature2D Icon
@@ -106,7 +106,7 @@ As always, we would be happy to hear your comments and receive your contribution
   
    =========== =======================================================
   
-   .. |Video| image:: images/video.png
+   .. |Video| image:: images/video.jpg
                  :height: 80pt
                  :width:  80pt
                  :alt: video Icon
@@ -121,7 +121,7 @@ As always, we would be happy to hear your comments and receive your contribution
   
    =========== =======================================================
   
-   .. |ObjDetect| image:: images/objdetect.png
+   .. |ObjDetect| image:: images/objdetect.jpg
                  :height: 80pt
                  :width:  80pt
                  :alt: objdetect Icon
@@ -136,7 +136,7 @@ As always, we would be happy to hear your comments and receive your contribution
   
    =========== =======================================================
   
-   .. |ml| image:: images/ml.png
+   .. |ml| image:: images/ml.jpg
                  :height: 80pt
                  :width:  80pt
                  :alt: ml Icon
@@ -151,7 +151,7 @@ As always, we would be happy to hear your comments and receive your contribution
   
    =========== =======================================================
   
-   .. |GPU| image:: images/gpu.png
+   .. |GPU| image:: images/gpu.jpg
                  :height: 80pt
                  :width:  80pt
                  :alt: gpu icon
@@ -166,11 +166,15 @@ As always, we would be happy to hear your comments and receive your contribution
   
    =========== =======================================================
   
-   .. |General| image:: images/general.png
+   .. |General| image:: images/general.jpg
                  :height: 80pt
                  :width:  80pt
                  :alt: General Icon
 
+.. raw:: latex
+
+   \pagebreak
+
 .. toctree::
    :maxdepth: 2
    :hidden:

doc/tutorials/video/table_of_content_video/table_of_content_video.rst

@@ -6,3 +6,7 @@
 Look here in order to find use on your video stream algoritms like: motion extraction, feature tracking and foreground extractions. 
 
 .. include:: ../../definitions/noContent.rst
+
+.. raw:: latex
+
+   \pagebreak

samples/cpp/tutorial_code/CxCore/Matrix/Drawing_1.cpp

-/**
- * @file Drawing_1.cpp
- * @brief Simple sample code
- */
-
-#include <opencv2/core/core.hpp>
-#include <opencv2/highgui/highgui.hpp>
-
-#define w 400
-
-using namespace cv;
-
-/// Function headers
-void MyEllipse( Mat img, double angle );
-void MyFilledCircle( Mat img, Point center );
-void MyPolygon( Mat img );
-void MyLine( Mat img, Point start, Point end );
-
-/**
- * @function main
- * @brief Main function
- */
-int main( int argc, char **argv ){
-
-  /// Windows names
-  char atom_window[] = "Drawing 1: Atom";
-  char rook_window[] = "Drawing 2: Rook";
-
-  /// Create black empty images 
-  Mat atom_image = Mat::zeros( w, w, CV_8UC3 );
-  Mat rook_image = Mat::zeros( w, w, CV_8UC3 );
-
-  /// 1. Draw a simple atom:
-  /// -----------------------
-
-  /// 1.a. Creating ellipses 
-  MyEllipse( atom_image, 90 );
-  MyEllipse( atom_image, 0 );
-  MyEllipse( atom_image, 45 );
-  MyEllipse( atom_image, -45 );
-
-  /// 1.b. Creating circles
-  MyFilledCircle( atom_image, Point( w/2.0, w/2.0) );
-
-  /// 2. Draw a rook
-  /// ------------------
-
-  /// 2.a. Create a convex polygon
-  MyPolygon( rook_image );
-
-  /// 2.b. Creating rectangles
-  rectangle( rook_image,
-	     Point( 0, 7*w/8.0 ),
-	     Point( w, w),
-	     Scalar( 0, 255, 255 ),
-	     -1,
-	     8 );
-
-  /// 2.c. Create a few lines 
-  MyLine( rook_image, Point( 0, 15*w/16 ), Point( w, 15*w/16 ) );
-  MyLine( rook_image, Point( w/4, 7*w/8 ), Point( w/4, w ) );
-  MyLine( rook_image, Point( w/2, 7*w/8 ), Point( w/2, w ) );
-  MyLine( rook_image, Point( 3*w/4, 7*w/8 ), Point( 3*w/4, w ) );
-
-  /// 3. Display your stuff!
-  imshow( atom_window, atom_image );
-  cvMoveWindow( atom_window, 0, 200 );
-  imshow( rook_window, rook_image );
-  cvMoveWindow( rook_window, w, 200 );
-
-  waitKey( 0 );
-  return(0);
-}
-
-/// Function Declaration
-
-/**
- * @function MyEllipse
- * @brief Draw a fixed-size ellipse with different angles
- */
-void MyEllipse( Mat img, double angle )
-{
-  int thickness = 2;
-  int lineType = 8;
-
-  ellipse( img,
-	   Point( w/2.0, w/2.0 ),
-	   Size( w/4.0, w/16.0 ),
-	   angle,
-	   0, 
-	   360,
-	   Scalar( 255, 0, 0 ),
-	   thickness,
-	   lineType );  
-}
-
-/**
- * @function MyFilledCircle
- * @brief Draw a fixed-size filled circle
- */
-void MyFilledCircle( Mat img, Point center )
-{
-  int thickness = -1;
-  int lineType = 8;
-
-  circle( img, 
-	  center,
-	  w/32.0,
-	  Scalar( 0, 0, 255 ),
-	  thickness, 
-	  lineType );
-}
-
-/**
- * @function MyPolygon
- * @function Draw a simple concave polygon (rook)
- */
-void MyPolygon( Mat img )
-{
-  int lineType = 8;
-
-  /** Create some points */
-  Point rook_points[1][20];
-  rook_points[0][0] = Point( w/4.0, 7*w/8.0 );
-  rook_points[0][1] = Point( 3*w/4.0, 7*w/8.0 );
-  rook_points[0][2] = Point( 3*w/4.0, 13*w/16.0 );
-  rook_points[0][3] = Point( 11*w/16.0, 13*w/16.0 );
-  rook_points[0][4] = Point( 19*w/32.0, 3*w/8.0 );
-  rook_points[0][5] = Point( 3*w/4.0, 3*w/8.0 );
-  rook_points[0][6] = Point( 3*w/4.0, w/8.0 );
-  rook_points[0][7] = Point( 26*w/40.0, w/8.0 );
-  rook_points[0][8] = Point( 26*w/40.0, w/4.0 );
-  rook_points[0][9] = Point( 22*w/40.0, w/4.0 );
-  rook_points[0][10] = Point( 22*w/40.0, w/8.0 );
-  rook_points[0][11] = Point( 18*w/40.0, w/8.0 );
-  rook_points[0][12] = Point( 18*w/40.0, w/4.0 );
-  rook_points[0][13] = Point( 14*w/40.0, w/4.0 );
-  rook_points[0][14] = Point( 14*w/40.0, w/8.0 );
-  rook_points[0][15] = Point( w/4.0, w/8.0 );
-  rook_points[0][16] = Point( w/4.0, 3*w/8.0 );
-  rook_points[0][17] = Point( 13*w/32.0, 3*w/8.0 );
-  rook_points[0][18] = Point( 5*w/16.0, 13*w/16.0 );
-  rook_points[0][19] = Point( w/4.0, 13*w/16.0) ;
-
-  const Point* ppt[1] = { rook_points[0] };
-  int npt[] = { 20 };
-
-  fillPoly( img,
-	    ppt,
-	    npt,
-            1,
-	    Scalar( 255, 255, 255 ),
-	    lineType );			
-}
-
-/**
- * @function MyLine
- * @brief Draw a simple line
- */
-void MyLine( Mat img, Point start, Point end )
-{
-  int thickness = 2;
-  int lineType = 8;
-  line( img, 
-	start,
-	end,
-	Scalar( 0, 0, 0 ),
-	thickness,
-	lineType );
-}
-
-

samples/cpp/tutorial_code/CxCore/Matrix/Drawing_2.cpp

-/**
- * @file Drawing_2.cpp
- * @brief Simple sample code
- */
-
-#include <opencv2/core/core.hpp>
-#include <opencv2/highgui/highgui.hpp>
-#include <iostream>
-#include <stdio.h>
-
-using namespace cv;
-
-/// Global Variables
-const int NUMBER = 100; 
-const int DELAY = 5;
-
-const int window_width = 900;
-const int window_height = 600;
-int x_1 = -window_width/2;
-int x_2 = window_width*3/2;
-int y_1 = -window_width/2;
-int y_2 = window_width*3/2;
-
-/// Function headers
-static Scalar randomColor( RNG& rng );
-int Drawing_Random_Lines( Mat image, char* window_name, RNG rng );
-int Drawing_Random_Rectangles( Mat image, char* window_name, RNG rng );
-int Drawing_Random_Ellipses( Mat image, char* window_name, RNG rng );
-int Drawing_Random_Polylines( Mat image, char* window_name, RNG rng );
-int Drawing_Random_Filled_Polygons( Mat image, char* window_name, RNG rng );
-int Drawing_Random_Circles( Mat image, char* window_name, RNG rng );
-int Displaying_Random_Text( Mat image, char* window_name, RNG rng );
-int Displaying_Big_End( Mat image, char* window_name, RNG rng );
-
-
-/**
- * @function main
- */
-int main( int argc, char** argv )
-{
-  int c;
-
-  /// Start creating a window
-  char window_name[] = "Drawing_2 Tutorial";
-
-  /// Also create a random object (RNG)
-  RNG rng( 0xFFFFFFFF ); 
-
-  /// Initialize a matrix filled with zeros
-  Mat image = Mat::zeros( window_height, window_width, CV_8UC3 );
-  /// Show it in a window during DELAY ms
-  imshow( window_name, image ); 
-  waitKey( DELAY );
-  
-  /// Now, let's draw some lines
-  c = Drawing_Random_Lines(image, window_name, rng);
-  if( c != 0 ) return 0;
-
-  /// Go on drawing, this time nice rectangles
-  c = Drawing_Random_Rectangles(image, window_name, rng);
-  if( c != 0 ) return 0;
-
-  /// Draw some ellipses
-  c = Drawing_Random_Ellipses( image, window_name, rng );
-  if( c != 0 ) return 0;
-
-  /// Now some polylines
-  c = Drawing_Random_Polylines( image, window_name, rng );
-  if( c != 0 ) return 0;
-
-  /// Draw filled polygons
-  c = Drawing_Random_Filled_Polygons( image, window_name, rng );
-  if( c != 0 ) return 0;
-
-  /// Draw circles
-  c = Drawing_Random_Circles( image, window_name, rng );
-  if( c != 0 ) return 0;
-
-  /// Display text in random positions
-  c = Displaying_Random_Text( image, window_name, rng );
-  if( c != 0 ) return 0;
-
-  /// Displaying the big end!
-  c = Displaying_Big_End( image, window_name, rng );
-  if( c != 0 ) return 0;
-
-  waitKey(0);
-  return 0;
-}
-
-/// Function definitions
-
-/**
- * @function randomColor
- * @brief Produces a random color given a random object
- */
-static Scalar randomColor( RNG& rng )
-{
-  int icolor = (unsigned) rng;
-  return Scalar( icolor&255, (icolor>>8)&255, (icolor>>16)&255 );
-}
-
-
-/**
- * @function Drawing_Random_Lines
- */
-int Drawing_Random_Lines( Mat image, char* window_name, RNG rng )
-{
-  int lineType = 8;
-  Point pt1, pt2;
-
-  for( int i = 0; i < NUMBER; i++ )
-  {
-    pt1.x = rng.uniform( x_1, x_2 );
-    pt1.y = rng.uniform( y_1, y_2 );
-    pt2.x = rng.uniform( x_1, x_2 );
-    pt2.y = rng.uniform( y_1, y_2 );
-
-    line( image, pt1, pt2, randomColor(rng), rng.uniform(1, 10), 8 );
-    imshow( window_name, image );
-    if( waitKey( DELAY ) >= 0 )
-      { return -1; }
-  }
-
-  return 0;
-}
-
-/**
- * @function Drawing_Rectangles
- */
-int Drawing_Random_Rectangles( Mat image, char* window_name, RNG rng )
-{
-  Point pt1, pt2;
-  int lineType = 8;
-  int thickness = rng.uniform( -3, 10 );
-
-  for( int i = 0; i < NUMBER; i++ )
-  {
-    pt1.x = rng.uniform( x_1, x_2 );
-    pt1.y = rng.uniform( y_1, y_2 );
-    pt2.x = rng.uniform( x_1, x_2 );
-    pt2.y = rng.uniform( y_1, y_2 );
-
-    rectangle( image, pt1, pt2, randomColor(rng), MAX( thickness, -1 ), lineType );
-
-    imshow( window_name, image );
-    if( waitKey( DELAY ) >= 0 )
-      { return -1; } 
-  }
-
-  return 0;
-}
-
-/**
- * @function Drawing_Random_Ellipses
- */
-int Drawing_Random_Ellipses( Mat image, char* window_name, RNG rng )
-{
-  int lineType = 8;
-
-  for ( int i = 0; i < NUMBER; i++ )
-  {
-    Point center;
-    center.x = rng.uniform(x_1, x_2);
-    center.y = rng.uniform(y_1, y_2);
-    
-    Size axes;
-    axes.width = rng.uniform(0, 200);
-    axes.height = rng.uniform(0, 200);
-
-    double angle = rng.uniform(0, 180);
-
-    ellipse( image, center, axes, angle, angle - 100, angle + 200,
-             randomColor(rng), rng.uniform(-1,9), lineType );
-        
-    imshow( window_name, image );
-    
-    if( waitKey(DELAY) >= 0 ) 
-      { return -1; }
-  }
-
-  return 0;
-}
-
-/**
- * @function Drawing_Random_Polylines
- */
-int Drawing_Random_Polylines( Mat image, char* window_name, RNG rng )
-{
-  int lineType = 8;
-
-  for( int i = 0; i< NUMBER; i++ )
-  {
-    Point pt[2][3];
-    pt[0][0].x = rng.uniform(x_1, x_2);
-    pt[0][0].y = rng.uniform(y_1, y_2);
-    pt[0][1].x = rng.uniform(x_1, x_2); 
-    pt[0][1].y = rng.uniform(y_1, y_2); 
-    pt[0][2].x = rng.uniform(x_1, x_2);
-    pt[0][2].y = rng.uniform(y_1, y_2);
-    pt[1][0].x = rng.uniform(x_1, x_2); 
-    pt[1][0].y = rng.uniform(y_1, y_2);
-    pt[1][1].x = rng.uniform(x_1, x_2); 
-    pt[1][1].y = rng.uniform(y_1, y_2);
-    pt[1][2].x = rng.uniform(x_1, x_2); 
-    pt[1][2].y = rng.uniform(y_1, y_2);
-
-    const Point* ppt[2] = {pt[0], pt[1]};
-    int npt[] = {3, 3};
-        
-    polylines(image, ppt, npt, 2, true, randomColor(rng), rng.uniform(1,10), lineType);
-        
-    imshow( window_name, image );
-    if( waitKey(DELAY) >= 0 )
-      { return -1; }
-  }
-  return 0;
-}    
-
-/**
- * @function Drawing_Random_Filled_Polygons
- */
-int Drawing_Random_Filled_Polygons( Mat image, char* window_name, RNG rng )
-{
-  int lineType = 8;
-
-  for ( int i = 0; i < NUMBER; i++ )
-  {
-    Point pt[2][3];
-    pt[0][0].x = rng.uniform(x_1, x_2);
-    pt[0][0].y = rng.uniform(y_1, y_2);
-    pt[0][1].x = rng.uniform(x_1, x_2); 
-    pt[0][1].y = rng.uniform(y_1, y_2); 
-    pt[0][2].x = rng.uniform(x_1, x_2);
-    pt[0][2].y = rng.uniform(y_1, y_2);
-    pt[1][0].x = rng.uniform(x_1, x_2); 
-    pt[1][0].y = rng.uniform(y_1, y_2);
-    pt[1][1].x = rng.uniform(x_1, x_2); 
-    pt[1][1].y = rng.uniform(y_1, y_2);
-    pt[1][2].x = rng.uniform(x_1, x_2); 
-    pt[1][2].y = rng.uniform(y_1, y_2);
-
-    const Point* ppt[2] = {pt[0], pt[1]};
-    int npt[] = {3, 3};
-        
-    fillPoly( image, ppt, npt, 2, randomColor(rng), lineType );
-        
-    imshow( window_name, image );
-    if( waitKey(DELAY) >= 0 )
-       { return -1; }
-  }
-  return 0;
-}
-
-/**
- * @function Drawing_Random_Circles
- */
-int Drawing_Random_Circles( Mat image, char* window_name, RNG rng )
-{
-  int lineType = 8;
-
-  for (int i = 0; i < NUMBER; i++)
-  {
-    Point center;
-    center.x = rng.uniform(x_1, x_2);
-    center.y = rng.uniform(y_1, y_2);
-        
-    circle( image, center, rng.uniform(0, 300), randomColor(rng),
-            rng.uniform(-1, 9), lineType );
-        
-    imshow( window_name, image );
-    if( waitKey(DELAY) >= 0 )
-      { return -1; }
-  }
-
-  return 0;
-}
-
-/**
- * @function Displaying_Random_Text
- */
-int Displaying_Random_Text( Mat image, char* window_name, RNG rng )
-{
-  int lineType = 8;
-
-  for ( int i = 1; i < NUMBER; i++ )
-  {
-    Point org;
-    org.x = rng.uniform(x_1, x_2);
-    org.y = rng.uniform(y_1, y_2);
-
-    putText( image, "Testing text rendering", org, rng.uniform(0,8),
-             rng.uniform(0,100)*0.05+0.1, randomColor(rng), rng.uniform(1, 10), lineType);
-        
-    imshow( window_name, image );
-    if( waitKey(DELAY) >= 0 )
-      { return -1; }
-  }
-
-  return 0;
-}
-
-/**
- * @function Displaying_Big_End
- */
-int Displaying_Big_End( Mat image, char* window_name, RNG rng )
-{
-  Size textsize = getTextSize("OpenCV forever!", CV_FONT_HERSHEY_COMPLEX, 3, 5, 0);
-  Point org((window_width - textsize.width)/2, (window_height - textsize.height)/2);
-  int lineType = 8;
-    
-  Mat image2;
-
-  for( int i = 0; i < 255; i += 2 )
-  {
-    image2 = image - Scalar::all(i);
-    putText( image2, "OpenCV forever!", org, CV_FONT_HERSHEY_COMPLEX, 3,
-             Scalar(i, i, 255), 5, lineType );
-        
-    imshow( window_name, image2 );
-    if( waitKey(DELAY) >= 0 )
-       { return -1; }
-  }
-
-  return 0;
-}