This chapter requires familiarity with the basic C++ programming language. All the code used in this chapter can be downloaded from the following GitHub link: https://github.com/PacktPublishing/Learn-OpenCV-4-By-Building-Projects-Second-Edition/tree/master/Chapter_02. The code can be executed on any operating system, though it is only tested on Ubuntu.
Check out the following video to see the Code in Action:
http://bit.ly/2QxhNBa

To configure and check all the requisite dependencies for our project, we are going to use CMake, but it is not the only way that this can be done; we can configure our project in any other tool or IDE, such as Makefiles or Visual Studio, but CMake is a more portable way to configure multiplatform C++ projects.

CMake uses configuration files called CMakeLists.txt, where the compilation and dependencies process is defined. For a basic project based on an executable built from a single source code file, a CMakeLists.txt file comprising three lines is all that is required. The file looks as follows:

cmake_minimum_required (VERSION 3.0) 
project (CMakeTest) 
add_executable(${PROJECT_NAME} main.cpp) 

The first line defines the minimum version of CMake required. This line is mandatory in our CMakeLists.txt file and allows us to use the functionality of...

CMake allows us to create libraries used by the OpenCV build system. Factorizing shared code among multiple applications is a common and useful practice in software development. In big applications, or common code shared in multiple applications, this practice is very useful. In this case, we do not create a binary executable, but instead we create a compiled file that includes all the functions, classes, and so on. We can then share this library file with other applications without sharing our source code.

CMake includes the add_library function to this end:

# Create our hello library 
    add_library(Hello hello.cpp hello.h) 
 
# Create our application that uses our new library 
    add_executable(executable main.cpp) 
 
# Link our executable with the new library 
    target_link_libraries(executable Hello) 

The lines starting with # add comments and are ignored...

CMake has the ability to search our dependencies and external libraries, giving us the ability to build complex projects, depending on the external components in our projects, and add some requirements.

In this book, the most important dependency is, of course, OpenCV, and we will add it to all of our projects:

    cmake_minimum_required (VERSION 3.0) 
    PROJECT(Chapter2) 
# Requires OpenCV 
    FIND_PACKAGE( OpenCV 4.0.0 REQUIRED ) 
# Show a message with the opencv version detected 
    MESSAGE("OpenCV version : ${OpenCV_VERSION}") 
# Add the paths to the include directories/to the header files
    include_directories(${OpenCV_INCLUDE_DIRS}) 
# Add the paths to the compiled libraries/objects
    link_directories(${OpenCV_LIB_DIR}) 
# Create a variable called SRC 
    SET(SRC main.cpp) 
# Create our executable 
    ADD_EXECUTABLE(${PROJECT_NAME...

In this section, we are showing a more complex script that includes subfolders, libraries, and executables; all told, just two files and a few lines, as demonstrated in this script. It's not mandatory to create multiple CMakeLists.txt files, because we can specify everything in the main CMakeLists.txt file. However, it is more common to use different CMakeLists.txt files for each project subfolder, thereby making it more flexible and portable.

This example has a code structure folder, which contains one folder for a utils library and the root folder, which contains the main executable:

CMakeLists.txt 
main.cpp 
utils/ 
   CMakeLists.txt 
   computeTime.cpp 
   computeTime.h 
   logger.cpp 
   logger.h 
   plotting.cpp 
   plotting.h 

Then, we have to define two CMakeLists.txt files, one in the root folder and the other in the utils folder. The...

The most important structure in computer vision is, without doubt, the images. The image in a computer vision is the representation of the physical world captured with a digital device. This picture is only a sequence of numbers stored in a matrix format (refer to the following diagram). Each number is a measurement of the light intensity for the considered wavelength (for example, red, green, or blue in color images) or for a wavelength range (for panchromatic devices). Every point in an image is called a pixel (for a picture element), and each pixel can store one or more values depending on whether it is a black and white image (also referred to as a binary image) that stores only one value, such as 0 or 1, a grayscale-level image that stores two values, or a color image that stores three values. These values are usually between 0 and 255 in an integer number...

Following the introduction to matrices, we are going to start with the OpenCV code basics. The first thing that we have to learn is how to read and write images:

#include <iostream> 
#include <string> 
#include <sstream> 
using namespace std; 
 
// OpenCV includes 
#include "opencv2/core.hpp" 
#include "opencv2/highgui.hpp" 
using namespace cv; 
 
int main(int argc, const char** argv) 
{ 
   // Read images 
   Mat color= imread("../lena.jpg"); 
   Mat gray= imread("../lena.jpg",CV_LOAD_IMAGE_GRAYSCALE); 

  if(! color.data ) // Check for invalid input
 {
 cout << "Could not open or find the image" << std::endl ;
 return -1;
 }
   // Write images 
   imwrite("lenaGray.jpg", gray); 
    
   // Get same pixel with opencv function 
   int myRow=color.cols-1; 
   int myCol=color...

This section introduces you to video and camera reading using this simple example. Before explaining how to read videos or camera input, we want to introduce a new, very useful class that helps us to manage the input command-line parameters. This new class was introduced in OpenCV version 3.0, and is the CommandLineParser class:

// OpenCV command line parser functions 
// Keys accepted by command line parser 
const char* keys = 
{ 
   "{help h usage ? | | print this message}" 
    "{@video | | Video file, if not defined try to use webcamera}" 
}; 

The first thing that we have to do for CommandLineParser is define what parameters we need or allow in a constant char vector; each line has the following pattern:

"{name_param | default_value | description}"

name_param can be preceded with @, which defines this parameter as a...

We have learned about the Mat and Vec3b classes, but there are many more classes that we have to learn.

In this section, we will learn the most basic object types required in the majority of projects:

• Vec
• Scalar
• Point
• Size
• Rect
• RotatedRect

Vec is a template class mainly for numerical vectors. We can define any type of vector and the number of components:

Vec<double,19> myVector; 

We can also use any of the predefined types:

typedef Vec<uchar, 2> Vec2b; 
typedef Vec<uchar, 3> Vec3b; 
typedef Vec<uchar, 4> Vec4b; 
 
typedef Vec<short, 2> Vec2s; 
typedef Vec<short, 3> Vec3s; 
typedef Vec<short, 4> Vec4s; 
 
typedef Vec<int, 2> Vec2i;...

In this section, we will learn a number of basic and important matrix operations that we can apply to images or any matrix data. We learned how to load an image and store it in a Mat variable, but we can create Mat manually. The most common constructor is giving the matrix a size and type, as follows:

Mat a= Mat(Size(5,5), CV_32F); 

The types supported depend on the type of number you want to store and the number of channels. The most common types are as follows:

CV_8UC1 
CV_8UC3 
CV_8UC4 
CV_32FC1 
CV_32FC3 
CV_32FC4

Before finishing this chapter, we will explore the OpenCV functions to store and read our data. In many applications, such as calibration or machine learning, when we finish performing a number of calculations, we need to save these results to retrieve them in subsequent operations. OpenCV provides an XML/YAML persistence layer to this end.

To write a file with some OpenCV or other numeric data, we can use the FileStorage class, using a streaming << operator such as STL streaming:

#include "opencv2/opencv.hpp" 
using namespace cv; 
 
int main(int, char** argv) 
{ 
   // create our writer 
    FileStorage fs("test.yml", FileStorage::WRITE);...

In this chapter, we learned the basics and the most important types and operations of OpenCV, access to images and videos, and how they are stored in matrices. We learned the basic matrix operations and other basic OpenCV classes to store pixels, vectors, and so on. Finally, we learned how to save our data in files to allow them to be read in other applications or other executions.

In the next chapter, we are going to learn how to create our first application, learning the basics of graphical user interfaces that OpenCV provides. We will create buttons and sliders, and introduce some image processing basics.