Avvio dello sviluppo della visione artificiale con OpenCV su Ubuntu

Qui tratterò come installare OpenCV sul tuo sistema Ubuntu, i modi in cui puoi creare programmi C++ basati su questa libreria Open Source Computer Vision, leggere da file o fotocamera, eseguire operazioni di elaborazione delle immagini di base, disegnare o scrivere alcune cose e salvare il nostro lavoro.

Sommario

• Intro
  • Informazioni su OpenCV
  • Requisiti
• Installazione
  • Prepara il tuo sistema
  • Ottieni OpenCV
  • Costruisci
  • Configura
• Sviluppo con OpenCV
  • Applicazione 1 - Finestra semplice
  • Costruzione terminale
    • g++
    • fare
    • Crea
  • Creazione di KDevelop
  • Applicazione 2 - Carica img
  • Applicazione 3 - Carica video
  • Applicazione 4 - Disegna ed elabora

Introduzione

Questo è un argomento di programmazione e alcune precedenti conoscenze di programmazione in qualsiasi linguaggio aiuteranno, tuttavia presenterò tutti gli strumenti e i comandi necessari per creare piccoli programmi, quindi chiunque abbia una buona capacità di ragionamento logico potrebbe essere in grado di costruire gli esempi e trarne vantaggio .

Inoltre, è un materiale introduttivo e non coprirà programmazione complessa o concetti scientifici, mi concentrerò invece su come far funzionare le cose, darti un codice di esempio per provarlo tu stesso, abituarti e divertirti.

Ti invitiamo ad aprire il manuale di riferimento dell'API in un'altra scheda e a fare riferimento ad esso ogni volta che trovi un nuovo oggetto, funzione o parametro nel codice qui fornito, una volta creato per la prima volta, apporta alcune modifiche da solo per una migliore comprensione.

Inoltre, è una buona idea usare man e guardare la documentazione ufficiale di ciascuno degli strumenti di compilazione, dei file e dei termini qui presentati.

Cos'è OpenCV

OpenCV è l'acronimo di Open Source Computer Vision Library e il suo scopo principale è creare un approccio standardizzato alla questione della visione artificiale. Fornisce una serie di moduli che ti aiutano su cose come algebra lineare, elaborazione delle immagini, apprendimento automatico, astrazione hardware, GUI di alto livello, nonché interfaccia per OpenGL, OpenCL, CUDA e così via. Tieni anche presente che è distribuito sotto licenza BSD, che è abbastanza permissiva e buona sia per scopi di ricerca che commerciali.

I moduli che useremo nei nostri programmi sono.

• Nucleo - le basi di OpenCV
• HighGUI - Fornisce un'interfaccia utente grafica di alto livello abbastanza semplice e utile
• improc - Fornisce capacità di elaborazione delle immagini

Requisiti

Questi sono i requisiti mostrati nei documenti di OpenCV, alcuni sono facoltativi, ma è sempre una buona idea soddisfare tutti i requisiti quando si impara qualcosa.

• GCC 4.4.xo successivo
• CMake 2.6 o versioni successive
• Git
• GTK+2.xo versioni successive, incluse le intestazioni (libgtk2.0-dev)
• pkg-config
• Python 2.6 o successivo e Numpy 1.5 o successivo con pacchetti per sviluppatori (python-dev, python-numpy)
• Pacchetti di sviluppo ffmpeg o libav:libavcodec-dev, libavformat-dev, libswscale-dev
• [opzionale] libtbb2 libtbb-dev, libdc1394 2.x, libjpeg-dev, libpng-dev, libtiff-dev, libjasper-dev, libdc1394-22-dev

Come installare

In questa prima parte dell'articolo ti mostrerò come preparare il tuo sistema, ottenere, costruire e installare OpenCV e alcune configurazioni post-installazione

Prepara

Per prima cosa aggiorna il tuo database apt

apt-get update

Installa le cose dalla sezione dei requisiti 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

Ottieni OpenCV

Useremo OpenCV 2.4.11, apriremo una sessione di terminale e useremo wget come segue:

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

Puoi anche clonare l'ultima versione in un secondo momento e dai un'occhiata qui, è un tutorial sulla migrazione in cui puoi imparare come effettuare la transizione tra le versioni di OpenCV.

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

Costruisci le fonti

Immettere la directory nel pacchetto

cd *2.4.11*

Crea una directory per il nostro build di OpenCV, ed entraci

mkdir build && cd build

All'interno della directory build, usa cmake per prepararlo.

cmake ..

Ora che abbiamo un Makefile, possiamo creare e installa

make && make install

Come configurare

Verifica se il tuo sistema riesce a trovare i percorsi OpenCV, esegui il seguente comando:

 pkg-config --cflags --libs opencv

Se ti dà un messaggio di errore, la tua variabile di ambiente PKG_CONFIG_PATH potrebbe non puntare a OpenCV e devi aggiungere il percorso su di essa. Prova a eseguire questo e il test ancora una volta

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

Puoi aggiungere l'ultimo comando su uno script di profilo per evitare la necessità di eseguirlo ogni volta, prova .bashrc:

vi ~/.bashrc

Sviluppo con OpenCV

Ora siamo pronti per iniziare un po' di codice OpenCV, ecco alcuni programmi di esempio e un approccio dal basso sui modi per costruirli.

Prima applicazione - Finestra semplice

Questa prima applicazione apre semplicemente una finestra sullo schermo, non è molto utile, ma buona per testare la tua installazione e imparare a costruire applicazioni OpenCV

main.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 ){

//crea una finestra chiamata theWindow

namedWindow("theWindow", CV_WINDOW_AUTOSIZE);

//aspetta che l'utente prema qualche tasto

waitKey(0);

//distrugge la finestra denominata Finestra

destroyWindow("theWindow");

restituisce 0;

}

Costruzione terminale

Crea una directory per il progetto

mkdir firstcv && cd firstcv

Crea il c++ file con Vi

vi main.cpp

ora compilalo direttamente con g++

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

Crea

L'applicazione firstcv è abbastanza semplice ed è facile costruirla direttamente, tuttavia quando il codice diventa complesso, i tuoi comandi di build diventano presto criptici, anche la pulizia e la manutenzione generale diventano un pasticcio. Per questo utilizziamo make

Crea un file chiamato Creafile con il seguente contenuto:

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

clean:
rm firstcv

Fondamentalmente chiamerà il compilatore con un set di parametri preparato quando tutti è la destinazione e rimuovi l'eseguibile quando la destinazione è pulita , per maggiori dettagli su Makefile, guarda qui

Un altro fatto su make è che se non viene fornito alcun ID target, utilizzerà il primo target, quindi per creare il codice è sufficiente make:

make

CMake

L'ultimo approccio alla creazione di applicazioni, ma anche la creazione di Makefile può diventare complessa quando si creano su più sistemi. Puoi quindi generare la tua build con CMake, come fa il progetto OpenCV stesso, semplifica la gestione della build e aumenta la compatibilità tra le piattaforme.

Invece di lavorare sul Makefile, creiamo ora un file chiamato CMakeLists.txt con contenuti simili a questo:

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 versione minima di CMake è 2.6

progetto :nome del tuo progetto

include_directory :Aggiuntivo include il percorso

trova_pacchetto :cerca il pacchetto OpenCV, come abbiamo fatto con pkg-config prima

aggiungi_eseguibile :i binari risultanti e i relativi file sorgente.

installa :Percorso di installazione

target_link_librerie :Oggetti condivisi da collegare, ancora una volta funziona come pkg-config

Quindi crea una directory di build ed entra su di essa.

mkdir build && cd build

Prepara la tua build con cmake

cmake ..

Con un Makefile in mano, fallo:

make

Basta eseguire il programma

./firstcv

Creazione di KDevelop

Nonostante tu possa costruire interi sistemi dal terminale della console, puoi fare molto di più usando funzionalità come la formattazione del codice, il riferimento al codice di evidenziazione della sintassi, il debugger e altri usando un IDE. KDevelop è fantastico, semplice e ti mostrerò come creare i tuoi progetti in base al suo modello di applicazione terminale Cmake.

Fare clic sul menu Progetto ->Nuovo da modello , quindi seleziona Standard in Categoria,Terminale al progetto digita e nominalo.

Una volta creato il progetto, cambia il contenuto del file main.cpp con quello fornito in precedenza

Nel pannello dei progetti, fai doppio clic sul nome del progetto, quindi sul file CMakeLists.txt e modificalo in base alla sezione CMake.

Crea il tuo progetto, fai clic su costruisci o premi [F8] chiave ed eseguilo con [F9] , alla prima esecuzione dovrai impostare i parametri di esecuzione come segue

Ora sei in grado di costruire il codice OpenCV, per le prossime applicazioni devi solo ripetere la creazione del progetto o sostituire il sorgente del file main.cpp.

Applicazione 2 - Mostra immagine

Questa applicazione mostra semplicemente il contenuto di un file immagine nella finestra

#include "opencv2/highgui/highgui.hpp"

using namespace cv;
using namespace std;

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

//crea un oggetto Mat e carica il contenuto del file linoxide.png su di esso

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

//se l'immagine è vuota, muore con stato di uscita di errore

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

namedWindow("theWindow", CV_WINDOW_AUTOSIZE);

//mostra l'immagine sulla finestra

imshow("la Finestra", img);

waitKey(0);

destroyWindow("theWindow");

restituisce 0;

}

Ecco il programma in esecuzione:

Applicazione 3 - Carica video

Questa volta leggeremo il contenuto direttamente dalla nostra fotocamera, sono solo alcune modifiche all'ultimo codice

#include "opencv2/opencv.hpp"

using namespace cv;
using namespace std;

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

//Avvia fotocamera

VideoCapture cap(0); Immagine mat;

namedWindow("theWindow", CV_WINDOW_AUTOSIZE);

while(vero){

//se non riesci a leggere dalla fotocamera, il programma muore

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

imshow("la Finestra", img );

if (waitKey(20) ==27) {return 0;}

}

}

Applicazione 4 - Elaborazione delle immagini

Ora che puoi caricare le tue immagini e avere un flusso di programma di base, miglioriamo questo, creiamo alcuni controlli, disegniamo qualcosa che assomigli al logo di Linoxide, eseguiamo alcune trasformazioni sulle immagini e salviamole.

//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) {

//Avvia dispositivo di acquisizione video su cap VideoCapture cap(0);

//Se non è possibile aprire il dispositivo di acquisizione, il programma die if(!cap.isOpened()){return -1;}

//Ecco la nostra cornice Mat frame;

//Mostreremo i nostri frame qui denominatiWindow("display", CV_WINDOW_AUTOSIZE);

//Questa finestra contiene le trackbar per modificare il comportamento del programma namedWindow("config", CV_WINDOW_AUTOSIZE);

//per impostazione predefinita non invertiremo il frame bool invertimg =false;

//disegneremo lo sketch del logo Linoxide bool draw =true;

// crea un supporto per la nostra modalità flip frame int flipmode =0; // crea una trackbar per cambiare la modalità capovolgi cvCreateTrackbar("Modalità capovolgi:", "config", &flipmode, 3);

//titolari dei valori di larghezza e altezza per il ridimensionamento dell'immagine int screen_width =640; int screen_height =480;

//crea le trackbar la finestra di configurazione per modificare le proprietà della dimensione cvCreateTrackbar("Width:", "config", &screen_width, 1024); cvCreateTrackbar("Height:", "config", &screen_height, 768);

//crea un vettore di parametri di compressione che verrà utilizzato per acquisire un'istantanea vector compression_pars; compression_pars.push_back(CV_IMWRITE_PNG_COMPRESSION); compression_pars.push_back(9);

while(vero){

if(!cap.read(frame)){return -1;} // impossibile leggere il frame, il programma muore

//se invertimg è vero, inverti ciascuno degli elementi della matrice riducendo il suo valore dal massimo possibile if(invertimg ==true){ frame =Scalar::all(255) - frame; }

//capovolgi il fotogramma in base ai valori della trackbar della modalità capovolgi if(flipmode> 0){flip(frame,frame,1);} //flip(frame,frame,1);} //flip orizzontalmente if(flipmode> 1){flip(frame,frame,0);} //capovolgi verticalmente, ora è capovolto in entrambe le direzioni if(flipmode> 2){flip(frame,frame,1);} //flip orizzontalmente, ora capovolto solo verticalmente

//ridimensiona il fotogramma in base ai valori delle trackbar resize(frame,frame, Size(screen_width,screen_height));

if (disegna ==vero){

//disegna un rettangolo bianco da utilizzare come sfondo, il colore è Scalar(B,G,R) rettangolo(frame, Point(5,25), Point(140,70), Scalar(255,255,255), -1, 8, 0);

//rettangolo giallo scuro, nota che il valore alfa può essere utilizzato rettangolo(frame, Point(5,25), Point(54,55), Scalar(00,225,255,0), -1, 8, 0);

//rettangolo blu brillante, lo spessore è negativo, quindi sarà completamente riempito rettangolo(frame, Point(57,25), Point(140,55), Scalar(255,225,100), -1, 8, 0);

//rettangolo nero, inizia al punto x5,y57, termina a x140,y70 rettangolo(frame, Point(5,57), Point(140,70), Scalar(0,0,0), -1, 8, 0 );

//scrive il testo sulla cornice, separato dalle caratteristiche del font e dalla posizione 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(frame, " O ", Point(10,50), FONT_HERSHEY_SIMPLEX, 1, Scalar(255,255,255),2,0); putText(frame, " XIDE", Point(14,50), FONT_HERSHEY_SIMPLEX, 0.8, Scalar(255,255,255),2,0); putText(frame, "Linux Freedom Thoughts", Point(10,65), FONT_HERSHEY_PLAIN, 0.6, Scalar(255,255,255),0,0);

} //mostra il nostro frame sulla finestra di visualizzazione imshow("display",frame);

switch(waitKey(10)){ case 27://[esc], termina il programma con successo restituisce 0; case 'i'://invert image toggle if (invertimg ==false){invertimg =true;}else {invertimg =false;} case 'd'://draw Linoxide toggle if (draw ==false){draw =true;}else {draw =false;} case 's'://scatta un'istantanea, salva in snapshot.png imwrite("snapshot.png", frame, compression_pars);

}

} //finisci con successo restituisce 0;

}

Eccolo

Conclusione

Per ora è tutto, dovresti essere in grado di creare programmi basati sulla libreria OpenCV. I concetti qui introdotti dovrebbero darti una comprensione delle idee alla base della libreria. Ma questo è solo l'inizio, puoi approfondire i tutorial ufficiali, approfondire i riferimenti e provare OpenCV e dare un'occhiata a cose più avanzate, come il rilevamento di oggetti, il rilevamento di volti, il tracciamento di oggetti, la corrispondenza dei modelli, l'apprendimento automatico, la mappatura 3D.

Grazie per la lettura, spero che ti piaccia e che faccia grandi cose con OpenCV!