Starten der Computer Vision-Entwicklung mit OpenCV auf Ubuntu

Hier werde ich behandeln, wie Sie OpenCV auf Ihrem Ubuntu-System installieren, wie Sie C++-Programme basierend auf dieser Open-Source-Bibliothek für maschinelles Sehen erstellen, Dateien oder Kameras lesen, grundlegende Bildverarbeitungsvorgänge ausführen, einige Dinge zeichnen oder schreiben und unsere speichern können Arbeit.

Inhaltsverzeichnis

• Einführung
  • Über OpenCV
  • Anforderungen
• Installieren
  • Bereiten Sie Ihr System vor
  • OpenCV herunterladen
  • Bauen
  • Konfigurieren
• Entwickeln mit OpenCV
  • Anwendung 1 - Einfaches Fenster
  • Terminalaufbau
    • g++
    • machen
    • CMake
  • KDevelop-Build
  • Anwendung 2 - Bild laden
  • Anwendung 3 - Video laden
  • Anwendung 4 - Zeichnen und verarbeiten

Einführung

Dies ist ein Programmierthema, und einige vorherige Programmierkenntnisse in einer beliebigen Sprache werden hilfreich sein, aber ich werde alle Tools und Befehle vorstellen, die zum Erstellen kleiner Programme erforderlich sind, sodass jeder mit guten logischen Denkfähigkeiten in der Lage sein kann, die Beispiele zu erstellen und davon zu profitieren .

Außerdem ist es ein einführendes Material und wird keine komplexen Programmier- oder wissenschaftlichen Konzepte behandeln. Ich werde mich stattdessen darauf konzentrieren, wie man Dinge zum Laufen bringt, Ihnen einen Beispielcode geben, damit Sie es selbst ausprobieren, sich daran gewöhnen und Spaß haben können.

Sie werden ermutigt, das API-Referenzhandbuch auf einer anderen Registerkarte zu öffnen und darauf zu verweisen, wann immer Sie ein neues Objekt, eine neue Funktion oder einen neuen Parameter in dem hier bereitgestellten Code finden, nachdem Sie es zum ersten Mal erstellt haben, nehmen Sie zum besseren Verständnis selbst einige Änderungen vor .

Außerdem ist es eine gute Idee, man zu verwenden und sich die offizielle Dokumentation aller hier vorgestellten Build-Tools, Dateien und Begriffe anzusehen.

Was ist OpenCV

OpenCV steht für Open Source Computer Vision Library, und ihr Hauptzweck besteht darin, einen standardisierten Ansatz für das Thema Computer Vision zu schaffen. Es bietet eine Reihe von Modulen, die Ihnen bei Dingen wie linearer Algebra, Bildverarbeitung, maschinellem Lernen, Hardwareabstraktion, High-Level-GUI sowie Schnittstellen zu OpenGL, OpenCL, CUDA usw. helfen. Denken Sie auch daran, dass es unter der BSD-Lizenz vertrieben wird, was ziemlich freizügig und sowohl für Forschungs- als auch für kommerzielle Zwecke gut ist.

Die Module, die wir in unseren Programmen verwenden werden, sind.

• Kern - die Basis von OpenCV
• HighGUI - Bietet eine ziemlich einfache und nützliche grafische Benutzeroberfläche auf hohem Niveau
• improc - Bietet Bildverarbeitungsfunktionen

Anforderungen

Dies sind die Anforderungen, die in den OpenCV-Dokumenten gezeigt werden, einige davon sind optional, aber es ist immer eine gute Idee, alle Anforderungen zu erfüllen, wenn Sie etwas lernen.

• GCC 4.4.x oder höher
• CMake 2.6 oder höher
• Git
• GTK+2.x oder höher, einschließlich Header (libgtk2.0-dev)
• pkg-config
• Python 2.6 oder höher und Numpy 1.5 oder höher mit Entwicklerpaketen (python-dev, python-numpy)
• ffmpeg- oder libav-Entwicklungspakete:libavcodec-dev, libavformat-dev, libswscale-dev
• [optional] libtbb2 libtbb-dev, libdc1394 2.x, libjpeg-dev, libpng-dev, libtiff-dev, libjasper-dev, libdc1394-22-dev

Installationsanleitung

In diesem ersten Teil des Artikels zeige ich Ihnen, wie Sie Ihr System vorbereiten, OpenCV erhalten, erstellen und installieren und einige Konfigurationen nach der Installation vornehmen

Vorbereiten

Aktualisieren Sie zuerst Ihre apt-Datenbank

apt-get update

Installieren Sie die Dinge aus dem Anforderungsabschnitt mit 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

OpenCV herunterladen

Wir werden OpenCV 2.4.11 verwenden, eine Terminalsitzung öffnen und wget wie folgt verwenden:

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

Sie können die neueste Version auch später klonen, und sehen Sie sich hier das Migrations-Tutorial an, in dem Sie lernen können, wie Sie zwischen OpenCV-Versionen wechseln.

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

Erstellen Sie die Quellen

Geben Sie das Paketverzeichnis ein

cd *2.4.11*

Erstellen Sie ein Verzeichnis für unseren OpenCV-Build und geben Sie es ein

mkdir build && cd build

Verwenden Sie im Build-Verzeichnis cmake, um es vorzubereiten.

cmake ..

Jetzt, wo wir ein Makefile haben, können wir machen und installieren

make && make install

Konfigurieren

Testen Sie, ob Ihr System die OpenCV-Pfade finden kann, führen Sie den folgenden Befehl aus:

 pkg-config --cflags --libs opencv

Wenn Sie eine Fehlermeldung erhalten, zeigt Ihre Umgebungsvariable PKG_CONFIG_PATH möglicherweise nicht auf OpenCV und Sie müssen den Pfad hinzufügen. Versuchen Sie, dies und den Test noch einmal auszuführen

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

Sie können den letzten Befehl an ein Profilskript anhängen, um es nicht jedes Mal ausführen zu müssen, versuchen Sie es mit .bashrc:

vi ~/.bashrc

Entwicklung mit OpenCV

Wir sind jetzt bereit, OpenCV-Code zu starten, hier sind einige Beispielprogramme und ein grundlegender Ansatz, wie man sie erstellt.

Erste Anwendung - Einfaches Fenster

Diese erste Anwendung öffnet einfach ein Fenster auf dem Bildschirm, es ist nicht sehr nützlich, aber gut, um Ihre Installation zu testen und zu lernen, wie man OpenCV-Anwendungen erstellt

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

//erstelle ein Fenster namens theWindow

namedWindow("theWindow", CV_WINDOW_AUTOSIZE);

//warte, dass der Benutzer eine Taste drückt

waitKey(0);

//Zerstöre das Fenster namens theWindow

DestroyWindow("theWindow");

gib 0 zurück;

}

Terminalaufbau

Erstellen Sie ein Verzeichnis für das Projekt

mkdir firstcv && cd firstcv

Erstellen Sie das c++ Datei mit Vi

vi main.cpp

bauen Sie es jetzt direkt mit g++

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

Machen

Die firstcv-Anwendung ist ziemlich einfach und kann leicht direkt erstellt werden. Wenn der Code jedoch komplex wird, werden Ihre Erstellungsbefehle bald kryptisch, auch die Reinigung und die allgemeine Wartung werden zu einem Chaos. Aus diesem Grund verwenden wir make

Erstellen Sie eine Datei namens Makefile mit folgendem Inhalt:

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

clean:
rm firstcv

Es ruft im Grunde den Compiler mit einem vorbereiteten Satz von Parametern auf, wenn all das Ziel ist und die ausführbare Datei entfernt, wenn das Ziel sauber ist , weitere Einzelheiten zu Makefile finden Sie hier

Eine weitere Tatsache bei make ist, dass es das erste Ziel verwendet, wenn keine Ziel-ID angegeben wird. Um den Code zu erstellen, brauchen Sie also nur make:

make

CMake

Der letzte Ansatz zum Erstellen von Anwendungen, aber die Erstellung von Makefiles kann auch komplex werden, wenn Sie systemübergreifend erstellen. Sie können dann Ihren Build mit CMake generieren, wie es das OpenCV-Projekt selbst tut, es vereinfacht das Build-Management und erhöht die plattformübergreifende Kompatibilität.

Anstatt am Makefile zu arbeiten, erstellen wir nun eine Datei namens CMakeLists.txt mit ähnlichem Inhalt:

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} )

Es heißt:

cmake_minimum_required :CMake-Mindestversion ist 2.6

Projekt :Name Ihres Projekts

include_directories :Zusätzlich enthält Pfad

find_package :Suchen Sie nach dem OpenCV-Paket, wie wir es mit pkg-config getan haben früher

add_executable :die resultierenden Binärdateien und ihre Quelldateien.

installieren :Installationspfad

target_link_libraries :Gemeinsame Objekte, die verknüpft werden sollen, funktioniert wieder wie pkg-config

Erstellen Sie dann ein Build-Verzeichnis und geben Sie dort ein.

mkdir build && cd build

Bereiten Sie Ihren Build mit cmake

vor

cmake ..

Mit einem Makefile in der Hand machen Sie es:

make

Führen Sie einfach Ihr Programm aus

./firstcv

KDevelop-Build

Obwohl Sie ganze Systeme vom Konsolenterminal aus erstellen können, können Sie viel mehr tun, indem Sie Funktionen wie Codeformatierung, Syntaxhervorhebungscodereferenz, Debugger und andere mithilfe einer IDE verwenden. KDevelop ist großartig, einfach und ich werde Ihnen zeigen, wie Sie Ihre Projekte basierend auf der Cmake-Terminalanwendungsvorlage erstellen.

Klicken Sie auf das Menü Projekt ->Neu aus Vorlage , und wählen Sie dann Standard aus in Kategorie,Terminal bei Projekttyp und benennen Sie es.

Sobald das Projekt erstellt ist, ändern Sie den Inhalt der Datei main.cpp mit dem zuvor bereitgestellten

Doppelklicken Sie im Projektfenster auf den Projektnamen, dann auf die Datei CMakeLists.txt und ändern Sie sie entsprechend dem CMake-Abschnitt.

Erstellen Sie Ihr Projekt, klicken Sie auf Erstellen oder drücken Sie [F8] drücken und mit [F9] ausführen , müssen Sie beim ersten Lauf die Laufparameter wie folgt einstellen

Jetzt können Sie OpenCV-Code erstellen, für die nächsten Anwendungen müssen Sie nur die Projekterstellung wiederholen oder die Quelle der main.cpp-Datei ersetzen.

Anwendung 2 - Bild anzeigen

Diese Anwendung zeigt einfach den Inhalt einer Bilddatei im Fenster

an

#include "opencv2/highgui/highgui.hpp"

using namespace cv;
using namespace std;

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

//Erstelle ein Mat-Objekt und lade den Inhalt der Datei linoxide.png darauf

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

//Wenn das Bild leer ist, sterbe mit Fehler-Exit-Status

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

namedWindow("theWindow", CV_WINDOW_AUTOSIZE);

//Zeige das Bild im Fenster

imshow("dasFenster", img);

waitKey(0);

DestroyWindow("theWindow");

gib 0 zurück;

}

Hier ist das laufende Programm:

Anwendung 3 - Video laden

Diesmal werden wir den Inhalt direkt von unserer Kamera lesen, es sind nur ein paar Änderungen am letzten Code

#include "opencv2/opencv.hpp"

using namespace cv;
using namespace std;

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

//Kamera starten

VideoCapture-Kappe (0); Mat img;

namedWindow("theWindow", CV_WINDOW_AUTOSIZE);

während (wahr){

//Wenn die Kamera nicht lesen kann, stirbt das Programm

if (! cap.read (img)) {Rückgabe -1; }

imshow("dasFenster", img );

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

}

}

Anwendung 4 - Bildverarbeitung

Nachdem Sie nun Ihre Bilder laden können und einen grundlegenden Programmablauf haben, wollen wir dies verbessern, einige Steuerelemente erstellen, etwas zeichnen, das dem Logo von Linoxide ähnelt, einige Transformationen an den Bildern vornehmen und sie speichern.

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

//Initiieren Sie das Videoaufnahmegerät auf der Kappe VideoCapture cap(0);

//Falls Aufnahmegerät nicht geöffnet werden konnte, Programm sterben if(!cap.isOpened()){return -1;}

//Hier ist unser Rahmen Mattenrahmen;

//Wir zeigen unsere Frames hier mit dem NamenWindow("display", CV_WINDOW_AUTOSIZE);

//Dieses Fenster enthält Trackbars zum Ändern des Programmverhaltens namedWindow("config", CV_WINDOW_AUTOSIZE);

//Standardmäßig werden wir den Frame nicht invertieren bool invertimg =false;

//wir zeichnen Linoxide Logo Sketch bool draw =true;

// einen Halter für unseren Frame-Flip-Modus erstellen int flipmode =0; // eine Trackbar erstellen, um den Flip-Modus zu ändern cvCreateTrackbar("Flip Mode:", "config", &flipmode, 3);

// Breiten- und Höhenwerthalter für die Bildgrößenänderung int screen_width =640; int screen_height =480;

// erstelle Trackbars im Konfigurationsfenster, um die Größeneigenschaften zu ändern cvCreateTrackbar("Width:", "config", &screen_width, 1024); cvCreateTrackbar("Höhe:", "config", &screen_height, 768);

// einen Vektor von Komprimierungsparametern erstellen, der zum Erstellen eines Schnappschusses verwendet wird vector compression_pars; compression_pars.push_back(CV_IMWRITE_PNG_COMPRESSION); compression_pars.push_back(9);

während (wahr){

if(!cap.read(frame)){return -1;} // Frame konnte nicht gelesen werden, Programm sterben

//Wenn Invertimg wahr ist, invertieren Sie jedes der Matrixelemente, indem Sie seinen Wert vom maximal möglichen Wert reduzieren, wenn (Invertimg ==true){frame =Scalar::all(255) - frame; }

// Rahmen gemäß den Werten auf der Flip-Modus-Trackbar spiegeln if(flipmode> 0){flip(frame,frame,1);} //horizontal spiegeln if(flipmode> 1){flip(frame,frame,0);} //vertikal spiegeln, jetzt wird in beide Richtungen gespiegelt if(flipmode> 2){flip(frame,frame,1);} //horizontal spiegeln, jetzt nur noch vertikal gespiegelt

//Größe des Rahmens entsprechend den Werten auf den Trackbars ändern resize(frame,frame, Size(screen_width,screen_height) );

if (draw ==true){

// Zeichne ein weißes Rechteck als Hintergrund, die Farbe ist Skalar (B, G, R) Rechteck (Rahmen, Punkt (5,25), Punkt (140,70), Skalar (255,255,255), -1, 8, 0);

//dunkelgelbes Rechteck, beachten Sie, dass der Alpha-Wert verwendet werden kann. rechteck(rahmen, Punkt(5,25), Punkt(54,55), Skalar(00,225,255,0), -1, 8, 0);

//Hellblaues Rechteck, die Dicke ist negativ, also wird es vollständig gefüllt. Rectangle(frame, Point(57,25), Point(140,55), Scalar(255,225,100), -1, 8, 0);

//schwarzes Rechteck, beginnt bei Punkt x5,y57, endet bei x140,y70 Rechteck(Rahmen, Punkt(5,57), Punkt(140,70), Skalar(0,0,0), -1, 8, 0 );

// Text auf den Rahmen schreiben, getrennt nach Schriftart und Position 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);

} //unseren Frame im Anzeigefenster anzeigen imshow("display",frame);

switch(waitKey(10)){ case 27://[esc], Programm mit Erfolg beenden return 0; case 'i':// Bild invertieren umschalten if (invertimg ==false){invertimg =true;}else {invertimg =false;} case 'd':// Linoxide umschalten if (draw ==false){draw =true;}else {draw =false;} case 's'://Schnappschuss machen, in snapshot.png speichern imwrite("snapshot.png", frame, compression_pars);

}

} //mit Erfolg beenden return 0;

}

Hier ist es

Schlussfolgerung

Das ist alles für den Moment, Sie sollten in der Lage sein, Programme basierend auf der OpenCV-Bibliothek zu erstellen. Die hier vorgestellten Konzepte sollen Ihnen die Ideen hinter der Bibliothek näherbringen. Aber das ist nur der Anfang, Sie können in die offiziellen Tutorials eintauchen, tiefer in Referenzen und Beispiele von OpenCV einsteigen und sich fortgeschrittenere Dinge ansehen, wie Objekterkennung, Gesichtserkennung, Objektverfolgung, Vorlagenabgleich, maschinelles Lernen, 3D-Mapping.

Danke fürs Lesen, ich hoffe es gefällt dir und du machst tolle Sachen mit OpenCV!