Comenzando el desarrollo de Computer Vision con OpenCV en Ubuntu

Aquí cubriré cómo puede instalar OpenCV en su sistema Ubuntu, formas en que puede crear programas C ++ basados ​​​​en esta Biblioteca de visión artificial de código abierto, leer desde archivos o cámara, realizar operaciones básicas de procesamiento de imágenes, dibujar o escribir algunas cosas y guardar nuestro trabajo.

Índice

• Introducción
  • Acerca de OpenCV
  • Requisitos
• Instalando
  • Prepare su sistema
  • Obtener OpenCV
  • Construir
  • Configurar
• Desarrollo con OpenCV
  • Aplicación 1 - Ventana simple
  • Construcción de terminales
    • g++
    • hacer
    • CMake
  • Compilación de KDevelop
  • Aplicación 2 - Cargar img
  • Aplicación 3 - Cargar video
  • Aplicación 4 - Dibujar y procesar

Introducción

Este es un tema de programación, y algunos conocimientos previos de programación en cualquier idioma ayudarán, sin embargo, presentaré todas las herramientas y los comandos necesarios para crear programas pequeños, de modo que cualquier persona con una buena habilidad de razonamiento lógico pueda crear los ejemplos y beneficiarse de ellos. .

Además, es un material de introducción y no cubrirá programación compleja o conceptos científicos, me centraré en cómo hacer que las cosas funcionen, le daré un código de muestra para que lo pruebe usted mismo, se acostumbre y se divierta.

Le animamos a abrir el manual de referencia de la API en otra pestaña y consultarlo cada vez que encuentre un nuevo objeto, función o parámetro en el código proporcionado aquí, una vez que lo haya creado por primera vez, haga algunos cambios por su cuenta para una mejor comprensión.

Además, es una buena idea usar man y consultar la documentación oficial de cada una de las herramientas de compilación, archivos y términos aquí presentados.

Qué es OpenCV

OpenCV significa Biblioteca de visión artificial de código abierto, y su objetivo principal es crear un enfoque estandarizado para el asunto de la visión artificial. Proporciona un conjunto de módulos que lo ayudan en cosas como álgebra lineal, procesamiento de imágenes, aprendizaje automático, abstracción de hardware, GUI de alto nivel, así como interfaz para OpenGL, OpenCL, CUDA, etc. Tenga también en cuenta que se distribuye bajo la licencia BSD, que es bastante permisiva y buena tanto para fines comerciales como de investigación.

Los módulos que vamos a utilizar en nuestros programas son.

• Básico - la base de OpenCV
• HighGUI - Proporciona una interfaz gráfica de usuario de alto nivel bastante simple y útil
• improc - Proporciona capacidades de procesamiento de imágenes

Requisitos

Estos son los requisitos que se muestran en los documentos de OpenCV, algunos de ellos son opcionales, pero siempre es una buena idea cumplir con todos los requisitos al aprender algo.

• GCC 4.4.x o posterior
• CMake 2.6 o superior
• Git
• GTK+2.x o superior, incluidos los encabezados (libgtk2.0-dev)
• pkg-config
• Python 2.6 o posterior y Numpy 1.5 o posterior con paquetes de desarrollador (python-dev, python-numpy)
• paquetes de desarrollo ffmpeg o libav:libavcodec-dev, libavformat-dev, libswscale-dev
• [opcional] libtbb2 libtbb-dev, libdc1394 2.x, libjpeg-dev, libpng-dev, libtiff-dev, libjasper-dev, libdc1394-22-dev

Cómo instalar

En esta primera parte del artículo, le mostraré cómo preparar su sistema, obtener, compilar e instalar OpenCV y algunas configuraciones posteriores a la instalación

Preparar

Primero actualice su base de datos apt

apt-get update

Instale las cosas de la sección de requisitos con apt-get.

apt-get install build-essential cmake git libgtk2.0-dev pkg-config libavcodec-dev libavformat-dev libswscale-dev python-dev python-numpy libtbb2 libtbb-dev libjpeg-dev libpng-dev libtiff-dev libjasper-dev libdc1394-22-dev

Obtener OpenCV

Vamos a usar OpenCV 2.4.11, abrir una sesión de terminal y usar wget de la siguiente manera:

wget https://github.com/Itseez/opencv/archive/2.4.11.zip

También puede clonar la última versión más tarde y echar un vistazo aquí, es un tutorial de migración donde puede aprender cómo hacer la transición entre las versiones de OpenCV.

git clone https://github.com/Itseez/opencv.git

Construir las fuentes

Introduzca el directorio del paquete

cd *2.4.11*

Cree un directorio para nuestra construcción de OpenCV y entra en él

mkdir build && cd build

Dentro del directorio de compilación, use cmake para prepararlo.

cmake ..

Ahora que tenemos un Makefile, podemos hacer e instalar

make && make install

Cómo configurar

Pruebe si su sistema puede encontrar las rutas de OpenCV, ejecute el siguiente comando:

 pkg-config --cflags --libs opencv

Si le da un mensaje de error, es posible que su variable de entorno PKG_CONFIG_PATH no esté apuntando a OpenCV y debe agregarle la ruta. Intenta ejecutar esto y la prueba una vez más

export PKG_CONFIG_PATH="$PKG_CONFIG_PATH:/usr/local/lib/pkgconfig"

Puede agregar el último comando en una secuencia de comandos de perfil para evitar la necesidad de ejecutarlo cada vez, intente .bashrc:

vi ~/.bashrc

Desarrollo con OpenCV

Ahora estamos listos para comenzar con un poco de código OpenCV, aquí hay algunos programas de muestra y un enfoque básico sobre las formas de construirlos.

Primera aplicación - Ventana simple

Esta primera aplicación simplemente abre una ventana en la pantalla, no es muy útil, pero es buena para probar su instalación y aprender a crear aplicaciones OpenCV

principal.cpp

//include high gui headers

#include "opencv2/highgui/highgui.hpp"

//we are using standard and OpenCV namespaces

using namespace cv;
using namespace std;

int main( int argc, const char** argv ){

//crear una ventana llamada laVentana

namedWindow("laVentana", CV_WINDOW_AUTOSIZE);

//espera que el usuario presione alguna tecla

teclaespera(0);

//destruye la ventana llamada laVentana

destruirVentana("laVentana");

devuelve 0;

Construcción de terminales

Crear un directorio para el proyecto

mkdir firstcv && cd firstcv

Crea el c++ archivo con Vi

vi main.cpp

ahora constrúyalo directamente con g++

g++ -o firstcv $(pkg-config --libs --cflags opencv) main.cpp

Hacer

La aplicación firstcv es bastante simple y es fácil construirla directamente, sin embargo, a medida que el código se vuelve complejo, sus comandos de construcción se vuelven crípticos pronto, también la limpieza y el mantenimiento general se vuelven un desastre. Por esta razón usamos make

Cree un archivo llamado Makefile con el siguiente contenido:

all:
g++ -o firstcv \
-I/usr/local/include/opencv  \
-L/usr/local/lib \
-lopencv_highgui \
-lopencv_core \
-lm \
main.cpp

clean:
rm firstcv

Básicamente, llamará al compilador con un conjunto preparado de parámetros cuando todos es el objetivo y elimina el ejecutable cuando el objetivo está limpio , para obtener más detalles sobre Makefile, consulte aquí

Otro hecho sobre make es que si no se proporciona una identificación de objetivo, usará el primer objetivo, por lo que para compilar el código solo necesita make:

make

CMake

El último enfoque para construir aplicaciones, pero la creación de Makefiles también puede volverse compleja cuando se construye a través de sistemas. Luego puede generar su compilación con CMake, como lo hace el proyecto OpenCV, simplifica la administración de la compilación y aumenta la compatibilidad entre plataformas.

En lugar de trabajar en el Makefile, ahora creamos un archivo llamado CMakeLists.txt con contenido similar a este:

cmake_minimum_required(VERSION 2.6)
project(firstcv)
include_directories("/usr/local/include")
find_package( OpenCV REQUIRED )
add_executable(firstcv main.cpp)
install(TARGETS firstcv RUNTIME DESTINATION bin)
target_link_libraries( firstcv ${OpenCV_LIBS} )

Dice:

cmake_minimum_required :la versión mínima de CMake es 2.6

proyecto :nombre de tu proyecto

incluir_directorios :Adicional incluye ruta

buscar_paquete :busca el paquete OpenCV, como hemos hecho con pkg-config antes

añadir_ejecutable :los binarios resultantes y sus archivos fuente.

instalar :Ruta de instalación

bibliotecas_enlace_objetivo :Objetos compartidos para vincular, una vez más funciona como pkg-config

Luego cree un directorio de compilación e ingrese en él.

mkdir build && cd build

Prepara tu compilación con cmake

cmake ..

Con un Makefile en la mano, hazlo:

make

Solo ejecuta tu programa

./firstcv

Compilación de KDevelop

A pesar de que puede construir sistemas completos desde la terminal de la consola, puede hacer mucho más usando características como formato de código, referencia de código de resaltado de sintaxis, depurador y otros usando un IDE. KDevelop es excelente, simple y le mostraré cómo crear sus proyectos basados ​​en su plantilla de aplicación de terminal Cmake.

Haga clic en el menú Proyecto ->Nuevo de plantilla , luego seleccione Estándar en Categoría, Terminal en el tipo de proyecto y asígnele un nombre.

Una vez creado el proyecto, cambie el contenido del archivo main.cpp por el proporcionado anteriormente

En el panel de proyectos, haga doble clic en el nombre del proyecto, luego en el archivo CMakeLists.txt y cámbielo según la sección CMake.

Cree su proyecto, haga clic en compilar o pulse [F8] y ejecútelo con [F9] , en la primera ejecución deberá configurar los parámetros de ejecución de la siguiente manera

Ahora puede crear código OpenCV, para las próximas aplicaciones solo necesita repetir la creación del proyecto o reemplazar la fuente del archivo main.cpp.

Aplicación 2 - Mostrar imagen

Esta aplicación simplemente muestra el contenido de un archivo de imagen en la ventana

#include "opencv2/highgui/highgui.hpp"

using namespace cv;
using namespace std;

int main( int argc, const char** argv ){

//crea un objeto Mat y carga el contenido del archivo linoxide.png en él

Mat img =imread("linoxide.png", CV_LOAD_IMAGE_UNCHANGED);

//si el img está vacío, muere con estado de salida de error

si (img.empty()){return -1;}

namedWindow("laVentana", CV_WINDOW_AUTOSIZE);

//muestra el img en laVentana

imshow("laVentana", img);

teclaespera(0);

destruirVentana("laVentana");

devuelve 0;

Aquí está el programa ejecutándose:

Aplicación 3 - Cargar video

Esta vez vamos a leer el contenido directamente desde nuestra cámara, son solo algunos cambios en el último código

#include "opencv2/opencv.hpp"

using namespace cv;
using namespace std;

int main( int argc, const char** argv ){

//Iniciar cámara

Límite de captura de video (0); Mat img;

namedWindow("laVentana", CV_WINDOW_AUTOSIZE);

mientras (verdadero){

//si no se puede leer desde la cámara, el programa muere

if (!cap.read(img)) { return -1;

imshow("laVentana", img );

si (llaveespera(20) ==27) {devuelve 0;}

Aplicación 4 - Procesamiento de imágenes

Ahora que puede cargar sus imágenes y tener un flujo de programa básico, mejoremos esto, creemos algunos controles, dibujemos algo parecido al logo de Linoxide, hagamos algunas transformaciones en las imágenes y guardémoslas.

//we include High level GUI and Media I/O
#include "opencv2/highgui/highgui.hpp"

//Including Image processing capabilities
#include "opencv2/imgproc/imgproc.hpp"

//OpenCV core module is implicitly included

//we are using both standard and OpenCV namespaces
using namespace std;
using namespace cv;

int main(int argc, char **argv) {

//Inicie el dispositivo de captura de video en la tapa VideoCapture cap(0);

//Si no se pudo abrir el dispositivo de captura, el programa muere if(!cap.isOpened()){return -1;}

//Aquí está nuestro marco Mat frame;

//Mostraremos nuestros marcos aquí namedWindow("display", CV_WINDOW_AUTOSIZE);

//Esta ventana contiene barras de seguimiento para cambiar el comportamiento del programa namedWindow("config", CV_WINDOW_AUTOSIZE);

//por defecto no invertiremos el cuadro bool invertimg =false;

//dibujaremos el logo de Linoxide sketch bool draw =true;

// crea un soporte para nuestro modo de cambio de cuadro int flipmode =0; // crea una barra de seguimiento para cambiar el modo flip cvCreateTrackbar("Modo Flip:", "config", &flipmode, 3);

//contenedores de valores de ancho y alto para cambiar el tamaño de la imagen int screen_width =640; int screen_height =480;

//crear trackbars en la ventana de configuración para cambiar las propiedades de tamaño cvCreateTrackbar("Ancho:", "config", &screen_width, 1024); cvCreateTrackbar("Altura:", "config", &screen_height, 768);

//crear un vector de parámetros de compresión que se usará para tomar una instantánea vector compresion_pars; compresión_pars.push_back(CV_IMWRITE_PNG_COMPRESSION); compresión_pars.push_back(9);

mientras (verdadero){

if(!cap.read(frame)){return -1;} // no se pudo leer el marco, el programa muere

//si invertimg es verdadero, invierte cada uno de los elementos de la matriz reduciendo su valor del máximo posible if(invertimg ==true){ frame =Scalar::all(255) - frame;

//voltear el cuadro de acuerdo con los valores en la barra de seguimiento del modo de volteo if(flipmode> 0){flip(frame,frame,1);} //voltear horizontalmente if(flipmode> 1){flip(frame,frame,0);} //voltea verticalmente, ahora se voltea en ambas direcciones if(flipmode> 2){flip(frame,frame,1);} //voltea horizontalmente, ahora solo se voltea verticalmente

//cambiar el tamaño del marco de acuerdo con los valores en las barras de seguimiento resize(frame,frame, Size(screen_width,screen_height) );

si (dibujar ==verdadero){

//dibuje un rectángulo blanco para usarlo como fondo, el color es Scalar(B,G,R) rectángulo(marco, Punto(5,25), Punto(140,70), Escalar(255,255,255), -1, 8, 0);

//rectángulo amarillo oscuro, tenga en cuenta que el valor alfa se puede usar rectángulo(marco, Punto(5,25), Punto(54,55), Escalar(00,225,255,0), -1, 8, 0);

//rectángulo azul brillante, el grosor es negativo, por lo que será un rectángulo completamente relleno(marco, Punto(57,25), Punto(140,55), Escalar(255,225,100), -1, 8, 0);

//rectángulo negro, comienza en el punto x5,y57, termina en x140,y70 rectángulo(marco, Punto(5,57), Punto(140,70), Escalar(0,0,0), -1, 8, 0 );

//escribe el texto en el marco, separado por las características de la fuente y la posición putText(frame, "L", Point(10,50), FONT_HERSHEY_SIMPLEX, 1, Scalar(0,0,0),2,0); putText(frame, "IN", Point(14,50), FONT_HERSHEY_SIMPLEX, 0.8, Scalar(0,0,0),2,0); putText(marco, "O", Punto(10,50), FONT_HERSHEY_SIMPLEX, 1, Escalar(255,255,255),2,0); putText(marco, "XIDE", Punto(14,50), FONT_HERSHEY_SIMPLEX, 0.8, Escalar(255,255,255),2,0); putText(frame, "Linux Freedom Thoughts", Point(10,65), FONT_HERSHEY_PLAIN, 0.6, Scalar(255,255,255),0,0);

} //mostrar nuestro marco en la ventana de visualización imshow("display",frame);

switch(waitKey(10)){ case 27://[esc], finaliza el programa con éxito return 0; case 'i'://invert image toggle if (invertimg ==false){invertimg =true;}else {invertimg =false;} case 'd'://dibujar Linoxide toggle if (draw ==false){draw =true;}else {draw =false;} case 's'://tome una instantánea, guárdela en snapshot.png imwrite("snapshot.png", marco, compresión_pars);

} //terminar con exito return 0;

Aquí está

Conclusión

Eso es todo por ahora, debería poder crear programas basados ​​en la biblioteca OpenCV. Los conceptos presentados aquí deberían ayudarlo a comprender las ideas detrás de la biblioteca. Pero eso es solo el comienzo, puede profundizar en los tutoriales oficiales, profundizar en la referencia y la muestra de OpenCV y echar un vistazo a cosas más avanzadas, como detección de objetos, detección de rostros, seguimiento de objetos, coincidencia de plantillas, aprendizaje automático, mapeo 3D.

¡Gracias por leer, espero que les guste y hagan grandes cosas con OpenCV!