OpenCV tutorial Chapter 1, sections 1.2, 1.8, 1.9 reading notes

Now I am skimming Chapter 1, sections 1.2, 1.8, and 1.9.  I skipped the sections in between, for Eclipse, Windows, Visual Studio, and Android.



1.2 Using OpenCV with gcc and CMake

...

• The easiest way of using OpenCV in your code is to use CMake. A few advantages (taken from the Wiki):

1. No need to change anything when porting between Linux and Windows

2. Can easily be combined with other tools by CMake( i.e. Qt, ITK and VTK )

• If you are not familiar with CMake, checkout the tutorial on its website.

Steps

Create a program using OpenCV

Let’s use a simple program such as DisplayImage.cpp shown below.

#include <cv.h>
#include <highgui.h>
using namespace cv;

int main( int argc, char** argv )
  {
  Mat image;
  image = imread( argv[1], 1 );
  if( argc != 2 || !image.data )
    {
    printf( "No image data \n" );
    return -1;
    }

    namedWindow( "Display Image", CV_WINDOW_AUTOSIZE );
    imshow( "Display Image", image );
    waitKey(0);
    return 0;
  }

Create a CMake file

Now you have to create your CMakeLists.txt file. It should look like this:

project( DisplayImage )
find_package( OpenCV REQUIRED )
add_executable( DisplayImage DisplayImage )
target_link_libraries( DisplayImage ${OpenCV_LIBS} )

Generate the executable

This part is easy, just proceed as with any other project using CMake:

cd <DisplayImage_directory>

cmake .

make

Result

By now you should have an executable (called DisplayImage in this case). You just have to run it giving an image
location as an argument, i.e.:

./DisplayImage lena.jpg

You should get a nice window as the one shown below:

1.8 Load and Display an Image

Goal

In this tutorial you will learn how to:

• Load an image (using imread)

• Create a named OpenCV window (using namedWindow)

• Display an image in an OpenCV window (using imshow)

Source Code

Download the source code from here.

1 #include <opencv2/core/core.hpp>
2 #include <opencv2/highgui/highgui.hpp>
3 #include <iostream>
4
5 using namespace cv;
6 using namespace std;
7
8 int main( int argc, char** argv )
9 {
10 if( argc != 2)
11 {
12 cout <<" Usage: display_image ImageToLoadAndDisplay" << endl;
13 return -1;
14 }
15
16 Mat image;
17 image = imread(argv[1], CV_LOAD_IMAGE_COLOR); // Read the file
18
19 if(! image.data ) // Check for invalid input
20 {
21 cout << "Could not open or find the image" << std::endl ;
22 return -1;
23 }
24
25 namedWindow( "Display window", CV_WINDOW_AUTOSIZE );// Create a window for display.
26 imshow( "Display window", image ); // Show our image inside it.
27
28 waitKey(0); // Wait for a keystroke in the window
29 return 0;
30 }

Explanation

In OpenCV 2 we have multiple modules. Each one takes care of a different area or approach towards image processing.

You could already observe this in the structure of the user guide of these tutorials itself. Before you use any of them

you first need to include the header files where the content of each individual module is declared.

You’ll almost always end up using the:

• core section, as here are defined the basic building blocks of the library

• highgui module, as this contains the functions for input and output operations

// Video Image PSNR and SSIM

#include <iostream> // for standard I/O
#include <string> // for strings

We also include the iostream to facilitate console line output and input. To avoid data structure and function name conflicts with other libraries, OpenCV has its own namespace: cv. To avoid the need appending prior each of these the cv:: keyword you can import the namespace in the whole file by using the lines:

using namespace cv;

using namespace std;

This is true for the STL library too (used for console I/O). Now, let’s analyze the main function. We start up assuring that we acquire a valid image name argument from the command line.

if( argc != 2)
{
cout <<" Usage: display_image ImageToLoadAndDisplay" << endl;
return -1;
}

Then create a Mat object that will store the data of the loaded image.

Mat image;

Now we call the imread function which loads the image name specified by the first argument (argv[1]). The second argument specifies the format in what we want the image. This may be:

• CV_LOAD_IMAGE_UNCHANGED (<0) loads the image as is (including the alpha channel if present)

• CV_LOAD_IMAGE_GRAYSCALE ( 0) loads the image as an intensity one

• CV_LOAD_IMAGE_COLOR (>0) loads the image in the RGB format

image = imread(argv[1], CV_LOAD_IMAGE_COLOR); // Read the file

Note: OpenCV offers support for the image formats Windows bitmap (bmp), portable image formats (pbm, pgm,/ppm) and Sun raster (sr, ras). With help of plugins (you need to specify to use them if you build yourself the library,

nevertheless in the packages we ship present by default) you may also load image formats like JPEG (jpeg, jpg, jpe),JPEG 2000 (jp2 - codenamed in the CMake as Jasper), TIFF files (tiff, tif) and portable network graphics (png).

Furthermore, OpenEXR is also a possibility.

After checking that the image data was loaded correctly, we want to display our image, so we create an OpenCV window using the namedWindow function. These are automatically managed by OpenCV once you create them. For this you need to specify its name and how it should handle the change of the image it contains from a size point of view. It may be:

• CV_WINDOW_AUTOSIZE is the only supported one if you do not use the Qt backend. In this case the window size will take up the size of the image it shows. No resize permitted!

• CV_WINDOW_NORMAL on Qt you may use this to allow window resize. The image will resize itself according to the current window size. By using the | operator you also need to specify if you would like the image to keep its aspect ratio (CV_WINDOW_KEEPRATIO) or not (CV_WINDOW_FREERATIO).

namedWindow( "Display window", CV_WINDOW_AUTOSIZE );// Create a window for display.

Finally, to update the content of the OpenCV window with a new image use the imshow function. Specify the OpenCV window name to update and the image to use during this operation:

imshow( "Display window", image ); // Show our image inside it.

Because we want our window to be displayed until the user presses a key (otherwise the program would end far too quickly), we use the waitKey function whose only parameter is just how long should it wait for a user input (measured in milliseconds). Zero means to wait forever.

waitKey(0); // Wait for a keystroke in the window

Result

• Compile your code and then run the executable giving an image path as argument. 

If you’re on Windows the executable will of course contain an exe extension too. Of course assure the image file is near your program file.

./DisplayImage HappyFish.jpg

• You should get a nice window as the one shown below:

1.9 Load, Modify, and Save an Image

Note: We assume that by now you know how to load an image using imread and to display it in a window (using imshow). Read the Load and Display an Image tutorial otherwise.

Goals

In this tutorial you will learn how to:

• Load an image using imread

• Transform an image from RGB to Grayscale format by using cvtColor

• Save your transformed image in a file on disk (using imwrite)

Code

Here it is:

1 #include <cv.h>
2 #include <highgui.h>
3
4 using namespace cv;
5
6 int main( int argc, char** argv )
7 {
8 char* imageName = argv[1];
9
62 Chapter 1. Introduction to OpenCV
The OpenCV Tutorials, Release 2.3
10 Mat image;
11 image = imread( imageName, 1 );
12
13 if( argc != 2 || !image.data )
14 {
15 printf( " No image data \n " );
16 return -1;
17 }
18
19 Mat gray_image;
20 cvtColor( image, gray_image, CV_RGB2GRAY );
21
22 imwrite( "../../images/Gray_Image.jpg", gray_image );
23
24 namedWindow( imageName, CV_WINDOW_AUTOSIZE );
25 namedWindow( "Gray image", CV_WINDOW_AUTOSIZE );
26
27 imshow( imageName, image );
28 imshow( "Gray image", gray_image );
29
30 waitKey(0);
31
32 return 0;
33 }

Explanation

1. We begin by:

• Creating a Mat object to store the image information

• Load an image using imread, located in the path given by imageName. Fort this example, assume you are loading a RGB image.

2. Now we are going to convert our image from RGB to Grayscale format. OpenCV has a really nice function to do this kind of transformations:

cvtColor( image, gray_image, CV_RGB2GRAY );

As you can see, cvtColor takes as arguments:

• a source image (image)

• a destination image (gray_image), in which we will save the converted image.

• an additional parameter that indicates what kind of transformation will be performed. In this case we use CV_RGB2GRAY (self-explanatory).

3. 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: imwrite imwrite( "../../images/Gray_Image.jpg", gray_image ); Which will save our gray_image as Gray_Image.jpg in the folder images located two levels up of my current location.

4. 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:

namedWindow( imageName, CV_WINDOW_AUTOSIZE );
namedWindow( "Gray image", CV_WINDOW_AUTOSIZE );
imshow( imageName, image );
imshow( "Gray image", gray_image );

5. Add add the waitKey(0) function call for the program to wait forever for an user key press.

Result

When you run your program you should get something like this:

And if you check in your folder (in my case images), you should have a newly .jpg file named Gray_Image.jpg:

Congratulations, you are done with this tutorial!

.END