piątek, 18 listopada 2011

OpenCV + OpenGL

Podpialem kamerke w C++ korzystajac z OpenCV, przyjemnej biblioteki wspomagajacej programowanie zagadnien zwiazanych z widzeniem maszynowym. Pisalem wczesniej o projekcie FaceTrackingu. Po napisaniu programu do konwersji obrazkow z przestrzeni RGB do HSV czas na nastepny krok. Napisalem klase CImageProcessor, ktora wykorzystuje do manipulowania obrazami za pomoca shaderow. Razem z OpenCV pozwala to na przetwarzanie live obrazu z kamerki. :)

Np. konwersja rgb2hsv:



Albo wykrywanie na obrazie fragmentow, ktore przypominaja ludzka skore:



My tu gadu gadu, a kodzik sam sie nie zrobi. :) Glowny plik main.cpp przedstawia sie nastepujaco:

/* v.1.2
 * author: pcygan 30.10.2011
 * purpose: grab camera input and render using opengl
 * in/out: C-STRING[][] -> INT
 */

//TODO CIMAGEPROCESSOR OFFSCREEN RENDERING AND CHAINING
#include  //for cout, cerr...
#include  //for sure that glew.h is before gl.h
#include  //SDL library
#include  //OpenCV library
#include  //OpenCV highgui library
#include "Texture.h" //Texture class for dealing with OpenGL textures
#include "Shader.h" //Shader class for making life with shaders easier
#include "CImageProcessor.h" //CImageProcessor for hiding implementation of rendering.
#include "CEvent.h" //CEvent as base for EventHandler
#include "EventHandler.h" //Handle ESC key to stop the program.

Niezbedne includy dla bibliotek i klas z jakich korzystam, czyli:
i. GLEW - do shaderow itp.
ii. SDL - do obslugi okienek i petli komunikatow.
iii. OpenCV - do przechwytywania obrazu z kamery.
iv. Texture - klasa napisana do obslugi textur OpenGL.
v. Shader - klasa napisana do obslugi shaderow OpenGL.
vi. CImageProcessor - klasa napisana do przetwarzania obrazow na karcie graficznej.
vii. CEvent - interfejs do obslugi zdarzen SDL.
viii. EventHandler - implementacja CEvent.

SDL_Surface* g_pDisplay= 0;
CvCapture* g_pCapture= 0;
IplImage* g_pFrame= 0;
Texture* g_pTexture= 0;
Shader* g_pShader= 0;
CImageProcessor* g_pImgProc= 0;
EventHandler* g_pEventHandler= 0;

int setupSDLAttribs();
void cleanup();

Deklaracja niezbednych zmiennych i funkcji pomocniczych. g_pDisplay jest uchwytem do przestrzeni na ktorej bedzie rysowal OpenGL w okienku. g_pCapture uchwytem do kamery. g_pFrame to obrazek (klatka?) zarejestrowany przez kamere, zawiera informacje o wymiarach, typie przestrzeni kolorow, ulozeniu bitow kolorow w obrazku i wielu innych rzeczach. g_pTexture to opakowana interfejsem textura w OpenGL, korzystajac z tej klasy mozna latwo wczytac obrazek jako texture. g_pShader to opakowany dodatkowym interfejsem shader, ale o nim pozniej. gImgProc to nasz procesor do przetwarzania obrazkow. g_pEventHandler bedzie sprawdzal czy wcisnelismy klawisz ESC i wtedy zakonczy program.

Funkcja setupSDLAttribs() odpowiada za ustawienie atrybutow niezbednych do poprawnej wspolpracy SDL i OpenGL. Natomiast cleanup() wyczysci zaalokowana w trakcie pracy programu pamiec.

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

 /*
  * Set working directory and some SDL attributes.
  */
 gltSetWorkingDirectory(argv[0]);
 if (setupSDLAttribs())
  return -1;

 //Try to open camera.
 g_pCapture= cvCaptureFromCAM(CV_CAP_ANY);
 if (!g_pCapture) {
  fprintf(stderr, "ERROR: Capture is NULL. Program stopped with error: GL_INVALID_OPERATION. cvCaptureFromCAM() failure. \n");
  getchar();
  return -1;
 }

 //Try to capture from opened camera.
 g_pFrame= cvQueryFrame(g_pCapture);
 if (!g_pFrame) {
  fprintf(stderr, "ERROR: Frame is NULL. Program stopped with error: GL_INVALID_OPERATION. cvQueryFrame() failure. \n");
  getchar();
  return -1;
 }


Etap inicjalizacji. Chcemy utworzyc okienko za pomoca SDL, w ktorym bedziemy mogli rysowac korzystajac z OpenGL. W dodatku, chcemy zeby okienko mialo taki sam rozmiar jak obraz zczytywany przez kamerke. Najpierw odpalam setupSDLAttribs() zeby ustawic atrybuty OpenGL w SDL. Nastepnie lopatologicznie odczytujemy rozmiar obrazkow z kamerki poprzez otworzenie kamerki, sciagniecie jednej klatki i odczytanie z niej wymiarow.

//Create new Texture class object.
 g_pTexture= new Texture();
 //Copy captured frame to OpenGL texture via Texture class object.
 g_pTexture->grabIpl(g_pFrame);

Przy okazji wykorzystamy sciagnieta klatke z kamerki do zainicjowania naszej tekstury, ktora z kolei posluzy jako wejscie do klasy CImageProcessor pozniej.

//Set proper SDL flags for video mode.
 GLint SDL_FLAGS = SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_OPENGL;

 //Set video mode- window size same as frame size.
 if ((g_pDisplay = SDL_SetVideoMode(g_pFrame->width, g_pFrame->height, 32, SDL_FLAGS))
   == NULL) {
  std::cerr << "SDL_SetVideoMode fail. Program stopped with error: GL_INVALID_OPERATION." << std::endl;
  return GL_INVALID_OPERATION;
 }

 //Init GLEW library.
 GLenum err = glewInit();
 if (GLEW_OK != err) {
  fprintf(stderr, "ERROR: GLEW initialization error. Error message: %s\n", glewGetErrorString(err));
  return 1;
 }
Wracamy do inicjalizacji - ustawiamy flagi SDL: SDL_HWSURFACE - chcemy wsparcie sprzetowego, SDL_DOUBLEBUF - chcemy wykorzystac podwojny bufor ramki, SDL_OPENGL - chcemy uzyc OpenGL do renderingu. Majac te flagi, przekazujemy je do SDL_SetVideoMode() razem wymiarami obrazu i glebokscia bitow zeby utworzyc nowe okienko.
string sh("shaders/rgb2hsv.glsl.cfg"); //Path to config file for Shader class.
 g_pShader= new Shader(&sh); //Create and load new shader config file.
 g_pImgProc= new CImageProcessor(); //Create new CImageProcessor class object.
 g_pImgProc->set(g_pTexture); //From now on, g_pImgProc will use g_pTexture as input texture.
 g_pImgProc->set(g_pShader); //From now on, g_pImgProc will use g_pShader as process shader.
 g_pEventHandler= new EventHandler(); //Create new SDL Event Handler.
 SDL_Event Event; //Temporary variable for events.
Inicjalizacja srodowiska jest kompletna, zostaja tylko zmienne. Tworzymy nowy obiekt Shadera - przekazujemy do konstruktora sciezke do pliku konfiguracyjnego dla Shadera. Powiedzmy, ze w ten sposob w tle wczytywany jest kod shadera fragmentow i wierzcholkow, kompilowany, linkowany i podpinane sa atrybuty shaderow do programu. Nastepne linijki tworza nowy obiekt klasy CImageProcessor (ktora mozna sobie wyobrazic jako procesor do obrobki obrazow, w bardzo ogolnym pojeciu). Przekazanie wskaznika na teksture do funkcji set wywolywanej na rzecz g_pImgProc powoduje, ze bedzie ona wykorzystywana jako wejscie dla g_pImgProc. Przekazanie wskaznika na shader do funkcji set powoduje ze g_pImgProc bedzie wykonywal dany shader na swoich danych wejsciowych. Ostatecznie otrzymujemy g_pImgProc gotowe do przetworzenia programem g_pShader tekstury g_pTexture.
while (g_pEventHandler->bRunning) {
  /*
   * Use SDL library to detect whether ESCAPE key was down?
   * If it was pressed down, then g_bRunning will be set to false.
   * It will break the loop.
   */
  while (SDL_PollEvent(&Event)) {
   g_pEventHandler->OnEvent(&Event);
  }

  /*
   * Try to capture next frame. End loop if operation fail.
   */
  g_pFrame = cvQueryFrame(g_pCapture);
  if (!g_pFrame) {
   fprintf(stderr, "ERROR: frame is null...\n");
   getchar();
   break;
  }

  /*
   * We need to flip captured frame in X and Y axis using cvFlip with -1 as last argument.
   * Otherwise captured frame will be shown incorrectly.
   */
  cvFlip(g_pFrame, NULL, -1);
  if (!g_pTexture->grabIpl(g_pFrame)) {
   cout << "false" << endl;
   continue;
  }
  /*
   * We use our CImageProcessor class, to process frame with g_pShader (GLSL shader)
   * and display it on the screen.
   */
  g_pImgProc->process();
  SDL_GL_SwapBuffers(); //Swap OpenGL buffers.
 }

Glowna petla programu. Jej pseudokod moglby wygladac nastepujaco: while (running) { while (is event) { handle_event(); } g_pFrame= grabFrameFromCamera(); g_pFrame= flipFrameXYAxis(g_pFrame); g_pImgProc->process(); display(); } Dzialamy dopoki running jest prawdziwe. A dzialanie polega na obsluzeniu lub zignorowaniu wszystkich komunikatow ze srodowiska (wcisniete klawisze, proba zamkniecia okna itp.), zczytaniu obrazu z kamery, zaktualizowaniu tekstury obrazem z kamery, przetworzeniem tekstury za pomoca g_pImgProc i wyswietlenie. Obsluga komunikatow to tylko sprawdzenie czy wcisnieto klawisz ESC, a wtedy ustawienie running na falsz. Calkiem proste. ;)
//Close camera.
 cvReleaseCapture(&g_pCapture);
 //Close frame.
 cvReleaseImage(&g_pFrame);
 //Close SDL display.
 SDL_FreeSurface(g_pDisplay);
 //Close SDL library.
 SDL_Quit();
 //Close OpenGL texture and clean memory allocated by Texture class object.
 g_pTexture->destroy();
 //Close Image Processor and clean it's allocated memory.
 g_pImgProc->destroy();
 //Clean up dynamically allocated memory.
 cleanup();
 return 0;
}
Czyszczenie pamieci, zamkniecie uzywanych zrodel i zakonczenie programu.
int setupSDLAttribs() {
 if (SDL_Init(SDL_INIT_EVERYTHING) < 0) {
  cerr << "Game initializaton error: problem occured "
    << "during SDL initialization." << endl;
  return GL_INVALID_OPERATION;
 }
 //These are all basic memory sizes for how much data OpenGL will store
 //and must be called BEFORE SDL_SetVideoMode(...)
 SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
 SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
 SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
 SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
 //Make sure your SDL_GL_DEPTH_SIZE is a power of two (16, 32 works),
 //otherwise anti-aliasing may not work for you.
 SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
 SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
 SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, 8);
 SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, 8);
 SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, 8);
 SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, 8);
 //SDL_GL_MULTISAMPLEBUFFERS is basically anti-aliasing flag
 SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
 //SDL_GL_MULTISAMPLESAMPLES is how much to anti-alias.
 SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 2);
 return GL_NO_ERROR;
}

void cleanup() {
 delete g_pDisplay;
 delete g_pTexture;
 //Close OpenGL shader and clean memory allocated by Shader class object.
 //It's done via destructor.
 delete g_pShader;
 delete g_pImgProc;
 delete g_pEventHandler;
}
Definicje funkcji pomocniczych. Podsumowanie, i co dalej?. Z pomoca biblioteki OpenCV i OpenGL, w dosyc prosty sposob mozemy w czasie rzeczywistym przetwarzac obrazy otrzymywane z kamery. Korzystajac z wczesniej napisanych kodow (klasy Texture, Shader, CImageProcessor, CEvent) staje sie to jeszcze prostsze. A jakie perspektywy na przyszlosc? Umozliwienie laczenia obiektow CImageProcessor w lancuchy, zeby w bardziej zaawansowany sposob manipulowac na obrazie z kamery - i ostatecznie sledzic twarz.
Link to complete source. Libraries needed: GL, GLEW, GLTools, SDL, cv, highgui, cxcore.





wtorek, 15 listopada 2011

Matlab - LZW - kompresja i dekompresja.

Napiszemy w Matlabie kompresje i dekompresje obrazka algorytmem LZW. Takie bylo zadanie na zajeciach. ;)

Wszystkie pliki zrodlowe, troche zabalaganione, znajduja sie tutaj:
http://dl.dropbox.com/u/2545858/lzw.zip

Cel.
Ogolna idea naszej dzialalnosci, napiszmy funkcje im2fd(), ktora musi:
-wczytac obrazek w odcieniach szarosci z pliku i zapamietac jego wymiary,
-przeksztalcic z macierzy odcieni szarosci na wektor,
-przeksztalcic z wektora odcieni szarosci na wektor znakow 8-bit char,
-skompresowac wektor znakow char algorytmem lzw,
-utworzyc plik do ktorego zapisze rozmiary obrazka i otrzymany kod z kompresji lzw.

Skoro bedziemy mieli funkcje im2fd, przyda sie tez fd2im(), ktora musi:
-wczytac z pliku ktory jest efektem dzialania funkcji im2fd rozmiar obrazka i kodo z kompresji lzw,
-zdekodowac kod z kompresji lzw na wektor znakow char,
-przeksztalcic z wektora znakow char na wektor odcieni szarosci,
-przeksztalcic z wektora odcieni szarosci na macierz dwuwymiarowa korzystajac z wczytanych wymiarow obrazka.
-zapisac otrzymana macierz odcienia szarosci jako obraz do pliku.

Cel jest jasny i prosty.

Plan.

Zaprojektujmy w takim razie funkcje im2fd:

void im2fd(string imagefile, string output) {
IMAGE= imageread(imagefile); %wczytac obrazek
SIZE= size(IMAGE); %wczytac jego rozmiary
IMAGE= m2v(IMAGE); %macierz -> wektor
IMAGE= int2char(IMAGE); %konwesja na wetkor char
CODE= lzw_encode(IMAGE); %kompresja
TOFILE= vector_concatenate(SIZE,CODE); %przygotowanie danych do zapisu: polaczenie wektora rozmiaru obrazka z wektorem kodu z kompresji
filewrite(output,TOFILE); %zapisanie do pliku output
}

Rozbilismy im2fd na kroki postepowania i kazdemu przypisalismy funkcje. Przerobienie takiego ideowego pseudokodu na dzialajacy kod w Matlabie, jest raczej banalne:

%pcygan 09.11.2011
% in -> out: str, str -> void
% purpose: compress imagefile using lzw algorithm and write generated code to output text file

function im2fd(imagefile,output)
disp(['Loading image: ' imagefile]);
IMAGE= imread(imagefile);  %wczytac obrazek
PREIMAGE= IMAGE;
disp('Reading image size.');
[rows_ cols_]= size(IMAGE); %wczytac jego rozmiary
disp(['Image size: ' num2str(rows_) 'x' num2str(cols_)]);
disp('Image vectorization.');
IMAGE= IMAGE(:)'; %macierz -> wektor
[o p]= size(IMAGE);
disp(['Data vector size is: ' num2str(o) 'x' num2str(p)]);
disp(['Max value: ' num2str(double(max(IMAGE))) ', min value: ' num2str(double(min(IMAGE)))]);
disp('Converting int2char');
IMAGE= char(IMAGE); %konwesja na wetkor char
disp('Coding image.'); 
CODE= lzw_encode(IMAGE); %kompresja
disp(['Code size' num2str(size(CODE))]);
disp('Code generated.');
disp(['Saving to file ' output '.']);
FILE= fopen(output,'w');
%przygotowanie danych do zapisu: polaczenie wektora rozmiaru obrazka z wektorem kodu z kompresji + zapisanie do pliku
fprintf(FILE,num2str([rows_ cols_ double(CODE)]));  
fclose(FILE);
disp('Save ok!');
imshow(PREIMAGE);
end

Bedziemy schludni i dodamy odrobine komentarzy, zeby po czasie gdy wrocimy do kodu, bylo latwiej go ogarnac. Ponadto dopisalismy troche wypisywania wiadomosci na konsole. :) Wszystkie funkcje dostepne sa w Matlabie, oprocz lzw_encode, ktora napiszemy sami.

lzw_encode
Jak mozemy sie dowiedziec z Wikipedii, pseudokod algorytmu kodowania LZW przedstawia sie nastepujaco:
1. Wypełnij słownik alfabetem źródła informacji.
2. c := pierwszy symbol wejściowy
3. Dopóki są dane na wejściu:
   Wczytaj znak s.
   Jeżeli ciąg c + s znajduje się w słowniku, 
      przedłuż ciąg c, tj. c := c + s
   Jeśli ciągu c + s nie ma w słowniku, wówczas:
      wypisz kod dla c (c znajduje się w słowniku)
      dodaj ciąg c + s do słownika
      przypisz c := s.
4. Na końcu wypisz na wyjście kod związany c.

W prosty sposob zaimplementujemy to w Matlabie, jako zapisanie (niemal) wprost pseudokodu w kod:

%pcygan 11.2011
%in->out: char vector -> int vector
%purpose: compress string(char vector) DATA using lzw algorithm and save compressed code in CODE (int vector)
%example:
%octave:33> lzw_encode('abrakadabra!')
%ans =
%
%    98    99   115    98   108    98   101   257   259    34
%

function CODE= lzw_encode(DATA)
    DICT= lzw_initDict();
    m= length(DATA);
    c= DATA(1); %char
    CODE= [];
    %TODO HANDLE 1-ELEMENT OR 2-ELEMENT DATA
    for i= 2:m
        %get s char
        s= DATA(i); %char
        %if c + s is in dict
        if lzw_findInDict(DICT,[c s])
            c= [c s];
        else
            CODE= [CODE lzw_findInDict(DICT,c)];
            c= [c s];
            DICT= [DICT {c}];
            c= s;
        end
    end
    CODE= [CODE lzw_findInDict(DICT,c)];
end

Pozostaja dwie funkcje do zdefiniowania:
-lzw_initDict(), odpowiedzialna za inicjalizacje slownika.
-lzw_findInDict(), odpowiedzialna za wyszukiwanie stringu w slowniku i zwracanie jego indeksu (badz 0 w przypadku gdy nie ma w slowniku).

Inicjalizacja slownika polega na wypelnieniu go alfabetem danych. W naszym przypadku, alfabetem danych jest zasieg 8-bitowej zmiennej char, poniewaz taki jest nasz Cel. Daje nam to 256 mozliwych znakow. Kod w Matlabie jest krotki i prosty, z jednym malym 'ale':

%pcygan 11.2011
%in->out: void->char vector
%purpose: create 1:256 char table containing all possible char values

function DICT= lzw_initDict()
    DICT= {0:255};
    for i=1:256
        DICT(i)= {char(i-1)};
    end
    %disp(DICT)
end

Ale polega na sposobie w jakim przechowujemy slownik. Przechowujemy jakby wskazniki na dane, zamiast samych danych - dlatego ciagi znakow w slowniku moga miec rozna dlugosc, co jest konieczne zeby algorytm zadzialal. Zwroc uwage na klamry '{' i '}' zamiast '[' i ']' w DICT.

Chemy, zeby lzw_findInDict(dict,str) zwrocila indeks wystapienia stringu str w slowniku dict lub 0 w przypadku, gdy nie wystepuje. Szukanie najprosciej zrobic jako porownywanie kazdego elementu slownika z szukanym stringiem i zwroceniem wartosci indeksu w razie sukcesu:

%pcygan 11.2011
%in->out: vector of strings, string->integer
%purpose: find whether string STR(char vector) is in dictionary(strings vector) DICT, if is, return it's index, if is not, return 0

function INDEX= lzw_findInDict(DICT,STR)
    INDEX= 0;
    [n m]= size(DICT);
    for i=1:m
        if strcmp(STR,DICT(i))
            INDEX= i;
            return;
        end
    end
end

Mamy teraz wszystko co jest potrzebne zeby nasza funkcja im2fd zadzialala. :)

fd2im
Teraz zrealizujemy drugi cel, jakim jest funkcja odwrotna do im2fd. Postepujemy analogicznie jak poprzednio - najpierw plan (ktory pomine), potem implementacja glownej funkcji fd2im, nastepnie implementacja funkcji 'skladowych'.

%pcygan 09.11.2011
% in -> out: str -> void
% purpose: read output lzw_file generated using im2fd function and create image

function fd2im(lzw_file)
disp(['Opening lzw .txt file: ' lzw_file '.']);
FILE= fopen(lzw_file);
disp('Copying data to memory.');
code= str2num(fread(FILE, '*char')');
disp('Closing file.');
fclose(FILE);
disp('File closed.');
rows_= code(1);
cols_= code(2);
disp(['Image size is: ' num2str(rows_) 'x' num2str(cols_)]);
[m n]= size(code);
code= code(3:n);
[m n]= size(code);
disp(['Code size is: ' num2str(m) 'x' num2str(n)]);
data= double(lzw_decode(code));
[o p]= size(data);
disp(['Data vector size is: ' num2str(o) 'x' num2str(p)]);
disp('Recovering matrix from vector by image size.');
data= v2m(data,rows_,cols_);
[r s]= size(data);
disp(['Data size is: ' num2str(r) 'x' num2str(s)]);
imshow(data,[0,255]);
disp(['Decompressed image size is: ' num2str(o*p) ', should be: ' num2str(rows_*cols_) '.']);
end

fd2im dziala odwrotnie jak im2fd, wiec nie ma sie tu nad czym zbytnio rozwodzic. Wyjasnienia wymagaja tylko dwie funkcje: v2m i lzw_decode. v2m jest banalne, poniewaz zamienia wektor w macierz:

%%
%AUTHOR 
%%
% pcygan 2011.10.28

%%
%DECLARATION    INPUT -> OUTPUT
%%
% VECTOR, ROWS_, COLS_ -> MATRIX[ROWS_,COLS_]

%%
%PURPOSE
%%
% CREATE MATRIX X EQUAL TO MATRIX M FROM VECTOR V, 
% WHEN VECTOR V WAS CREATED FROM MATRIX M: V= M(:)
% THIS FUNCTION REVERSE OPERATION M(:)
% V= M(:), X= v2m(V,M_rows,M_columns); 
% X == M -> true, after MATRIX X IS EQUAL TO MATRIX M.

%%
%EXAMPLE
%%
% $in$ F= [1 2 3 4; 5 6 7 8]
% $out$
% F =
%
%   1   2   3   4
%   5   6   7   8
% $in$ [rows_ cols_]= size(F)
% $out$
%   rows_ =  2
%   cols_ =  4
% $in$ F= F(:)
% $out$
%
% F =
%
%   1
%   5
%   2
%   6
%   3
%   7
%   4
%   8
% $in$ v2m(F,2,4)
% $out$
% ans =
%
%   1   2   3   4
%   5   6   7   8

function MATRIX= v2m(VECTOR,r,c)
    MATRIX= ones(r,c); %preallocate memory for better performance
    m= length(VECTOR); %remember VECTOR's number of rows
    i= 0; %set starting variables
    j= 1;
    for it=1:m %iterate through VECTOR
        i= i+1; %increment row pointer
        if i > r %if row pointer is greater restored matrix* then number of rows
            i= 1; %then reset row pointer to first row
        end
        %copy data from VECTOR(it) to proper position in MATRIX
        MATRIX(i,j)= VECTOR(it);
        if mod(it,r) == 0 %this mean we went through restored matrix column
            j= j+1; %so increment column pointer
        end
    end
end

% *restored matrix is M in %EXAMPLE

Troche duzo kodu, a dowiedzialem sie ostatnio, ze nie musialem deklarowac nowej funkcji, bo wystarczylo zamiast niej napisac (:

MATRIX(:)= VECTOR;

Natomiast lzw_decode to juz inna bajka:

%pcygan 11.2011
%in->out: int vector->char vector
%purpose: decode char string(char vector) DATA from CODE (int vector). we assume CODE was generated using LZW compression algorithm
%example:
%octave:34> lzw_decode(lzw_encode('abrakadabra!'))
%ans = 
%
% abrakadabra!
%

function DATA= lzw_decode(CODE)
    DICT= lzw_initDict();
    pk= CODE(1);
    k= 1;
    [n m]= size(CODE);
    DATA= DICT{pk};
    for i= 2:m
        %wczytaj kod k
        k= CODE(i);
        %ciag skojarzony z poprzednim kodem
        pc= DICT{pk};
        %jezeli slowo o kodzie k jest w slowniku
        [o p]= size(DICT);
        if k <= p
            tmp= DICT{1,k};
            pc= [pc tmp(1)]; %dodaj do slownika pc + slownik[k][0]
            DICT= [DICT {pc}];
            DATA= [DATA tmp]; %na wyjsciu wypisz slownik[k]
        else
            pc= [pc pc(1)];
            DICT= [DICT {pc}];
  DATA= [DATA pc];
        end
    pk= k;
    end
end

wtorek, 1 listopada 2011

OpenCV - niezly kombajn!

Odnoszac sie do poprzedniego postu, poszperalem w sieci troche w poszukiwaniu cross-platform API do obslugi kamerki i natknalem sie na OpenCV. Obsluguje ona wiekszosc, jezeli nie wszystkie ficzery jakie potrzebuje w swoim programie do sledzenia twarzy. Co znaczy, ze jezeli bym sie uparl, nie musialbym samemu nic napisac. :D W kazdym razie - rzeczy wymaga glebszej analizy, haha! :)