środa, 29 kwietnia 2009

Quo vadis?

Zastanawiając się nad tematyką kolejnego posta doszedłem do wniosku, że nie mam szansy zrobić regularnego kursu, ponieważ za małą mam wiedzę w tej dziedzinie ;-) A co za tym idzie, nie będzie już kolejnych postów pt. "OpenCV cz.X". Nie mam zamiaru jednak zawieszać bloga. Dalej będę opisywać zmagania z biblioteką, ale już w luźniejszej formie i bez konkretnego kierunku.To co sprawi mi problemy lub wyda mi się ciekawe zostanie tutaj opisane. Na głównej stronie biblioteki napisano:
The Open Computer Vision Library has > 500 algorithms, documentation and sample code for real time computer vision.
I na tych algorytmach chciałbym się skupić. Jak wyjdzie w praniu, to się okaże...

Pozdrawiam,
Ratix ;-)

niedziela, 19 kwietnia 2009

OpenCV cz. 4. Splot

Splot (ang. convolution) jest jedną z najczęściej używanych operacji w wizji (widzeniu) komputerowym. Po definicję matematyczną splotu odsyłam do wikipedii. Nie należy się zrażać widząc całki. W przetwarzaniu obrazów cyfrowych mamy doczynienia z funkcjami dyskretnymi, więc całki jako takie nie mają racji bytu (dotyczy to też wielu innych matematycznych narzędzi). Więc czym jest splot? Można to określić jako modyfikację jednej funkcji inną. U nas będzie to modyfikacja obrazu pewną maską. W ten sposób zmodyfikujemy obraz, aby ułatwić sobie dalszą z nim pracę. Jak to działa w praktyce?

Powyżej widzimy maskę i wycinek obrazka. Ciemniejszym kolorem zaznaczono odpowiednio środek maski i aktualnie przetwarzany piksel. "Nakładamy" maskę tak aby zaciemnione pola się nakryły i wykonujemy mnożenie pikseli obrazka z pikselami maski które się nad nimi znajdują:
0.1 * 32 + 0.1 * 12 + 0.1 * 54 + 0.1 * 43 + 0.2 * 32 + 0.1 * 32 + 0.1 * 12 + 0.1 * 73 + 0.1 * 43 = 36.5.
Wynik zaokrąglamy, otrzymujemy 36. Wartość tą wstawiamy w obraz wynikowy na pozycji odpowiadającej aktualnie przetwarzanemu pikselowi. Tak uzyskany obraz wynikowy nazywany jest potocznie splotem.

Poniżej przedstawione zdjęcie (tablica z parku Vigelanda w Oslo):
przetwarzamy, w wersji w odcieniach szarości, wcześniej pokazaną maską
0.1 0.1 0.1
0.1 0.2 0.1
0.1 0.1 0.1

i otrzymujemy:
Jak można zauważyć (lub nie można ;-) ), uzyskany obraz jest wygładzony. Omawiana maska jest tzw. filtrem wygładzającym. Jest to przykładowe wykorzystanie splotu. Samych filtrów wygładzających jest sporo. Często maski prezentuje się w takiej formie:
1 1 1
1 2 1
1 1 1

dodając przed maską współczynnik skali, w tym przypadku wynosi on 1/10. Ok, czas na kod:
// otwieramy obraz na ktorym bedziemy operowac
IplImage* obraz = cvLoadImage("/home/lukasz/blog/vigeland.png", CV_LOAD_IMAGE_GRAYSCALE);

// tworzymy maske
CvMat* maska = cvCreateMat(3,3,CV_32F);

// nasza maska wyglada nastepujaco
// 0.1 0.1 0.1
// 0.1 0.2 0.1
// 0.1 0.1 0.1
for(int i = 0; i < 3; i++)
for(int j = 0; j < 3; j++)
cvSet2D(maska,j,i,cvScalarAll(0.1));

cvSet2D(maska,1,1,cvScalarAll(0.2));

// splot
// kolejno przekazujemy: obraz zrodlowy, obraz docelowy, maska i opcjonalnie
// srodek maski
// Przekazywanie jako obrazu zrodlowego i docelowego tej samej struktury nie
// zawsze jest wskazane. Wspomne o tym w odpowiednim momencie.
cvFilter2D(obraz,obraz,maska);

cvNamedWindow("splot", CV_WINDOW_AUTOSIZE);
cvShowImage("splot", obraz);
while (true)
{
if (cvWaitKey(100) == 'k') break;
}

// zapisujemy obraz wynikowy
cvSaveImage("/home/lukasz/blog/splot.png",obraz);

cvDestroyAllWindows();
cvReleaseImage(&obraz);
cvReleaseMat(&maska);
Splot służy nie tylko do wygładzania. Jedyne czego nam potrzeba to odpowiednie maski! Zobaczmy filtr Sobela. Maska wygląda nastepująco:
-1 -2 -1
0  0  0
1  2  1
w odpowienie miejsce w kodzie wstawiamy:
cvSet2D(maska,2,0,cvScalarAll(1.0));
cvSet2D(maska,2,1,cvScalarAll(2.0));
cvSet2D(maska,2,2,cvScalarAll(1.0));
cvSet2D(maska,1,1,cvScalarAll(0.0));
cvSet2D(maska,1,1,cvScalarAll(0.0));
cvSet2D(maska,1,1,cvScalarAll(0.0));
cvSet2D(maska,0,0,cvScalarAll(-1.0));
cvSet2D(maska,0,1,cvScalarAll(-2.0));
cvSet2D(maska,0,2,cvScalarAll(-1.0));
i otrzymujemy: Filtr sobela realizuje coś na wzór pierwszej pochodnej. Przedstawiona maska operuje wzdłuż osi pionowej. Tego typu filtry wykorzystuje się np. do wykrywania krawędzi na obrazie. Transponując macierz, otrzymamy filtr dla osi poziomej:
-1  0 -1
-2  0 -2
-1  0 -1
Ten sam efekt można uzyskać też inaczej, zdając się na bilbiotekę:
// otwieramy obraz na ktorym będziemy operowac
IplImage* obraz = cvLoadImage("/home/lukasz/blog/vigeland.png", CV_LOAD_IMAGE_GRAYSCALE);

// tworzymy maske
CvMat* maska = cvCreateMat(3,3,CV_32F);

// stosujemy filtr sobela rzedu 0 dla poziomu i 1 dla pionu
cvSobel(obraz,obraz,0,1);

cvNamedWindow("splot", CV_WINDOW_AUTOSIZE);
cvShowImage("splot", obraz);
while (true)
{
if (cvWaitKey(100) == 'k') break;
}

// zapisujemy obraz wynikowy
cvSaveImage("/home/lukasz/blog/splot.png",obraz);

cvDestroyAllWindows();
cvReleaseImage(&obraz);
Wynikiem jest: Wynik działania powinien być w miarę podobny. Czasami rozbieżności wynikają z faktu, że dla danego filtru istnieje więcej niż jedna maska. Na przyszłość polecam oczywiście metodę cvSobel :) Splot jest bardzo często jedną z początkowych operacji w przetwarzaniu wizyjnym. Zobaczmy laplasjan:
// otwieramy obraz na ktorym bedziemy operowac
IplImage* obraz = cvLoadImage("/home/lukasz/blog/vigeland.png", CV_LOAD_IMAGE_GRAYSCALE);

// tworzymy macierz na wynik
CvMat* lap = cvCreateMat(obraz->height,obraz->width,CV_32F);
// uzycie operatora Laplace'a 
cvLaplace(obraz,lap);

cvNamedWindow("splot", CV_WINDOW_AUTOSIZE);
cvShowImage("splot", lap);
while (true)
{
if (cvWaitKey(100) == 'k') break;
}

// zapisujemy obraz wynikowy
cvSaveImage("/home/lukasz/blog/splot.png",lap);

cvDestroyAllWindows();
cvReleaseMat(&lap);
Chciałem tu zwrócić uwagę na dwie sprawy. Po pierwsze, do wyświetlania wyniku posłużyliśmy się tym razem strukturą CvMat, jak widać nie ma z tym problemu, o czym pisałem już kiedyś (nie jest to oczywiście bezwarunkowa operacja). Druga to właśnie fakt, że do cvLaplace nie mogliśmy podać jako źródła i wyniku tego samego obrazu. cvLaplace wymaga by jako wynik podać strukturę przechowującą 16-bitowe liczby ze znakiem lub 32-bitowe bez znaku. Nasz obraz wczytany z pliku nie spełnia tych wymogów i jego użycie jako źródła i przeznaczenia spowoduje wystąpienie błędu. Po wykonaniu otrzymujemy: Uzyskany wynik przedstawia drugą pochodną cząstkową zsumowaną w pionie i poziomie. Nie może być traktowany jako obraz, gdyż nim nie jest (występują tam np. wartości ujemne). Dla laplasjanu także istnieją maski, np.
1   1   1   1  1
1   1   1   1  1
1   1  -24  1  1
1   1   1   1  1
1   1   1   1  1
Wykonując ją uzyskamy: Podobnie jak w przypadku Sobela, istnieje kilka masek dla laplasjanu. Chciałem zademonstrować sposób działania splotu, bo być może przyjdzie nam korzystać z naszej lub innej z góry zadanej maski. Sam problem wykonania splotu jest bardziej złożony, niż może się wydawać na pierwszy rzut oka (co zrobić np. z pikselami na krawędziach obrazu?). Jednak mając odpowiednią maskę możemy się zdać na bibliotekę :)

niedziela, 29 marca 2009

OpenCV cz. 3. Otwieranie i zapis obrazu wideo

OpenCV posiada możliwość odczytywania i zapisywania obrazu w wielu popularnych formatach. Funkcjonalność ta udostępniona jest w zestawie HighGui. Dopuszczalne są (podano rozszerzenia plików):bmp, dib, jpeg, jpg, jpe, png, pbm, pgm, ppm, sr, ras, tiff, tif, exr oraz jp2. Funkcje, które pozwalają przeprowadzić te operacje pojawiały się już w poprzednich wpisach. Dla przypomnienia poniżej zaprezentowano przykładowy kawałek kodu:
// wczytanie obrazu w odcieniach szarosci
IplImage*img=cvLoadImage("/home/lukasz/Pulpit/rysowanie.png",CV_LOAD_IMAGE_GRAYSCALE);
// zapisanie obrazu do pliku
cvSaveImage("/home/lukasz/Pulpit/rysowanie.png",img);

Trochę bardziej złożonym zagadnieniem jest odczyt i zapis strumienia wideo. OpenCV pozawala domyślnie na obsługę plików dvix (patrz: źródło). Z obsługą obrazu wideo związana jest analogiczna do IplImage struktura CvCapture. Wyznaję zasadę, że lepszy okomentowany kod niż długie opisy działania ;-) Poniżej przykład pokazujący odczyt i wyświetlanie pliku avi:
// odczytanie pliku avi
CvCapture* vid = cvCreateFileCapture("/home/lukasz/Pulpit/sample.avi");

// tworzymy okno wyswietlajace obraz
cvNamedWindow("plik wideo", 0);

// odczytanie pierwszej klatki - niezbedne do prawidlowego odczytania wlasciwosci pliku
// przy uzyciu funkcji cvGetCaptureProperty
cvQueryFrame(vid);

// odczytujemy z wlasciwosci pliku liczbe klatek na sekunde
double fps =  cvGetCaptureProperty(vid, CV_CAP_PROP_FPS);

// wyliczamy czas potrzebny do odtwarzania pliku z prawidlowa prędkoscia
int odstep_miedzy_klatkami = 1000 / fps;

while (true)
{
// pobranie kolejnej ramki
IplImage* ramka = cvQueryFrame(vid);

// jezeli nie jest pusta to wyswietlamy
if (ramka != 0)
cvShowImage("plik wideo", ramka);
else
break;

// czekamy przez okreslony czas
int c = cvWaitKey(odstep_miedzy_klatkami);

// jezeli nacisnieto klawisz 'k', konczymy wyswietlanie
if (c == 'k')
break;

}

// zwolnienie zasobów
cvDestroyAllWindows();
cvReleaseCapture(&vid);
Kolejnym poruszanym zagadnieniem jest odczyt i zapis obrazu z kamery. Zasadniczo nie różni się on bardzo od obsługi plików dvix. Dalej mamy do czynienia ze strukturą CvCapture. Zmienia się jedynie metoda zwracająca do niej wskaźnik. Przykład:
// pobranie zasobu kamery, parametr mowi o tym ktora kamere wybieramy
// w przypadku gdy w systemie dostepna jest wiecej niz jedna
CvCapture* vid = cvCreateCameraCapture(0);

// tworzymy okno wyswietlajace obraz
cvNamedWindow("plik wideo", CV_WINDOW_AUTOSIZE);

// odczytanie pierwszej klatki - niezbedne do prawidlowego odczytania wlasciwosci pliku
// przy uzyciu funkcji cvGetCaptureProperty
cvQueryFrame(vid);

// ustalamy wartosc fps - najlepiej wieksza niz maksymalna deklarowana przez producenta
// Jezeli wartosc bedzie za mala, obraz bedzie pojawial sie z opoznieniem
double fps =  50;

int odstep_miedzy_klatkami = 1000 / fps;

while (true)
{
// pobranie kolejnej klatki
IplImage* ramka = cvQueryFrame(vid);

// jezeli nie jest pusta to wyswietlamy
if (ramka != 0)
cvShowImage("plik wideo", ramka);
else
break;

// czekamy przez okreslony czas
int c = cvWaitKey(odstep_miedzy_klatkami);

// jezeli nacisnieto klawisz 'k', konczymy wyswietlanie
if (c == 'k')
break;

}

// zwolnienie zasobow
cvDestroyAllWindows();
cvReleaseCapture(&vid);
W powyższych kodach pojawia się funkcja cvQueryFrame. Jak wspomniano, służy ona do pobierania ramek z CvCapture. Ten sam efekt można osiągnąć posługując się kolejno funkcjami cvGrabFrame i cvRetrieveFrame. Pierwsza z nich ściąga ramkę z kamery i pozostawia ją w stanie surowym w pamięci, a druga pobiera taką ramkę i zamienia ją na IplImage.

Ostatnią funkcjonalnością dzisiaj opisaną będzie zapis wideo. Zapisywać możemy kolejne obrazy IplImage. Nie musi być to zatem obraz z kamery czy przetworzony plik wideo. Przykład:

// pobranie zasobu kamery, parametr mowi o tym ktora kamere wybieramy
// w przypadku gdy w systemie dostepna jest wiecej niz jedna
CvCapture* vid = cvCreateCameraCapture(0);

// tworzymy okno wyswietlajace obraz
// jako parametr przekazujemy CV_WINDOW_AUTOSIZE, ktory utworzy okno o wielkości
// odpowiadajacej wyswietlanemu obrazowi
cvNamedWindow("plik wideo", CV_WINDOW_AUTOSIZE);

// odczytanie pierwszej klatki - niezbedne do prawidlowego odczytania wlasciwosci pliku
// przy uzyciu funkcji cvGetCaptureProperty
cvQueryFrame(vid);

// ustalamy wartosc fps
double fps =  30;
int odstep_miedzy_klatkami = 1000 / fps;

// tworzymy strukture zapisujaca klatki do pliku
// kolejno podajemy: sciezke do pliku, format, fps i rozmiar ramki (opcjonalnie czy obraz ma byc w kolorze)
CvVideoWriter* vr = cvCreateVideoWriter("/home/lukasz/Pulpit/zapis.mpg",CV_FOURCC_DEFAULT,fps,cvSize(640,480));

while (true)
{
// pobranie kolejnej klatki
IplImage* ramka = cvQueryFrame(vid);

// jezeli nie jest pusta to wyswietlamy
if (ramka != 0)
{
cvShowImage("plik wideo", ramka);

// zapisujemy ramke do pliku
cvWriteFrame(vr,ramka);
}
else
break;

// czekamy przez okreslony czas
int c = cvWaitKey(odstep_miedzy_klatkami);

// jezeli nacisnięto klawisz 'k', konczymy wyswietlanie
if (c == 'k')
break;

}

// zwolnienie zasobow
cvDestroyAllWindows();
cvReleaseCapture(&vid);
cvReleaseVideoWriter(&vr);

Jakieś wady? Niestety tak. Nie da się ukryć, że kamerki komputerowe mają zmienny (zależny np. od oświetlenia) współczynnik fps. W CvVideoWriter nie zmienimy tego po utowrzeniu, więc film może zachowywać się nieprzewidywalnie w trakcie nagrywania. Problem nie dotyczy oczywiście zapisu wcześniej przygotowanych statycznych obrazów. Jeżeli ktoś posiada lepszy pomysł na synchronizację obrazu z kamery z nagrywaniem to zapraszam do komentarzy ;-)

poniedziałek, 23 lutego 2009

OpenCV cz. 2. Rysujemy i piszemy

Do rysowania prostych figur przygotowano odpowiednie funkcje. Podobnie ma się rzecz z wyświetlaniem tekstu. Aby wyświetlić linię prostą skorzystamy z funkcji cvLine. Jako parametry przyjmuje ona wskaźnik na CvArr, dwa punkty oznaczające końce linii oraz kolor. Ponadto można ustawić kilka parametrów opcjonalnych pozwalających ustawić grubość linii czy sposób jej wyświetlania (np. z antyaliasingiem). Przy ustawionym ROI, linia zostanie wyświetlona tylko w jego obszarze.
// tworzy linię o końcach [1,1] oraz [100,100], koloru białego, o grubości 3 pikseli
cvLine(img,cvPoint(1,1),cvPoint(100,100),cvScalarAll(255.0),3);

Jak widać, jest ona podobna w nazewnictwie do innych funkcji tej biblioteki. Idąc dalej mamy możliwość umieszczania innych obiektów geometrycznych: prostokąta, elipsy itd. Przykładowy kod na końcu notki (aby lepiej zrozumieć działanie funkcji cvEllipse zachęcam do zapoznania się z tym obazkiem). Inne funkcje wysujące (np. wielokąty) działają podobnie, w razie potrzeby odsyłam, a jakże inaczej, do dokumentacji.

Pisanie jest czynnością podobną do rysowania, ale wcześniej należy zainicjować czcionkę.
// zainicjowanie czcionki
CvFont font = cvFont(1.0,1);
cvInitFont(&font,CV_FONT_HERSHEY_SIMPLEX,1.0,1.0);

a same napisy tworzymy funkcją cvPutText.
Poniżej kod na podsumowanie:
#include "cv.h"
#include "cxcore.h"
#include "cxtypes.h"
#include "highgui.h"

/*
* Rysowanie i pisanie
* autor: ratixu.blogspot.com
*/
int main(int argc, char** argv)
{
IplImage* img = cvCreateImage(cvSize(700, 700), IPL_DEPTH_32F, 3);

// tworzenie linii o końcach w punktach [5,1] oraz [200,100]
// o kolorze białym, grubości 5 pkseli z antyaliasingiem
cvLine(img,cvPoint(5,1),cvPoint(200,100),cvScalarAll(255.0),5,CV_AA);

// tworzenie prostokąta o przekątnej o końcach w punktach [5,110]
// oraz [200,210] grubości 4 pksele
cvRectangle(img,cvPoint(5,110),cvPoint(200, 210),cvScalar(122,121,43),4);

// tworzenie elipsy - jedna z metod
CvPoint srodek = cvPoint(200,350);
CvSize osie = cvSize(200,100);
double kat = 360.0;
double katStartowy = 0.0;
double katKoncowy = kat;
CvScalar kolor = cvScalarAll(255.0);
int grubosc = 5;
cvEllipse(img,srodek,osie,kat,katStartowy,katKoncowy,kolor,grubosc);

// tworzenie okręgu o promieniu 75 pikseli i środku w punkcie [200,600]
// oraz grubości 5 pikseli
cvCircle(img,cvPoint(200,600),75,cvScalarAll(255.0),5);

// zainicjowanie czcionki:
// skala rozciągnięcia, przyjumjąc 1 za 100%
double skala = 2.0;
// pochylenie czcionki, przyjmując 1.0 za 45 stopni
double kursywa = 0.2;
CvFont font = cvFont(skala,grubosc);
// włączamy antyalliasing, CV_FONT_XXX to typy dostępnych czcionek
cvInitFont(&font,CV_FONT_HERSHEY_SIMPLEX,skala,skala,kursywa,grubosc,CV_AA);


//podpisujemy figury
cvPutText(img,"Odcinek",cvPoint(300,100),&font,cvScalarAll(255.0));
cvPutText(img,"Prostokat",cvPoint(300,200),&font,cvScalarAll(255.0));
cvPutText(img,"Elipsa",cvPoint(450,350),&font,cvScalarAll(255.0));
cvPutText(img,"Okrag",cvPoint(300,650),&font,cvScalarAll(255.0));

cvNamedWindow("img",0);
cvShowImage("img", img);
while(true)
{
if(cvWaitKey(100) == 'k') break;
}

// zapisujemy wynik do pliku
cvSaveImage("/home/lukasz/Desktop/rysowanie.png",img);
cvDestroyWindow("img");
cvReleaseImage(&img);
return (EXIT_SUCCESS);
}

a tutaj zapisany obraz:

piątek, 13 lutego 2009

OpenCV cz. 1. Podstawy

Dzisiaj będzie trochę o strukturach w OpenCV. Podstawą jest struktura o nazwie CvArr. Jak sama nazwa wskazuje jest to jednowymiarowa tablica przechowująca dane określonego typu. Dalej znajdziemy CvMat czyli tablicę wielowymiarową oraz IplImage który jest odzwierciedleniem obrazu. Struktury wymieniono w takiej kolejności nie bez powodu: można ich generalnie używać jakby istniał schemat dziedziczenia Arr -> Mat -> Image. Sama biblioteka to w większości funkcje napisane w C i kilka klas w C++. Mamy tu zatem do czynienia z klasycznymi strukturami i ciężko mówić o dziedziczeniu obiektowym. Piszę o tym ponieważ w większości funkcji bibliotecznych które przyjmują jako parametr CvArr możemy spokojnie posłać w tym miejscu CvMat lub IplImage i dalej, jeżeli przyjmuje CvMat to przyjmuje także IplImage. Nie dotyczy to jednak metod napisanych samodzielnie... W skład tych struktur, oprócz wskaźnika na dane, wchodzą inne przydatne informacje takie jak liczba kanałów, wysokość, szerokość itp. Poniżej trochę kodu:
// macierz o 30 wierszach i 40 kolumnach, składająca się z elementów 32 bitowych zmiennoprzecinkowych
CvMat* mat = cvCreateMat(30,40,CV_32F);

// utworzenie obrazka o rozdzielczości 800x600, głębi 32 bitowej i 4 kanałach
IplImage* img = cvCreateImage(cvSize(800,600),IPL_DEPTH_32F,4);

// wierna kopia obrazka, macierz posiada analogiczną metodę cvCloneMat
IplImage* img2 = cvCloneImage(img);
CvMat* mat2 = cvCloneMat(mat);

// oczywiście sprzątamy po sobie
cvReleaseImage(&img);
cvReleaseImage(&img2);
cvReleaseMat(&mat);
cvReleaseMat(&mat2);

Kolejnymi strukturami o których warto wspomnieć są: CvSize, CvScalar i CvRect. Pojawiają się one dosyć często do określania parametrów funkcji (jak np. w w/w konstruktorach). CvSize służy do określenia wysokości i szerokości, CvScalar do przetrzymywania 4 wartości typu dobule (np. jako kolor w formacie RGBA) a CvRect do określania prostokątów (wysokość,szerokość,x,y).
// prostokąt o wymiarach 40x30 kórego pozycja startowa (lewy górny róg)
// jest w punkcie [0,0]
CvRect rect = cvRect(0,0,40,30);
// podobne do CvRect ale bez punktu zaczepienia
CvSize size = cvSize(40,30);
// Prosty skalar
CvScalar scal = cvScalar(23.2,34.2,45.7,23.5);
// odpowiada to funkcji cvScalar(0.3,0.3,0.3,0.3);
CvScalar scal2 = cvScalarAll(0.3);

Takich struktur jest jeszcze trochę. W razie problemów najlepiej sięgnąć do dokumentacji i API (znajdziecie je w dziale linki - wizja komputerowa). Pisanie ułatwia oczywiście dobre IDE. Podpowiada one składnię i można szybko zobaczyć jakie parametry posiada funkcja. Wiele struktur ma gotowe funkcje tworzące, które ułatwiają poszukiwania ;-)

Czas wrócić do macierzy i obrazów. Wypadałoby jeszcze wspomnieć jak dostać się do ich elementów. Na początek najlepiej posłużyć się cvGet2D przyjmującym dwie współrzędne i, oczywiście, wskaźnik do CvArr dzięki czemu działa na macierzach i obrazkach. Podobnie przedstawia się ustawianie wartości za pomocą funkcji cvSet2D
// pobranie wartości spod komórki [1,1]
// przyjęte parametry to: wskaźnik na strukturę, współrzędna Y, współrzędna X
CvScalar s1 = cvGet2D(img,1,1);
// działa tak jak powyższa metoda, ale zwraca tylko wartość double
double s2 = cvGetReal2D(mat,1,1);

// ustawianie wartości
// przyjęte parametry to: wskaźnik na strukturę, współrzędna Y, współrzędna X,
// CvScalar z wartością
cvSet2D(mat,1,1,cvScalarAll(0.5));
cvSet2D(img,1,1,,cvScalarAll(0.5));

Oczywiście sami musimy zadbać w tym przypadku czy nie pobieramy danych spoza zakresu. Opisana metoda nie jest najszybszą (można wręcz powiedzieć że najwolnieszją) metodą dostępu to pikseli. Później poznamy szybsze ;-)

Inną użyteczną rzeczą są tzw. ROI (Region of Interest) oraz COI (Color of Interest). Pozwalają one ograniczyć obszar (lub kolor) który jest przetwarzany. Wiele funkcji sprawdza czy podany obraz ma ustawiony ROI i stosuje algorytm tylko na nim. Z COI jest już trochę gorzej ale powiedzmy że także działa :)

// ustawienie ROI na kwadrat o boku 10, zaczynający się w [0,0]
cvSetImageROI(img,cvRect(0,0,10,10));
// ustawienie kanału COI
cvSetImageCOI(img,1);

Podsumowując:
#include "cxtypes.h"
#include "cxcore.h"
#include "highgui.h"

/*
* Manipulowanie danymi
* autor: ratixu.blogspot.com
*/
int main(int argc, char** argv)
{

IplImage* img = cvCreateImage(cvSize(300,300),IPL_DEPTH_32F,3);

for(int i = 0; i < img->width; i++)
for(int j = 0; j < img->height; j++)
{
if(i==j)
cvSet2D(img,i,j,cvScalar(255,0,255,0));
else if (i < j)
cvSet2D(img,i,j,cvScalar(0,255,255,0));
else
cvSet2D(img,i,j,cvScalar(255,255,0,0));
}

cvNamedWindow("okienko", 1);
// metoda ta wyświetla obraz. Sama dostosuje rozmiar okna
cvShowImage("okienko",img);
while(true)
{
if(cvWaitKey(100) == 'q') break;
}
cvDestroyWindow("okienko");
cvReleaseImage(&img);
return (EXIT_SUCCESS);
}

i efekt wywołania: