Katedra Robotyki i Mechatroniki

Systemy wizyjne.

OpenCv_Cw0

Temat: Wprowadzenie do bibliotek OpenCV

(Dwiczenia do samodzielnej realizacji).

Prowadzący: dr inż. Piotr KOHUT

Grupa:

Imię i nazwisko:

Data:

Uwagi:

1.)

Cel dwiczenia:

Zapoznanie się z biblioteką OpenCV. Zapoznanie się z metodologią konfiguracji kompilatora
DevCpp z biblioteką OpenCV. Zapoznanie się z możliwościami pozyskania obrazów z kamery
internetowej USB za pomocą funkcji cvCaptureFromCAM().

2.)

Podstawy teoretyczne:

Wstęp do biblioteki OpenCV
OpenCV (Open Source Computer Vision library) jest bezpłatną, open-source’ową biblioteką
do użytku komercyjnego i edukacyjnego, bez konieczności udostępniania swoich projektów
opartych o jej implementację. Została napisana w języku C i C++ i rozwijana jest za pomocą
wrapperów w wielu językach programowania takich jak C#, Python, Ruby, Matlab czy Java.
Posiada wielu użytkowników na całym świecie – doskonałym przykładem jest grupa
tematyczna o OpenCV na portalu Yahoo, która aktualnie posiada ponad 48.000
użytkowników.
Biblioteka ta została stworzona na potrzeby aplikacji czasu rzeczywistego gdzie wydajnośd
obliczeniowa programów jest bardzo istotna. Napisana jest w zoptymalizowanym języku
C/C++ i wykorzystuje możliwości jakie dają popularne od kilku lat procesory wielordzeniowe.
Jednym z głównych celów biblioteki OpenCV jest dostarczenie narzędzia, które pozwoli
tworzyd zarówno proste programy jak również zaawansowane projekty ludziom z różnym
poziomem wiedzy na temat programowania i przetwarzania obrazów. Amatorzy za pomocą
OpenCV i kamery internetowej mogą poznawad elementy przetwarzania obrazów w
zakresie: wykrywania krawędzi, segmentacji czy filtracji obrazów bez większego wysiłku. Zaś
sami specjaliści nie muszą poświęcad czasu na pisanie bazowych funkcji w zaawansowanych
projektach – nigdy więcej wymyślania koła! Możliwe jest to dzięki wbudowanym w
bibliotekę ponad 500 funkcjom, które obejmują wiele obszarów komputerowej wizji takich
jak robotyka, stereowizja, bezpieczeostwo, analiza obrazów medycznych czy kalibracja
kamery. Wiele projektów wykorzystujących zdjęcia z lotu ptaka czy mapowanie ulic takie jak
– „Google Maps”, czy „Google Street’s View”, wykorzystuje kalibracje kamery oraz metody
„zszywania” obrazów, które są częścią OpenCV. Bezzałogowe samoloty, urządzenia do
detekcji obiektów czy układy monitoringu również oparte są o wizje komputerową.
Interesującym zastosowaniem było użycie ich w wyścigu „Grand Challange” przeznaczony dla
autonomicznych pojazdów. Wyścig odbył się w październiku roku 2005, a organizatorem była
amerykaoska agencja DARPA, zajmująca się rozwojem technologii wojskowej. Samochód
„Stanley” – Volkswagen Touareg przejechał samodzielnie trasę 212 km po pustyni Mojave
oraz południu Las Vegas w czasie 6 godzin i 54 minut. Jedną z głównych ról przy
projektowaniu systemu wizyjnego odegrała właśnie biblioteka OpenCV.

Rozwój projektu i zgodnośd

Początki OpenCV sięgają kooca lat 90’. W tamtych latach korporacja Intel rozpoczęła kilka
projektów opartych o prace w czasie rzeczywistym – takich jak śledzenie promieni oraz
wyświetlanie obiektów 3D na ścianie. Jeden z autorów tych projektów wizytując w tym
czasie amerykaoskie uniwersytety zauważył, że kilka grup uniwersyteckich takich jak „MIT
Media Lab” z MIT w Massachusetts posiada wiele rozbudowanych narzędzi do przetwarzania

obrazów, które były propagowane i jednocześnie udoskonalane przez studentów. Właśnie
przy współpracy tych grup oraz pomocy Intel’s Performance Library Team zostało stworzone
jądro z zaimplementowanym kodem oraz specyfikacją algorytmów. Dane te zostały
przesłane do Intel’s Russian Library Team w Niższym Nowogrodzie w Rosji – gdzie właśnie
powstała biblioteka OpenCV.
Głównymi celami OpenCV jakie zostały założone w trakcie jej budowania było stworzenie
darmowego, otwartego i zoptymalizowanego kodu dla podstawowych funkcji przetwarzania
obrazów. Kod ten musiał byd czytelny i łatwy do przenoszenia, gdyż był podstawą dla
deweloperów, którzy mieli go rozwijad.
Można by się zastanawiad dlaczego Intel stworzył bardzo pomocą bibliotekę dla
deweloperów całkowicie za darmo. Idea była bardzo prosta – wykorzystanie tej biblioteki
pomagało w projektowaniu aplikacji wymagających dużej mocy obliczeniowej, a tym samym
szybkich procesorów. Sprzedaż komponentów firmy Intel była bardziej opłacalna niż
wypuszczenie na rynek dodatkowego oprogramowania. Pomysł mógł byd zrealizowany tylko
przy dużej popularności tej biblioteki. Intel nie pomylił się z prognozami – do tej pory ze
strony projektu biblioteka OpenCV została ściągnięta 3.305.005 razy, co stanowi 46.8 TB
danych!

Rys. 1. Statystyki pobrao biblioteki OpenCV ze strony projektu

Pierwsza wersja „alpha” biblioteki została udostępniona w roku 2000. Następne,
udoskonalone wersje to: „Beta 1” – 2001 (wsparcie dla Linuxa), „Beta 2” – 2002, „Beta 3” –
2003, „Beta 4” – 2004, „Beta 5” – 2005. Oficjalna wersja OpenCV o nazwie „1.0” powstała
dopiero w październiku 2006 roku. Spora aktywnośd deweloperów w kierunku rozwijania
projektu spowodowała powstawanie kolejnych wersji: „1.1pre1” – 2008, „2.0” – 2009. Od
kwietnia 2010 roku dostępna jest wersja „2.1”. W grudniu 2010 pojawiła się wersja „2.2”.
Biblioteka OpenCV przeznaczona jest do pracy z systemami Linux, MacOS oraz Windows pod
kompilatorami Visual Studio 2005, 2008 (wraz z wersjami Express), MinGW – Windows oraz
GCC 4.x – Linux i MacOS..

Konfiguracja biblioteki OpenCV w środowisku kompilatora Bloodshed Dev C++

Aby pisad programy w C/C++ z wykorzystaniem bibliotek OpenCV należy najpierw

skonfigurowad odpowiednio kompilator. Poniższy opis zakłada iż użytkownik jest w stanie

samodzielnie poradzid sobie z instalacją plików bibliotek OpenCV oraz, DevCpp. Opracowanie

zostało przygotowane dla anglojęzycznej wersji programu, oraz wersji bibliotek 1.0, oraz 1.1.

Sposób konfiguracji kolejnych wersji bibliotek można znaleźd w komentarzach, jednak nie

jest on zobrazowany przykładami, co należy mied na uwadze.

Założono że biblioteki OpenCV są zainstalowane zgodnie z następującą ścieżką: C:\Program

Files\OpenCV .

Pierwszym krokiem będzie uruchomienie programu DevCpp, a następnie z menu Tools

wybranie opcji Compiler Options

Następnie należy kliknąd zielony plus, aby dodad nowy kompilator ( w rzeczywistości stary, ze

zmienioną jedynie nazwą) Jako nazwę nowego kompilatora należy wpisad OpenCV

Aby zakooczyd tą częśd należy w sekcji Add the following.. wpisad:

-L"C:\Program Files\OpenCV\lib" -lcxcore -lcv -lcvaux -lhighgui -lml –lcvcam

Lub też w przypadku wersji bibliotek 2.x:

-L"C:\OpenCV2.x\lib" -lcxcore2x0 -lcv2x0 -lcvaux2x0 -lhighgui2x0 -lml2x0

Gdzie x należy zastąpid stosownym numerem porządkowym.

Następnie w zakładce Directories, pod zakładka C należy dodad podkatalogi zgodnie z

poniższym zdjęciem:

Dla wersji bibliotek 2.x należy jedynie dodad jedynie folder zgodnie ze ścieżką:

C:\Program Files\OpenCV2.x\include\opencv

Te same operacje należy przeprowadzid w pod zakładce C++

Następnie w zakładce Libraries należy dodad biblioteki jak poniżej:

Dla wersji bibliotek 2.x zamiast biblioteki otherlibs\highgui należy dodad bibliotekę

OpenCV2.x\bin

Na koniec należy w zakładce Libaries dodad jak poniżej:

3.) Instrukcja wykonania dwiczenia

a.) Schemat blokowy postępowania w dwiczeniu

b.) Opis dwiczenia

W pierwszym etapie należy dokonad kontroli stanowiska, złożonego z kamery internetowej i
komputera klasy PC. Należy skontrolowad poprawnośd podłączenia kamery do komputera
poprzez interfejs USB.

Następnie należy skontrolowad poprawnośd konfiguracji programu DevCpp zgodnie z opisem
zawartym w punkcie 2, oraz, w razie problemów z nią związanych wprowadzid stosowne
poprawki.

Kolejnym etapem jest implementacja w środowisku programu wykorzystującego
podstawowe funkcje biblioteki OpenCV

Po uruchomieniu programu DevCpp należy otworzyd nowy plik źródłowy (Rys. 2.)

Kontrola
stanowiska,
poprawności
konfiguracji
DevCpp

Implementacja
zadanego
programu i
jego kompilacja

Przeprowadzenie
testów
funkcjonowania
utworzonego
programu

Rozszerzenie
funkcjonalności
programu o
zapis wybranej
klatki

Ponowny test
funkcjonowania
programu i zapis
wyników

Rys. 2. Otwieranie nowego pliku źródłowego w programie DevCpp

Następnie należy zapisad plik, pod wybraną nazwą, przy użyciu menu Plik -> Zapisz jako

(Rys. 3.)

Rys. 3. Zapis projektu pod wybraną nazwą.

Po wykonaniu powyższych czynności wstępnych można wprowadzid w okno edytora
programu poniższy kod:

////////////////////////////////////////////////////////////////////////////////

//Biblioteki

#include <cv.h>

#include <highgui.h>

#include <stdio.h>



int main()

{

////////////////////////////////////////////////////////////////////////////////

//Krok 1: Utworzenie polaczenia z kamera

CvCapture* capture = cvCaptureFromCAM( CV_CAP_ANY );

//Stworzenie obsługi bledu: "nie wykryto kamery"

if( !capture )

{

fprintf( stderr, "nie wykryto kamery" );

getchar();

return -1;

}

////////////////////////////////////////////////////////////////////////////////

//Krok 2: Utworzenie okna

cvNamedWindow( "on-line", CV_WINDOW_AUTOSIZE );

////////////////////////////////////////////////////////////////////////////////

//Krok 3: Przechwyt klatek w pętli

while( 1 )

{

IplImage* frame = cvQueryFrame( capture );

//Stworzenie obslugi bledu: "brak klatki"

if( !frame )

{

fprintf( stderr, "brak klatki" );

getchar();

break;

}

////////////////////////////////////////////////////////////////////////////////

//Krok 4: Projekcja klatek w petli

cvShowImage( "on-line", frame );

//Warunek przerwania petli. Klwaisz 'Esc'

if( (cvWaitKey(10) & 255) == 27 ) break;



}

////////////////////////////////////////////////////////////////////////////////

//Krok 5: Usuniecie obiektow z pamieci

cvReleaseCapture( &capture );

cvDestroyWindow( "on-line" );

return 0;

}

////////////////////////////////////////////////////////////////////////////////

Tak utworzony program należy przekompilowad wybierając z menu Uruchom opcję Kompiluj
(Rys. 4.)

Rys. 4. Uruchomienie kompilacji programu

3 Etapem jest kontrola poprawności utworzonego programu. Należy uruchomid utworzony
plik wykonawczy (.exe). Jego nazwa będzie taka sama jak nadana uprzednio plikowi
źródłowemu. Po uruchomieniu programu powinny wyświetlid się 2 okna – okno programu, w
którym wyświetlane będą ewentualne komunikaty o błędach, oraz okno podglądu obrazu z
kamery.

Należy teraz przeprowadzid kontrolę przechwytywania obrazu przez kamerę, zmieniając
obserwowany przez nią obraz. Efekty tych działao należy zarejestrowad w postaci print
screnów w celu zawarcia ich w raporcie. Aby zakooczyd pracę z programem należy nacisnąd
klawisz „Esc”

W kolejnym etapie należy wrócid do utworzonego pliku źródłowego, a następnie zapisad go
ponownie pod zmienioną nazwą (Rys. 3.) w celu modyfikacji.

W programie należy dokonad modyfikacji, dodając linię odpowiedzialne za zapis pojedynczej
klatki, zgodnie z wyborem użytkownika. Kod wynikowy znajduje się poniżej:

////////////////////////////////////////////////////////////////////////////////

//Biblioteki

#include <cv.h>

#include <highgui.h>

#include <stdio.h>



int main()

{

////////////////////////////////////////////////////////////////////////////////

//Krok 0: Deklaracja zmiennych

char* filename = "obraz.bmp";

////////////////////////////////////////////////////////////////////////////////

//Krok 1: Utworzenie polaczenia z kamera

CvCapture* capture = cvCaptureFromCAM( CV_CAP_ANY );

//Stworzenie obslugi bledu: "nie wykryto kamery"

if( !capture )

{

fprintf( stderr, "nie wykryto kamery" );

getchar();

return -1;

}

////////////////////////////////////////////////////////////////////////////////

//Krok 2: Utworzenie okna

cvNamedWindow( "on-line", CV_WINDOW_AUTOSIZE );

////////////////////////////////////////////////////////////////////////////////

//Krok 3: Przechwyt klatek w petli

while( 1 )

{

IplImage* frame = cvQueryFrame( capture );

//Stworzenie obslugi bledu: "brak klatki"

if( !frame )

{

fprintf( stderr, "brak klatki" );

getchar();

break;

}

////////////////////////////////////////////////////////////////////////////////

//Krok 4: Projekcja klatek w petli

cvShowImage( "on-line", frame );

////////////////////////////////////////////////////////////////////////////////

//Krok 5: Zapisanie klatki pod zdeklarowana nazwa

cvSaveImage(filename, frame);

//Warunek przerwania petli. Klwaisz 'Esc'

if( (cvWaitKey(10) & 255) == 27 ) break;



}

////////////////////////////////////////////////////////////////////////////////

//Krok 5: Usuniecie obiektow z pamieci

cvReleaseCapture( &capture );

cvDestroyWindow( "on-line" );

return 0;

}

////////////////////////////////////////////////////////////////////////////////

Tak utworzony program należy skompilowad (Rys. 4.)

Następnie należy uruchomid plik wykonawczy tak skompilowanego programu, jego nazwa
będzie się zgadzad z uprzednio nadaną plikowi źródłowemu.

Podobnie jak poprzednio program wyświetla 2 okna – okno programu, w którym wyświetla
komunikaty, i okno podglądu obrazu z kamery.

Dodatkowo po naciśnięciu klawisza „Esc” na dysku zostaje zachowany aktualny obraz, pod
nazwą zadaną przez zmienną „filename” zgodnie z poniższym fragmentem kodu:

////////////////////////////////////////////////////////////////////////////////

//Krok 0: Deklaracja zmiennych

char* filename = "obraz.bmp";

////////////////////////////////////////////////////////////////////////////////

Jednocześnie kooczy to pracę programu. Należy zarejestrowad w ten sposób kilka obrazów,
zmieniając nazwę obrazu w kodzie programu, i zawrzed je w raporcie.

4.) Najważniejsze wykorzystane funkcje bibliotek OpenCV I ich składnia:



cvCaptureFromCAM

CvCapture* cvCaptureFromCAM(int index)

Initializes capturing a video from a camera.

Parameter:

index – Index of the camera to be used. If there is only one camera or it does not matter
what camera is used -1 may be passed.

The function cvCaptureFromCAM allocates and initializes the CvCapture structure for
reading a video stream from the camera. Currently two camera interfaces can be used on
Windows: Video for Windows (VFW) and Matrox Imaging Library (MIL); and two on Linux:
V4L and FireWire (IEEE1394).

To release the structure, use ReleaseCapture .



cvNamedWindow

int cvNamedWindow(const char* name, int flags)

Creates a window.

Parameters:

name – Name of the window in the window caption that may be used as a window
identifier.

flags – Flags of the window. Currently the only supported flag is CV_WINDOW_AUTOSIZE . If
this is set, window size is automatically adjusted to fit the displayed image (see ShowImage ),
and the user can not change the window size manually.

The function cvNamedWindow creates a window which can be used as a placeholder for
images and trackbars. Created windows are referred to by their names.

If a window with the same name already exists, the function does nothing. [Qt Backend
Only] qt-specific details:

flags Flags of the window. Currently the supported flags are:

CV_WINDOW_NORMAL or CV_WINDOW_AUTOSIZE: CV_WINDOW_NORMAL let the user
resize the window, whereas CV_WINDOW_AUTOSIZE adjusts automatically the window’s
size to fit the displayed image (see ShowImage ), and the user can not change the window
size manually.

CV_WINDOW_FREERATIO or CV_WINDOW_KEEPRATIO: CV_WINDOW_FREERATIO adjust
the image without respect the its ration, whereas CV_WINDOW_KEEPRATIO keep the
image’s ratio.

CV_GUI_NORMAL or CV_GUI_EXPANDED: CV_GUI_NORMAL is the old way to draw the
window without statusbar and toolbar, whereas CV_GUI_EXPANDED is the new enhance
GUI.

This parameter is optional. The default flags set for a new window are
CV_WINDOW_AUTOSIZE , CV_WINDOW_KEEPRATIO , and CV_GUI_EXPANDED .

However, if you want to modify the flags, you can combine them using OR operator, ie:

cvNamedWindow( ``myWindow'', ``CV_WINDOW_NORMAL`` textbar
``CV_GUI_NORMAL`` );



cvShowImage

void cvShowImage(const char* name, const CvArr* image)

Displays the image in the specified window

Parameters:

name – Name of the window.

image – Image to be shown.

The function cvShowImage displays the image in the specified window. If the window was
created with the CV_WINDOW_AUTOSIZE flag then the image is shown with its original size,
otherwise the image is scaled to fit in the window. The function may scale the image,
depending on its depth:

If the image is 8-bit unsigned, it is displayed as is.

If the image is 16-bit unsigned or 32-bit integer, the pixels are divided by 256. That is, the
value range [0,255*256] is mapped to [0,255].

If the image is 32-bit floating-point, the pixel values are multiplied by 255. That is, the value
range [0,1] is mapped to [0,255].



cvWaitKey

int cvWaitKey(int delay=0)

Waits for a pressed key.

Parameter:

delay – Delay in milliseconds.

The function cvWaitKey waits for key event infinitely ( ) or for delay milliseconds. Returns
the code of the pressed key or -1 if no key was pressed before the specified time had
elapsed.

Note: This function is the only method in HighGUI that can fetch and handle events, so it
needs to be called periodically for normal event processing, unless HighGUI is used within
some environment that takes care of event processing. [Qt Backend Only] qt-specific details:
With this current Qt implementation, this is the only way to process event such as repaint
for the windows, and so on ldots



cvSaveImage

int cvSaveImage(const char* filename, const CvArr* image)

Saves an image to a specified file.

Parameters:

filename – Name of the file.

image – Image to be saved.

The function cvSaveImage saves the image to the specified file. The image format is chosen
based on the filename extension, see LoadImage . Only 8-bit single-channel or 3-channel
(with ‘BGR’ channel order) images can be saved using this function. If the format, depth or
channel order is different, use cvCvtScale and cvCvtColor to convert it before saving, or use
universal cvSave to save the image to XML or YAML format.



cvReleaseCapture

void cvReleaseCapture(CvCapture** capture)

Releases the CvCapture structure.

Parameter:

capture – Pointer to video the capturing structure.

The function cvReleaseCapture releases the CvCapture structure allocated by
CaptureFromFile or CaptureFromCAM .



cvDestroyWindow

void cvDestroyWindow(const char* name)

Destroys a window.

Parameter:

name – Name of the window to be destroyed.

The function cvDestroyWindow destroys the window with the given name.