Rafał Petryniak

Aplikacja interaktywna w OpenCV reagującą na ruch

2012-01-09T22:54:00.001+01:00

Kurs programowania systemów interaktywnych z wykorzystaniem OpenCV, który jakiś czas temu rozpocząłem na łamach tego bloga (patrz: etykieta OpenCV), byłby niekompletny, gdyby zabrakło opisu interakcji ruchowej. Obsługa klawiatury i myszki są oczywiście ważne, ale już na nikim nie robią szczególnego wrażenia. OpenCV jak wiadomo jest przeznaczony do śledzenia i analizy ruchu i to jest jego główna siła.

W dzisiejszym wpisie zostanie pokazane jak dodać kolejną warstwę interakcji poprzez analizę i detekcję ruchu. Wpis ten będzie naturalnym rozszerzeniem przykładów omawianych wcześniej, dlatego zachęcam do ich wcześniejszej analizy. Szczególnie istotne są dwa z nich:

OpenCV - obsługa klawiatury i myszki [16 maj 2011]
Detekcja ruchu w OpenCV - porównanie klatek [6 kwi 2011]

Dobra wiadomość jest taka, że dzięki wprowadzeniu obiektowego szkieletu aplikacji, rozszerzenie aplikacji o interakcję ruchową będzie niezwykle proste i nie będzie wymagało wielu zmian w kodzie. Dla przykładu kod kulki praktycznie pozostaje bez zmian. Logika aplikacji jest również taka sama jak dla poprzedniego przykładu.

Pierwszą rzeczą, którą należy zrobić jest dodanie kilku pomocniczych zmiennych, które będą zawierać pośrednie etapu przetwarzania obrazu.

// plik: interactive_app_tutorial-MainApp.h
class MainApp
{
private:
  Mat cam_frame, img_gray, img_first, img_prev, img_diff, img_bin;

Następnie należy rozszerzyć funkcję update klasy MainApp o sprawdzanie na ile każda z kulek pokrywa się z fragmentami obrazu binarnego, gdzie został wykryty ruch.

// plik: interactive_app_tutorial-MainApp.cpp
for (int k = 0; k < myBall.size(); k++) {
  movementAmount = 0;
  ball_dim = myBall[k].getDim();
  ball_x   = myBall[k].getX();
  ball_y   = myBall[k].getY();
  
  for (int i=(-1*ball_dim); i<ball_dim; i++)
    for (int j=(-1*ball_dim); j<ball_dim; j++)
      if ( dist(0,0,i,j) < ball_dim ) {          
        canvas_ind_x = ball_x + i;
        canvas_ind_y = ball_y + j;
        
        if ( canvas_ind_x<=0 || canvas_ind_y<=0 || 
             canvas_ind_x>CANVAS_WIDTH || canvas_ind_y>CANVAS_HEIGHT) 
          continue; 
        
        if ( img_bin.at<uchar>(canvas_ind_y,canvas_ind_x) > 30) {
          movementAmount++;
        }
      }
      
      if (movementAmount > max_motion_points)
        myBall[k].decrementLives();
      else
        if (!pauseBallsMove) myBall[k].update();
}

W powyższym przykładzie widać, że jeśli więcej niż 30 pikseli leży na masce (zmienna img_bin) wskazującej miejsce detekcji ruchu to możemy uznać, że kulka została "dotknięta". Oczywiście można zmienić tą wartość na inną, lub nawet ustalać ją w zależności od wielkości elementu zbijanego. To prawdopodobnie byłoby lepsze rozwiązanie od obecnego, ale jak widać na poniższym filmie, obecne również daje radę :-)

Oglądaj film w rozdzielczości HD na pełnym ekranie.

Zbiór przykładowych aplikacji Qt Quick

2011-08-08T16:12:00.001+02:00

Jak widać, patrząc na moje ostatnie wpisy na blogu - a raczej ich brak :-), zrobiłem sobie dłuższą przerwę od MeeGo i Qt. Nie wynika to bynajmniej z utraty zainteresowania tymi dwoma technologiami, ale raczej z chronicznego braku czasu. Po rozpoczętej na początku tego roku serii wpisów dotyczących systemów mobilnych, nadszedł czas na zapoznanie się z mocno ostatnio promowanym Qt Quick. Nie będę jednak zbyt wiele pisał o tej technologii, bo przyznam szczerze, że nie wiele się na niej znam. Po przerobieniu jednego prostego kursu, nie będę udawał, że jestem ekspertem w tej dziedzinie :-).

Pierwsze przymiarki do Qt Quick i QMLa rozpocząłem od przeszukania Internetu za gotowymi przykładami. Najwięcej jest ich oczywiście na stronie Nokii i tam polecam zajrzeć. Niestety jest mały bałagan w ich lokalizacji i mimo prób ich gromadzenia na Wiki Qt lub też w Portalu dla Developerów Noki ciągle znajdują się one w kilku miejscach. Udało mi się nad tym zapanować tworząc odpowiednie kategorie w moich Ulubionych. Oczywiście udostępniam je również Wam.

Przykłady dołączone do oficjalnej dokumentacji:

Calculator
Flickr Mobile
Minehunt
Photo Viewer
RSS News
Same Game
Snake
Twitter Mobile
QML Web Browser
Więcej przykładów na stronie dokumentacji.

Przykłady opisane na Wiki Qt (link):

Przykłady z portalu dla developerów Noki:

Oficjalnie wspierane (link):

Rozwijane przez społeczność (link) - wybrałem te, które wizualnie zrobiły na mnie największe wrażenie:

ICT Academy Hub

Egg Hunter
Submariner
Submariner

Wiki dla społeczności Noki (link):

Inne przykłady znalezione na stronie Qt:

Kursy i poradniki pokazujące jak coś zrobić:

Repozytoria:

Przykłady i projekty społeczności:

Canola Media Center

Patrząc na tą listę nie wiem czy udało mi się znaleźć dużo, czy mało przykładów aplikacji zaimplementowanych z użyciem Qt Quick. Dla osób raczkujących w tej technologi, tak jak ja, jest ich jednak w zupełności wystarczająco na start.

"Generative art" teraz w moim plecaku

2011-07-25T23:32:00.000+02:00

Nareszcie przyszła druga zamówione przez mnie książka w Amazon. Czekałem na nią długo - ok. 2 miesiące. Na szczęście w tym czasie spokojnie mogłem przejrzeć "Form+Code".

Pierwsze moje wrażenie po otwarciu "Generative art" było takie: "to nie tak miało być! spodziewałem się czegoś innego!". Moje lekkie rozczarowanie wynikało po prostu stąd, że po obejrzeniu przykładowego rozdziału, który jest dostępny na stronie autora książki Matta Pearsona (podaje link, aby było szybciej: Rozdział 1) spodziewałem się w pełni ilustrowanej książki, coś w rodzaju katalogu projektów i opisu dobrych praktyk.

Na szczęście, to było tylko pierwsze i jak się okazało powierzchowne wrażenie. No bo jak budować opinie na temat książki przeglądając jedynie parę stron. Wystarczy poświecić jej trochę więcej czasu, aby dostrzec, że jest ona pełna opisów dobrych praktyk, zawiera naprawdę sporo wartościowych przykładów i pokazuje krok po kroku coraz bardziej zaawansowane techniki generowania ilustracji komputerowych.

Więcej nie zdradzam. Zachęcam do przejrzenia :-)

I jeszcze jedna dobra wiadomość: po zakupie książki ebooka dostajemy gratis :-D.

Google Matrix

2011-07-12T23:58:00.001+02:00

Wszystko wskazuje na to, że Google wie o mnie wszystko. Nie tylko to z kim koresponduję, to o czym wtedy piszę, to czego szukam w Internecie i komu robię fotki wakacjach.

Wie również z jakiego systemu korzystam i (o zgrozo) z jakiej przeglądarki nie korzystam - a wg Google powinienem ;-)

Najlepszym przykładem tego o czym właśnie piszę, może być reklama jaką dzisiaj zaserwował mi Google w swoim czytniku RSSów:

Czyżby nadchodził Google Matrix?

"Form+Code" w mojej biblioteczce

2011-06-13T09:38:00.000+02:00

Po kilku tygodniach czekania w końcu doszła do mnie nowa książka. "Form+Code" zamówiłem jakiś czas temu przez Amazon razem z innym tytułem, o którym napiszę jaki mi go prześlą (ma być pod koniec czerwca, bo na razie nie mają go na stanie). Książka, która do mnie dotarła kilka dni temu, tak jak przewidywałem, nie jest za bardzo techniczno - informatyczna. Zawiera ona za to wiele opisów wdrożeń i instalacji światowej czołówki artystów zajmujących się sztuką generowaną (Generative Art) i kreatywnym kodowaniem (Creative Coding). Na szczęści książka zawiera również algorytmiczny opis kilkunastu ciekawych efektów, dzięki czemu można trochę podejrzeć jakich metod i narzędzi używają najlepsi w branży :-)

Bardzo cennym uzupełnieniem książki jest również obszerna strona internetowa jej poświęcona. Można na niej zobaczyć niektóre strony z książki - jest ona głównie ilustrowana więc jest co oglądać, przejrzeć spis treści, a co najważniejsze pobrać przykładowe programy dołączone do książki.

Polecam!

OpenCV - obsługa klawiatury i myszki

2011-05-16T22:59:00.002+02:00

Pełny kod źródłowy

Kontynuując rozpoczęty ponad miesiąc temu cykl wpisów dotyczących pisania aplikacji interaktywnych nadszedł czas na wprowadzenie kolejnego elementu do wcześniej zaproponowanego szablonu. Dzisiaj zostanie omówiona zasadnicza kwestia pozwalająca na wprowadzenie przynajmniej podstawowej interakcji do programu: obsługa klawiatury i myszy. Oczywiście dla każdego programisty naturalnym jest to, że program z definicji coś takiego posiada, tzn. że możemy klikać na przyciski, przesuwać suwaki, wybierać zakładki i wpisywać tekst do formularzy. Jednak w przypadku OpenCV, należy pamiętać, że jest to biblioteka głównie do przetwarzania obrazu i chociaż obsługa klawiatury i myszy jest dostępna, to nie jest ona widoczna na pierwszy rzut oka.

W tym wpisie poza omówieniem mechanizmów API do obsługi klawiatury i myszy, zostanie dodatkowo rozszerzony omawiany we wcześniejszych wpisach przykład z kulkami. Zachęcam również do samodzielnych testów i modyfikacji udostępnionego kodu.

Obsługa zdarzeń myszy

Myszka w OpenCV jest w pełni obsługiwana za pomocą modułu highgui, który jest również odpowiedzialny za wyświetlanie obrazków. Obsługę taką możemy włączyć za pomocą funkcji cvSetMouseCallback, w której przywiązujemy do danego okienka funkcję obsługującą zdarzenia myszy. Dodatkowo, ponieważ jest to funkcja globalna, a nie lokalna naszej klasy MainApp, należy do niej przekazać wskaźnik do aktualnego obiektu. Dzięki temu będziemy mieć dostęp do jego funkcji składowych. Podsumowując: należy dodać do funkcji MainApp::run() następującą linijkę:

cvSetMouseCallback(win_canvas, mouse_callback, this);

Drugi parametr tej funkcji jest wskaźnikiem do właściwej funkcji obsługującej myszkę. Funkcja ta odbiera nie tylko zdarzenie jakie wystąpiło (naciśnięcie i zwolnienie klawisza, podwójny klik, przesunięcie myszki), ale również bieżące współrzędne wskaźnika myszki.

void mouse_callback(int event, int x, int y, int flags, void* param)
{
  MainApp *app = ((MainApp *)param);
  switch (event) {
    case  CV_EVENT_LBUTTONDBLCLK:
      app->mouseDoubleClick(x,y,APP_MOUSE_LEFT);   break;
    case  CV_EVENT_RBUTTONDBLCLK:
      app->mouseDoubleClick(x,y,APP_MOUSE_RIGHT);  break;
    case  CV_EVENT_MBUTTONDBLCLK:
      app->mouseDoubleClick(x,y,APP_MOUSE_MIDDLE); break;
    case  CV_EVENT_LBUTTONDOWN:
      app->mousePressed(x,y,APP_MOUSE_LEFT);       break;
    case  CV_EVENT_RBUTTONDOWN:
      app->mousePressed(x,y,APP_MOUSE_RIGHT);      break;
    case  CV_EVENT_MBUTTONDOWN:
      app->mousePressed(x,y,APP_MOUSE_MIDDLE);     break;
    case  CV_EVENT_LBUTTONUP:
      app->mouseReleased(x,y,APP_MOUSE_LEFT);      break;
    case  CV_EVENT_RBUTTONUP:
      app->mouseReleased(x,y,APP_MOUSE_RIGHT);     break;
    case  CV_EVENT_MBUTTONUP:
      app->mouseReleased(x,y,APP_MOUSE_MIDDLE);    break;
    case  CV_EVENT_MOUSEMOVE:
      app->mouseMoved(x,y);                        break;
  }
}

Oczywiście w tym miejscu można już zaprogramować co ma się wydarzyć po wystąpieniu konkretnego zdarzenia, ale proponuję przekazać podejmowanie tej decyzji do wnętrza klasy, do odpowiednich funkcji. Oto one:

void MainApp::mouseMoved(int mouseX, int mouseY ){
  if (m_mousePressed) mouseDragged(mouseX, mouseY);
}

void MainApp::mouseDragged(int mouseX, int mouseY){
}

void MainApp::mousePressed(int mouseX, int mouseY, int button){
  m_mousePressed = true;
}

void MainApp::mouseReleased(int mouseX, int mouseY, int button){
  m_mousePressed = false;
}

void MainApp::mouseDoubleClick(int mouseX, int mouseY, int button){
}

Jak widać nie ma tutaj nic szczególnego - kilka pustych funkcji. Czekają one po prostu na oprogramowanie przez użytkownika, a ich treść zależy od tego co w danym momencie chcemy osiągnąć. Na końcu wpisu zostanie podany przykład jak za pomocą kliknięcia myszką w element usunąć go z ekranu, więc polecam doczytać do końca :-).

Obsługa zdarzeń klawiatury

Z klawiaturą mamy już dużo łatwiej, aniżeli z myszką. Można zupełnie obejść się bez dodatkowych funkcji i wszystko zaprogramować w ciele funkcji, która zawiera pętlę główną programu. Wystarczy w tym celu skorzystać z funkcji cvWaitKey(int), aby sprawdzić czy użytkownik wcisnął jakiś klawisz.

int key;
while(1) {
  key = cvWaitKey(DELAY);  // wait for keyboard input
  if (key == 'q') break;   // 'q' pressed, quit the program
  if (key != -1 ) keyPressed(key);

  update();
  draw();
  
  imshow(win_canvas, canvas);
}

Podejście to pomimo tego, że poprawne, może niepotrzebnie wprowadzić nam zamieszanie nadmiarem kodu w ważnym miejscu programu. Polecam zatem wprowadzić dodatkową funkcję, która będzie zajmowała się wyłącznie reagowaniem na zdarzenia klawiatury. Jej deklaracja jest następująca:

void MainApp::keyPressed(int key){

  switch (key){
    case ' ':
      pauseBallsMove = !pauseBallsMove;
      break;
  }
}

Patrząc na tą funkcję widać, że została zdefiniowana akcja, która wydarzy się po wciśnięciu przez użytkownika spacji. Nie dzieje się tutaj nic więcej, aniżeli prosta negacja zmiennej logicznej pauseBallsMove. Zmienna ta może się przydać np. do zatrzymania ruchu elementów w naszym przykładowym programie:

MainApp::update()

if (!pauseBallsMove) {
  for (int i = 0; i < myBall.size(); i++) {
    myBall[i].update();
  }
}

Przykładowa aplikacja

A teraz obiecany przykład :-) Nie zawiera on szczególnie wiele kodu, ale efekt jaki pozwala osiągnąć wydaje się całkiem interesujący. Na początek polecam dodać dodatkowe polecenia obsługujące zdarzenie naciśnięcia klawisza 'a' i 'd'. Naciśniecie pierwszej literki będzie powodować dodanie kolejnych kulek na ekranie, natomiast naciśnięcie drugiej zmniejszenie ich liczny.

case 'a':
  myBall.push_back( Ball(&canvas) );
  break;
case 'd':
  if (myBall.size()>=1) myBall.pop_back();
  break;

Kolejną zmianą jaką można wprowadzić jest dodanie kilku linii kodu, reagujących na klikniecie myszką. Uzupełniamy ciało funkcji mousePressed następującym kodem:

for(int i=0; i < myBall.size(); i++) {
  if(myBall[i].checkMouseOver(mouseX, mouseY)) {
    myBall[i].decrementLives();

    if(myBall[i].isEndLive()) myBall.erase(myBall.begin()+i);
  }
}

Teraz jeszcze wystarczy dodać kilka nowych funkcji do klasy Ball:

bool Ball::checkMouseOver(int _mouseX, int _mouseY) {
  bool mouseIsOver = false;

  if ( dist(_mouseX,_mouseY,x,y) < dim ) mouseIsOver = true;

  return mouseIsOver;
}

void Ball::decrementLives() {
  lives--;
}

bool Ball::isEndLive() {
  return (lives <= 0);
}

i chyba nie trudno się domyślić jaki w ten sposób efekt możemy uzyskać :-)

Dla osób zniecierpliwionych lub takich, które nie mają czasu na samodzielną kompilację przykładu, przygotowałem krótki filmik pokazujący efekty wprowadzenia obsługi klawiatury i myszki do omawianej aplikacji:

Oglądaj film w rozdzielczości HD na pełnym ekranie.

Repozytorium dla przykładów OpenCV na GitHub

2011-04-19T09:19:00.000+02:00

W ostatnim czasie na blogu pojawiło się kilka wpisów o OpenCV. Wiele z nich zawierało przykładowy kod źródłowy, który wklejałem we fragmentach, aby nie wydłużać samych postów. Były to głównie kluczowe fragmenty opisywanych programów i nie zawierały one najczęściej początku i końca pliku. Wiem, że nie jest to żaden kłopot dla osób, które miały do czynienia z OpenCV, ale dla początkującego użytkownika może to być mały problem. Łatwo przecież zrobić drobny błąd, literówkę lub coś przeoczyć, a trudniej to później znaleźć. W związku z tym utworzyłem publiczne repozytorium kodu źródłowego GitHub, do którego wypchnąłem (push - w terminologii Git) opracowane do tej pory przykłady. Do repozytorium można przejść klikając w poniższy obrazek.

Poprawiony szkielet aplikacji interaktywnej dla OpenCV

2011-04-11T23:18:00.003+02:00

Pełny kod źródłowy

Kilka dni temu zaproponowałem na tym blogu obiektowy szkielet aplikacji interaktywnej dla OpenCV. W dzisiejszym wpisie chciałbym pokazać jak można zrobić to jeszcze lepiej, aby kod był nie tylko bardziej obiektowy, ale również miał lepiej zorganizowaną strukturę. Pomimo tego, że przedstawiony tam schemat aplikacji całkiem nieźle się sprawdza, a kod jest w miarę czytelny, ma on kilka wad i usterek, które zapewne niejeden zaawansowany programista C++ szybko mógłby wytknąć. Oto dwie z nich:

Cały kod programu został umieszczony w jednym pliku. Dla małych projektów jest to w miarę dobre rozwiązanie, jednak przy większych aplikacjach może być uciążliwe. Umieszczanie całego kodu w jednym pliku łamie również powszechnie stosowaną zasadę umieszczania każdej klasy w osobnym pliku. Inną powszechnie znaną praktyką, która nie została tam zastosowana, jest rozdział deklaracji klasy od jej ciała i umieszczenie ich osobno w pliku nagłówkowym (*.h) i w pliku z implementacją funkcji (*.cpp).
Trudno nazwać przedstawiony w poprzednim wpisie szkielet za w pełni obiektowy, jeśli znajduje się tam jedna klasa, która zawiera całą funkcjonalność aplikacji. Szczególnie problem jest widoczny w braku osobnej reprezentacji obiektowej dla znajdujących się tam kulek. Problem ten nie jest szczególnie zauważalny w przypadku istnienia jednej kulki, ale jest już odczuwalny w przypadku ich większej ilości. Wystarczy spojrzeć na funkcję MainApp::update() i spróbować sobie wyobrazić, jak mogłaby ona wyglądać, jeśli trzeba by było zarządzać ruchem i rysowaniem np. 10 kulek. Widać wyraźnie, że coś jest tutaj nie tak i wręcz konieczne wydaje się rozszerzenie modelu obiektowego własnie o te obiekty, które są rysowane na ekranie, a które mają w miarę niezależny schemat poruszania się.

Patrząc na te problemy postanowiłem szybko wprowadzić niezbędne poprawki, aby wyeliminować opisane niedogodności. Z jednego pliku powstało ich sześć. Dodatkowo utworzyłem klasę Ball reprezentująca ruch i wygląd kulek. Pozwoliło mi to na wprowadzenie łatwej personalizacji dla każdej kulki z osobna. Struktura obydwu klas (MainApp i Ball) została rozdzielona na pliki nagłówkowe i pliki z implementacją ich funkcji składowych.

Krótka charakterystyka szkieletu aplikacji interaktywnej OpenCV

interactive_app_tutorial-main.cpp - plik ten zawiera jedynie funkcję główną programu main(), której jedynym zadaniem jest uruchomienie i wyświetlenie głównego okna aplikacji reprezentowanego przez klasę MainApp. Dodatkowo na początku tego pliku inicjalizowany jest generator liczb losowych OpenCV wartością równą liczbie milisekund, która upłynęła od ustalonej daty w przeszłości (w systemie Linux jest to 1 styczeń 1970 roku).

#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>

#include "interactive_app_tutorial-MainApp.h"

using namespace cv;

RNG rng(cvGetTickCount());

int main(int, char**)
{
  MainApp::getInstance().run();
  
  return 0;
}

interactive_app_tutorial-util.h - tutaj najlepiej umieszczać funkcje ogólnego przeznaczenia oraz funcke narzędziowe, które mogą się przydać w różnych miejscach programu. Na razie znajduje się tu jedynie funkcja zwracająca składowe koloru, dla przekazanej jako parametr liczby.

#ifndef UTIL_H
#define UTIL_H

static Scalar randomColor(RNG& rng)
{
  int icolor = (unsigned)rng;
  return Scalar(icolor&255, (icolor>>8)&255, (icolor>>16)&255);
}

#endif

interactive_app_tutorial-MainApp.h - jest to plik nagłówkowy zawierający deklarację klasy MainApp i jej składowych. Na pierwszy rzut nie widać, aby coś się zmieniło względem szkieletu aplikacji opisanego w poprzednim wpisie. Jednak jak będzie to widać dalej, implementacja poszczególnych funkcji jest już zupełnie inna. Patrząc na zmienne prywatne jakie tutaj zostały zadeklarowane, można zauważyć, że klasa będzie zarządzać trzema kulkami. Jak sobie poradzić z tym ograniczeniem zostanie pokazane na końcu tego wpisu.

#ifndef MAINAPP_H
#define MAINAPP_H

#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>

#include "interactive_app_tutorial-Ball.h"

using namespace cv;

//MainApp singelton class
class MainApp
{
private:
  Mat canvas;               // Image for drawing
  Scalar bgr_color;         // Background color
  Ball *myBall_1, *myBall_2, *myBall_3;
  
public: // Some global params:
  static int DELAY;
  static int CANVAS_WIDTH;  
  static int CANVAS_HEIGHT;  
  
private:
  MainApp() {}
  MainApp(const MainApp &);
  MainApp& operator=(const MainApp&);
  
  void setup();   // Initial commands for setup processing
  void update();  // Commands to modify the parameters
  void draw();    // Drawing functions:
  
public:
  static MainApp& getInstance()
  {
    static MainApp instance;
    return instance;
  }
  
  // Main loop function with displaying image support
  // and handle mouse and keyboard events
  void run();
};

#endif

interactive_app_tutorial-MainApp.cpp - plik ten zawiera właściwą implementację funkcji zawartych w klasie MainApp. Nie są one jakość szczególnie interesujące ponieważ wywołują jedynie funkcje składowe klasy Ball o identycznych nazwach.

#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>

#include "interactive_app_tutorial-MainApp.h"

using namespace cv;

// Best place to initialize global MainApp params:
int MainApp::DELAY        = 5;
int MainApp::CANVAS_WIDTH = 500;
int MainApp::CANVAS_HEIGHT= 350;

void MainApp::run() {
  setup();
  
  const char *win_canvas = "Canvas";
  namedWindow(win_canvas, CV_WINDOW_AUTOSIZE);
  
  while (cvWaitKey(4) == -1) {
    update();
    draw();
    
    imshow(win_canvas, canvas);
    waitKey(DELAY);
  }
}

void MainApp::setup() 
{
  bgr_color = Scalar(200,200,200);
  canvas = Mat(CANVAS_HEIGHT, CANVAS_WIDTH, CV_8UC3, bgr_color);
  
  myBall_1 = new Ball(&canvas);
  myBall_2 = new Ball(&canvas);
  myBall_3 = new Ball(&canvas);
}

void MainApp::draw() {
  canvas = bgr_color;
  
  myBall_1->draw();    
  myBall_2->draw();    
  myBall_3->draw();    
}

void MainApp::update() 
{
  myBall_1->update();
  myBall_2->update();
  myBall_3->update();
}

interactive_app_tutorial-Ball.h - tak naprawdę to tutaj zaczynają się większe zmiany względem poprzedniego szkieletu aplikacji. Plik ten zawiera deklarację nowej klasy Ball, która już sama będzie dbać o swój wygląd, wyrysowanie siebie na ekranie oraz wyliczenie właściwej lokalizacji dla kolejnej iteracji. Sprawą, na którą należy tutaj zwrócić szczególną uwagą jest postać konstruktorów. Konstruktor domyślny Ball() został specjalnie zablokowany, aby zachęcić (zmusić ;-)) użytkownika do korzystania z dodatkowego konstruktora, który jako parametr przyjmuje wskaźnik do struktury cv::Mat, po której będzie można rysować. Generalnie powinien być tutaj przekazywany wskaźnik do głównego obrazka z klasy MainApp, na którym odbywa się rysowanie.

#ifndef BALL_H
#define BALL_H

#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>

using namespace cv;

//Ball class
class Ball 
{
private:
  Mat *canvas;
  float x, y, dim;
  float speedX, speedY;
  Scalar color;
  
  Ball();
  void setup();
  
public:
  Ball(Mat *can)
  {
    canvas = can;
    setup();
  }
  
  void update();
  void draw();
};

#endif

interactive_app_tutorial-Ball.cpp - osoby, które już wcześniej analizowały poprzedni szkielet aplikacji zapewne zauważyły, że istotna część treści funkcji MainApp::update() i MainApp::draw() zostały przeniesione do funkcji o identycznych nazwach w klasie Ball. Jest to najważniejsza zmiana w nowym szablonie. Teraz to każda kulka samodzielnie dba o siebie i kontroluje swoje zachowanie.

#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>

#include "interactive_app_tutorial-Ball.h"
#include "interactive_app_tutorial-MainApp.h"
#include "interactive_app_tutorial-util.h"

using namespace cv;

extern RNG rng;

void Ball::setup()
{
  x = rng.uniform(0, MainApp::CANVAS_WIDTH); // give some random positioning
  y = rng.uniform(0, MainApp::CANVAS_HEIGHT);
  speedX = rng.uniform((float)-2, (float)2); // and random speed and direction
  speedY = rng.uniform((float)-2, (float)2);
  dim    = rng.uniform(20,60);
  
  color = randomColor(rng);
}

void Ball::update() 
{
  if(x < 0 ){
    x = 0;
    speedX *= -1;
  } else if(x > MainApp::CANVAS_WIDTH){
    x = MainApp::CANVAS_WIDTH;
    speedX *= -1;
  }
  
  if(y < 0 ){
    y = 0;
    speedY *= -1;
  } else if(y > MainApp::CANVAS_HEIGHT){
    y = MainApp::CANVAS_HEIGHT;
    speedY *= -1;
  } 
  
  x+=speedX;
  y+=speedY;  
}

void Ball::draw()
{
  circle(*canvas, Point(x,y), dim, color,-1,CV_AA); 
}

CMakeLists.txt - plik ten zawiera konfigurację procesu kompilacji CMake dla omówionego przykładu. Wcześniej był tylko jeden plik, teraz jest ich sześć. Aby się w tym nie pogubić warto skorzystać właśnie z CMake.

PROJECT(OpenCvInteractiveAppsAndExamples-InteractiveAppTutorial2)

cmake_minimum_required(VERSION 2.8)

FIND_PACKAGE( OpenCV REQUIRED )

ADD_EXECUTABLE(interactive_app_tutorial_2 interactive_app_tutorial-main.cpp interactive_app_tutorial-MainApp.cpp interactive_app_tutorial-Ball.cpp)
TARGET_LINK_LIBRARIES(interactive_app_tutorial_2 ${OpenCV_LIBS})

Drobne poprawki na koniec

Wydawać by się mogło, ze w opisanym powyżej szkielecie aplikacji OpenCv wszystko jest OK, ale jeden szczegół na dłuższą metę może okazać się bardzo uciążliwy. W tym momencie w klasie MainApp zosłao z góry określone ile kulek będzie rysowane na ekranie. Trzy kulki to trochę mało. Co by było gdyby trzeba ich było narysować np. trzysta? Najlepiej w takiej sytuacji skorzystać z dynamicznie rozszerzanych kontenerów dostępnych w C++. Klasa vector będzie w zupełności wystarczająca. Na początek warto zmienić deklarację klasy MainApp usuwając z niej zmienne lokalne *myBall_1, *myBall_2, *myBall_3, a wprowadzając na to miejsce deklarację wektora vector <Ball> myBall;. Ja dodatkowo wprowadziłem jeszcze jedną zmienną statyczną, która będzie regulować liczbę kulek wyświetlanych na ekranie. Po tych zmianach kod kod może wyglądać jak poniżej:

interactive_app_tutorial-MainApp.h

private:
  vector <Ball> myBall;
  //...
  
public:
  static int INITIAL_BALLS_NUMBER;
  //...

Kolejna zmiana, która należy wprowadzić to aktualizacja funkcji setup(), update() i draw() klasy MainApp. Teraz one powinny wyglądać następująco:

interactive_app_tutorial-MainApp.cpp

void MainApp::setup() 
{
  bgr_color = Scalar(200,200,200);
  canvas = Mat(CANVAS_HEIGHT, CANVAS_WIDTH, CV_8UC3, bgr_color);
  
  for (int i = 0; i < INITIAL_BALLS_NUMBER; i++){
    myBall.push_back( Ball(&canvas) );
  }

}

void MainApp::draw() {
  canvas = bgr_color;
  
  for (int i = 0; i < myBall.size(); i++){
    myBall[i].draw();
  }  
}

void MainApp::update() 
{
  for (int i = 0; i < myBall.size(); i++){
    myBall[i].update();
  } 
}

Ostatecznie aplikacja po powyższych zmianach i ustawieniu liczby kulek na 30 może dać rezultat podobny jak ten na obrazku poniżej:

W miarę wolnego czasu w kolejnych wpisach będę chciał pokazać jak wprowadzić do powyższego szablonu możliwości interakcji za pomocą klawiatury i myszki oraz za pomocą ruchu zarejestrowanego kamerą.

Obiektowy szkielet aplikacji interaktywnej dla OpenCV

2011-04-07T23:31:00.002+02:00

Pełny kod źródłowy

Biblioteka OpenCV pomimo tego, że zawiera sporo konstrukcji obiektowych i pozwala pisać programy w C++, sama w sobie nie precyzuje i nie podpowiada jaką strukturę powinien mieć dobrze napisany kod programu. Wpływa to oczywiście na morale wielu programistów, którzy widząc, że można napisać kod liniowo w całości w funkcji main, idą na skróty i własnie tak robią. Nie chciałbym tutaj nikogo szczególnie piętnować ;), ale większość przykładowych programów, które ostatnio analizowałem tak własnie jest napisana. Dotyczy to również standardowych przykładów dołączonych do biblioteki OpenCV. Oczywiście tak nie musi być. Programy napisane w OpenCV przy zastosowaniu podstawowych konstrukcji obiektowych mogą być nie tylko czytelniejsze dla osoby, która je pierwszy raz przegląda, ale również znacznie łatwiejsze w pielęgnacji i dalszym rozwoju dla osoby lub zespołu, który taką aplikację napisał.

W tym wpisie chciałem się podzielić szablonem aplikacji OpenCV, którego ostatnio używam. Jest to szablon, który może być szczególnie użyteczny dla aplikacji interaktywnych, w których użytkownik ma wpływ na zachowanie wyświetlanych elementów. Przygotowując ten szablon starałem się zachować podejście znane z programowania aplikacji okienkowych, gdzie pracujemy raczej na komponentach odnoszących się do interfejsu użytkownika, a nie na wielu obiektach z mniej lub bardziej złożoną strukturą powiązań. Jak widać z analizy poniższego kodu funkcja main została zredukowana do minimum, a cała logika aplikacji została przeniesiona do klasy MainApp. Klasa ta nie powinna być wielokrotnie tworzona, dlatego została ona skonstruowana w oparciu o wzorzec Singelton, który tego pilnuje.

Polecam teraz dokładnie przeanalizować podany szablon, a dalsze wyjaśnienia będzie można przeczytać poniżej.

#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>

using namespace cv;

//MainApp singelton class
class MainApp
{
private:
  Mat canvas;               // Image for drawing
  Scalar bgr_color;         // Background color
  int x, y, speedX, speedY; // Circle local params
  
public: // Some global params:
  static int DELAY;
  static int CANVAS_WIDTH;  
  static int CANVAS_HEIGHT;  
  
private:
  MainApp() {}
  MainApp(const MainApp &);
  MainApp& operator=(const MainApp&);
  
  // Initial commands for setup processing
  void setup() 
  {
    x = 0;
    y = 0;
    speedX = 1;
    speedY = 1;
    
    bgr_color = Scalar(120,235,139);
    canvas = Mat(CANVAS_HEIGHT, CANVAS_WIDTH, CV_8UC3, bgr_color);
  }
  
  // Commands to modify the parameters
  void update() 
  {
    if(x < 0 ){
      x = 0;
      speedX *= -1;
    } else if(x > CANVAS_WIDTH){
      x = CANVAS_WIDTH;
      speedX *= -1;
    }
    
    if(y < 0 ){
      y = 0;
      speedY *= -1;
    } else if(y > CANVAS_HEIGHT){
      y = CANVAS_HEIGHT;
      speedY *= -1;
    } 
    
    x+=speedX;
    y+=speedY;    
  }
  
  // Drawing functions:
  void draw() {
    canvas = bgr_color;
    circle(canvas, Point(x,y), 30, Scalar(0,255,255),-1,CV_AA);
  }
  
public:
  static MainApp& getInstance()
  {
    static MainApp instance;
    return instance;
  }
  
  // Main loop function with displaying image support
  // and handle mouse and keyboard events
  void run() {
    setup();

    const char *win_canvas = "Canvas";
    namedWindow(win_canvas, CV_WINDOW_AUTOSIZE);

    while (cvWaitKey(4) == -1) {
      update();
      draw();
      
      imshow(win_canvas, canvas);
      waitKey(DELAY);
    }
  }
};

// Best place to initialize global MainApp params:
int MainApp::DELAY        = 5;
int MainApp::CANVAS_WIDTH = 500;
int MainApp::CANVAS_HEIGHT= 350;

int main(int, char**)
{
  MainApp::getInstance().run();
  
  return 0;
}

Patrząc na powyższy kod nie trudno zauważyć, że został on podzielony na kilka części. Dotyczy to szczególnie klasy MainApp. Została ona podzielona na funkcje, które mają ściśle określone role:

run() - publicznie dostępna funkcja, która obsługuje główną pętlę programu. Program będzie się w niej wykonywał do momentu, aż użytkownik wciśnie klawisz Escape. Funkcja ta nie tylko wywołuje kolejne, niżej opisane funkcje, ale również odpowiada za wyświetlanie głównego okienka programu i obsługę zdarzeń nadchodzących z klawiatury i myszki.
setup() - funkcja wywoływana tylko raz, na początku działania programu, której zadaniem jest inicjalizacja zmiennych lokalnych i utworzenie obrazka, na którym będą rysowane pozostałe elementy.
update() - funkcja modyfikująca wybrane parametry działania programu. Tak naprawdę to tutaj powinna być zapisana główna logika działania programu.
draw() - zawiera wszystkie operacje rysowania na głównej scenie programu.

Aby jeszcze dokładniej prześledzić organizację kodu w podanym szablonie przeanalizujmy przykład, który jest do niego dołączony. Mi wygodnie będzie to zrobić za pomocą następującego dialogu:

A. Tych funkcji jest kilka. Kodu samego nie ma wiele. Czy robi on coś konkretnego?

B. Wszystko co możemy zobaczyć na ekranie odbywa się w funkcji draw(). W tym przykładzie widać wyraźnie, że rysuje ona okręgi o promieniu 30 w punkcie o współrzędnych x, y.

A. Nie wydaje się to nic szczególnie ciekawego.

B. Warto teraz zajrzeć do funkcji update(). To tutaj znajduje się właściwe centrum sterowania aplikacji. To tutaj iteracyjnie modyfikowane są wybrane parametry elementów, które są wyświetlane na ekranie. W przypadku okręgu, o którym mowa, własnie w tej funkcji jest zaprogramowane, aby poruszał się on w linii prostej i odbijał się od krawędzi.

Domyślam się, że przedstawiony szablon nie pokazuje nic szczególnie odkrywczego ;-). Wielu zaawansowanych programistów OpenCV, do których ja się raczej nie zaliczam, pewnie stosuje podobne i lepsze rozwiązania od dawna. Mam jedynie nadzieje, że okaże się on przydatny dla osób, które dopiero zaczynają przygodę z OpenCV i chcą napisać swój pierwszy interaktywny program.

Czekam oczywiście na uwagi i komentarze co można poprawić i co można zrobić lepiej.

Aktualizacja 2011.04.11: Opisany w tym wpisie szkielet aplikacji OpenCV ma kilka niedoskonałości. Opisałem je we wpisie Poprawiony szkielet aplikacji interaktywnej dla OpenCV. Zaproponowałem tam również jego udoskonaloną wersję. Szablon opisany w tym wpisie może być jednak z powodzeniem stosowany do prostszych aplikacji.

Detekcja ruchu w OpenCV - porównanie klatek

2011-04-06T00:15:00.001+02:00

Pełny kod źródłowy

OpenCV zostało stworzone i jest głównie używane tam, gdzie jest potrzebna zaawansowana analiza sekwencji wideo. Jest to narzędzie, które zawiera nie tylko funkcje obsługujące pobieranie obrazu z kamery, ale również funkcje, które potrafią ten obraz przetwarzać i wydobywać z niego ważne dla nas informacje. W przypadku analizy sekwencji wideo jednym z ważniejszych zadań jest detekcja miejsc, gdzie wystąpił ruch. Sama detekcja nie musi być szczególnie problematyczna, jeśli chodzi nam jedynie o proste wskazanie obszarów, na których coś się rusza. Wystarczy jedynie sprawdzić, które piksele na kolejnych klatkach obrazu zmieniają swoją wartość i podjąć decyzję na ile ta zmiana powinna być istotna, aby wykryć rzeczywisty ruch obiektu, a nie np. zaburzenia oświetlenia, bądź też ruch cienia obiektu. Oczywiście istnieje wiele problemów, które wymagają bardziej zaawansowanych algorytmów, aniżeli proste porównywanie obrazów. Możemy do nich mi.in zaliczyć rozpoznawanie i śledzenie wybranych obiektów.

W dzisiejszym wpisie chciałem pokazać proste rozwiązanie problemu detekcji ruchu z wykorzystaniem biblioteki OpenCV. Skorzystam tutaj z opisanej powyżej koncepcji sprawdzania, które punkty obrazu zmieniają swoją wartość na kolejnych obrazach w sekwencji wideo. Najłatwiej w tym celu skorzystać z operacji odejmowania obrazów, a następnie binaryzacji obrazu wynikowego w celu określenia, jaka zmiana wartości pikseli powinna zostać uznana za ruch obiektu, a jaka za brak ruchu. Najczęściej stosuje się tutaj jedną z dwoch strategii odejmowania obrazów:

odejmowanie dwóch sąsiednich obrazów, tzn. odejmowanie od bieżącej klatki, klatki poprzedniej,
odejmowanie od bieżącej klatki, pierwszej klatki, która została zarejestrowana i która jest uznawana jako tło (zakładamy oczywiście, że na pierwszej klatce nie ma obiektów, które później będą zmieniać swoje położenie).

Oba powyższe podejścia pomimo tego, że są bardzo zbliżone do siebie dają całkiem różne rezultaty. Pierwszy sposób wskazuje jedynie, na fragmenty obiektu, które zmieniły swoją lokalizację w sekwencji ruchu, podczas gdy drugi powinien wskazać cały obszar poruszającego się obiektu.

Implementacja opisanych metod w OpenCV nie nastręcza wiele problemów. Obydwa sposoby mogą być zaimplementowane z pomocą poniższego fragmentu kodu:

//TESTED WITH OpenCV 2.2

int diffType = atoi( argv[1] );
int thresval = atoi( argv[2] );

Mat cam_frame, img_gray, img_prev, img_diff, img_bin;

bool first_frame = true;

// LOOP FOR GRABBING IMAGE FROM WEBCAM 

cap >> cam_frame;
cvtColor(cam_frame, img_gray, CV_BGR2GRAY);

if (first_frame) {
    img_prev=img_gray.clone();
    first_frame = false;
    continue;
}

absdiff(img_gray, img_prev, img_diff);
threshold(img_diff, img_bin, thresval, 255, THRESH_BINARY);
erode(img_bin,  img_bin, Mat(), Point(-1,-1), 3);
dilate(img_bin, img_bin, Mat(), Point(-1,-1), 1);

imshow(win_cam,  cam_frame);
imshow(win_gray, img_gray);
imshow(win_diff, img_bin);

if (diffType == 1) img_prev=img_gray.clone();

// END LOOP

Analizując powyższy kod łatwo zauważyć, że jego działaniem możemy sterować za pomocą dwóch zmiennych:

diffType - określa, którą klatkę należy odejmować od klatki bieżącej, czy poprzednią (wartość = 1), czy też pierwszą (wartość = 2). To sprawdzanie odbywa się w ostatniej linijce powyższego kodu, gdzie jest ustawiana klatka, która będzie odejmowana.
thresval - zmienna ta będzie służyć do określania, co uznajemy za ruch obiektu, a co nie. Polecam ustawiać ją w przedziale od 30 do 100 (60 powinno być w miarę bezpieczną, a zarazem skuteczną wartością progu).

Aby nie wchodzić w szczegółową analizę działania powyższego kodu, opiszę jedynie w skrócie jego najważniejsze fragmenty:

W pierwszym przebiegu pętli zapamiętujemy jedynie pierwszą klatkę obrazu. Dzięki temu w drugiej iteracji będziemy mieli co odejmować od klatki bieżącej.
absdiff - bezwzględne odjęcie (pomijamy znak) dwóch klatek od siebie.
threshold - operacja progowania wykonywana na obrazie różnicowym. Pomijamy punkty, które nieznacznie zmieniły swoją wartość.
erode - usunięcie drobnych elementów, oraz wygładzenie krawędzi tych większych. Skutkiem ubocznym tej operacji jest zmniejszenie rozmiaru wszystkich obiektów.
dilate - dylatację stosujemy po etapie erozji, aby delikatnie powiększyć obiekty, tak aby miały podobny rozmiar jak to było przed erozją.

Aby dalej się nie rozpisywać na temat tego bądź co bądź krótkiego fragmentu kodu, zapraszam do obejrzenia filmiku na którym widać obie opisywane metody w działaniu.

Oglądaj film w rozdzielczości HD na pełnym ekranie.

Obsługa parametrów wywołania programu w C++

2011-04-01T00:31:00.001+02:00

Pisząc programy konsolowe niejednokrotnie spotykamy się problemem przekazywania parametrów startowych. Najczęstszym rozwiązaniem jest ich wpisywanie zaraz po nazwie programu, dzięki czemu będą one później dostępne w tablicy argv funkcji main. Innym rozwiązaniem, rzadziej stosowanym jest ich zapisywanie do pliku tekstowego, np. XML i dalsze jego parsowanie zaraz po starcie programu. To drugie rozwiązanie zalecane jest raczej w przypadku naprawdę złożonych parametrów wywołania. W większości przypadków w zupełności wystarcza proste przekazywanie parametrów po nazwie programu w trakcie jego wywołania.

Podejście klasyczne o przykładowym zapisie:

int zmienna1 = atoi (argv[1]);
int zmienna2 = atoi (argv[3]);

może być kłopotliwe w stosowaniu, ponieważ wymaga dokładnego pamiętania kolejności poszczególnych parametrów. Znacznie lepszym rozwiązaniem są parametry nazwane, co do których ten wymóg nie jest już konieczny. Parametry tego typu znane są na pewno każdemu, kto jakiś czas pracował w konsoli tekstowej i potrzebował zmodyfikować domyślne parametry działania programu lub podać własne.

Obecnie jest kilka mechanizmów obsługi tego typu parametrów w języku C++. Niestety nie są one wbudowane do biblioteki standardowej i wymagają stosowania zewnętrznych bibliotek, które mają nie tylko mocne, ale również słabe strony. Oto niektóre z nich:

Boost.Program_options - jeśli ktoś nie miał do tej pory potrzeby korzystania z bibliotek Boost to nie wydaje się dobrym pomysłem włączanie ich do projektu tylko ze względu na obsługę parametrów wejściowych. Bardziej szczegółowy opis biblioteki można znaleźć tutaj.
GNU getopt - użycie tego narzędzia w praktyce wymaga od użytkownika napisania kodu zawierającego instrukcję pętli while i przełącznik switch, przez co implementacja programu niepotrzebnie się wydłuża i może tracić czytelność (szczególnie w przypadku krótkich programów). Przykładowy program można zobaczyć w oficjalnej dokumentacji.
Do innych rozwiązań tego typu można zaliczyć: bibliotekę google-gflags, bibliotekę CLPP, argstream, clp.

Każde z powyższych rozwiązań, nawet jeśli w praktyce działa bardzo dobrze, wymaga korzystania z dodatkowych bibliotek, co do których należy mieć pewność, że zostały poprawnie zainstalowane w systemie. Dodatkowo w przypadku, niedużych programów, nie wydaje się sensowne korzystanie z bibliotek, które swoim rozmiarem znacznie przewyższają kod implementowanego algorytmu. Ja osobiście nie przekonałem się do żadnej z powyższych bibliotek, dlatego postanowiłem sam zaprogramować obsługę parametrów wywołania programu.

Poniższe rozwiązanie przygotowałem na podstawie przykładu ze strony: http://stackoverflow.com/questions/865668/parse-command-line-arguments/868894#868894. Przykład ten niestety nie działał do końca poprawnie i ostateczne rozwiązanie udało mi sie przygotowac analizując kod biblioteki CImg, którą używam do przetwarzania obrazu, a która to miała zaimplementowany podobny mechanizm. Poniższego kodu nie będe szczegółowo opisywał. Mam nadzieje, że jest on wystarczająco czytelny :-).

Funkcja parsująca parametry wywołania programu w C++:

inline const char*  getCmdOption(const char * name, const char * defaut, const int argc, const char *const * argv)
{
  const char *res = 0;
  
  if (argc > 0) {
    int k = 0;
    while (k < argc && strcmp(argv[k],name)) ++k;
    res = (k++==argc?defaut:(k==argc?argv[--k]:argv[k]));
  } else res = defaut;
  
  return res;
}

Przykładowe użycie funkcji getCmdOption:

Funkcja getCmdOption już okazała mi się pomocna w kilku programach z zakresu przetwarzania obrazu. Poniżej fragment programu do wczytywania danych binarnych, ze szczególnym uwzględnieniem obsługi parametrów wejściowych:

if (argc == 1) {
  printf("Usage: %s -f filename.raw -dx [value] -dy [value] -dz [value]\n", argv[0]);
  exit(0);
}

const char * filename  = getCmdOption("-f",    (char*)0, argc, argv );
const char * _dx       = getCmdOption("-dx",   (char*)0, argc, argv );
const char * _dy       = getCmdOption("-dy",   (char*)0, argc, argv );
const char * _dz       = getCmdOption("-dz",   (char*)0, argc, argv );

if ((char*)0 == filename) { 
  printf("Please specify input data file name (-f)\n"); 
  exit(0);
}
if ((char*)0 == _dx || (char*)0 == _dx || (char*)0 == _dx) { 
  printf("Please specify input data dimension sizes (-dx, -dy, -dz)\n"); 
  exit(0);
}

int dx = atoi( _dx );
int dy = atoi( _dy );
int dz = atoi( _dz );

To co było dla mnie najważniejsze i co mam nadzieje udało mi się uzyskać, to duża czytelność kodu. Mam nadzieje, że proponowana funkcja getCmdOption, okaże się również przydatna dla innych.

Wygodna konfiguracja procesu budowania programów OpenCV w CMake

2011-03-24T21:05:00.000+01:00

O sposobach kompilacji programów OpenCV w Linuksie pisałem ostatnio we wpisie OpenCV - instalacja i pierwszy przykład w Ubuntu. Pokazalem tam również przykladowy plik konfiguracyjny dla CMake: CMakeLists.txt. Na pierwszy rzut oka wydaje się on w porządku, jednakże jeśli zacznie nam przybywać nowych programów, wówczas kopiowanie tych dwóch linijek rozpoczynających się od ADD_EXECUTABLE i TARGET_LINK_LIBRARIES może być irytujące. Można oczywiście sobie z tym poradzić i przekonać CMake d bardziej zautomatyzowanej pracy - przykład poniżej:

PROJECT(NazwaProjektu)

cmake_minimum_required(VERSION 2.8)

FIND_PACKAGE( OpenCV REQUIRED )

SET(SOURCES
  aplikacja1
  aplikacja2
  aplikacja3
  aplikacja4 
)

FOREACH(source ${SOURCES})
  ADD_EXECUTABLE(${source} ${source}.cpp)
  TARGET_LINK_LIBRARIES(${source} ${OpenCV_LIBS})
ENDFOREACH(source)

Jak łatwo zauważyć, dodawanie nowego programu do kompilacji nie wymaga wiele wysiłku. Wystarczy dodać nazwę pliku z kodem źródłowym w sekcji SOURCES i gotowe.

Życzę przyjemnej kompilacji programów OpenCV :-)

Dostęp do składowych piksela w OpenCV 2.2

2011-03-22T22:57:00.002+01:00

Pełny kod źródłowy

Wraz ze zmianą wersji biblioteki OpenCV z 2.1 na 2.2 doszło do wielu zmian nie tylko w zakresie organizacji modułów, ale również w zakresie sposobu programowania. Dokładnie nie śledziłem jakie zaszły zmiany, więc nie będę ich dokładnie opisywał, jednak zauważyłem, że został położony większy nacisk na programowanie obiektowe. Widoczne jest to szczególnie w strukturach przechowujących obraz. Od zawsze do tego celu korzystało się ze struktury IplImage, natomiast teraz zalecane jest używanie klasy cv::Mat, która reprezentuje wielowymiarowe macierze danych. Aby szczegółowo zapoznać się z konstrukcją tej klasy najlepiej zajrzeć do oficjalnej dokumentacji pod hasło Basic Structures → Mat.

Pierwszym problemem podczas przejścia ze struktury IplImage do używania klasy Mat będzie zapewne to, jak odczytać i zmodyfikować zawartość poszczególnych składowych piksela. Do tej pory było kilka sposobów, żeby sobie z tym poradzić (polecam wpis na oficjalnym Wiki pod hasłem: How to access image pixels). Teraz podobnie, mamy kilka możliwości, aby dostać się do piksela, jednak dokumentacja opisuje to bardzo pobieżnie. W rozdziale Introduction → Fast Element Access zostały pokazane 3 różne sposoby operowania na pikselach obrazu, jednak dla mnie wydają się one kłopotliwe w użyciu. To właśnie było powodem przygotowania niniejszego poradnika, w którym chciałem przedstawić własne i znalezione w Internecie wygodne sposoby dostępu do składowych piksela.

Obrazy w skali szarości

Na początek, aby nabrać wprawy najlepiej zrobić proste testy z wykorzystaniem obrazów 1-kanałowych. W tym celu obrazy pozyskane z kamery można przekonwertować na obraz szary i na nim wykonywać dalsze operacje.

Poniżej został pokazany fragment kodu, który zawiera 3 sposoby dostępu do piksela, począwszy od tego najbardziej tradycyjnego, gdzie operujemy bezpośrednio na tablicy z danymi (metoda 1), poprzez użycie funkcji at(), której przekazujemy współrzędne interesującego nas punktu (metoda 2), a skończywszy na zastosowaniu wskaźnika do każdego analizowanego wiersza obrazu (metoda 3). Z tych 3 metod podejście obiektowe jest reprezentowane przez sposób 2, podczas gdy pozostałe 2 przypadki działają bardziej tradycyjnie.

Aby skupić się na tym co istotne, poniższy kod zawiera jedynie najważniejszą część programu, z deklaracją używanych struktur reprezentujących obraz, oraz środkiem pętli przetwarzającej obraz z kamery. Aby uruchomić ten program można skorzystać z szablonu, który podałem w poprzednim wpisie OpenCV - instalacja i pierwszy przykład w Ubuntu w sekcji Ten sam przykład po nowemu.

Mat cam_frame, img_gray_v1, img_gray_v2, img_gray_v3;

// LOOP FOR GRABBING IMAGE FROM WEBCAM 

cap >> cam_frame;

// Method 1: Old style method operating on data array
cvtColor(cam_frame, img_gray_v1, CV_BGR2GRAY);

for(int i = 0; i < img_gray_v1.rows; i++)
  for(int j = 0; j < img_gray_v1.cols; j++) {
    img_gray_v1.data[img_gray_v1.step*i + j] = 255 - img_gray_v1.data[img_gray_v1.step*i + j];
  }

// Method 2: Assign pixel using .at() function
cvtColor(cam_frame, img_gray_v2, CV_BGR2GRAY);

for(int i = 0; i < img_gray_v2.rows; i++)
  for(int j = 0; j < img_gray_v2.cols; j++)
    img_gray_v2.at(i,j) = 255 - img_gray_v2.at(i,j);      

// Method2: Use plain C operator []. More efficient than method 2 
//    if you need to process a whole row of a 2d array
cvtColor(cam_frame, img_gray_v3, CV_BGR2GRAY);

for(int i = 0; i < img_gray_v3.rows; i++)
{
  uchar* img_gray_v3_i = img_gray_v3.ptr(i);
  for(int j = 0; j < img_gray_v3.cols; j++)
    img_gray_v3_i[j] = 255 - img_gray_v3_i[j];
}

// END LOOP

Obrazy wielokanałowe

Większy problem aniżeli obrazy 1-kanałowe sprawiają obrazy kolorowe, domyślnie uzyskiwane z tradycyjnych kamer cyfrowych. Należy tutaj pamiętać nie tylko o współrzędnych punktu, który jest analizowany, ale również o jego składowej koloru. na szczęście jest na to kilka sposobów, które można prześledzić poniżej.

Podejście tradycyjne

Podobnie jak w przypadku obrazów szarych, dla obrazów wielokanałowych można również skorzystać z podejścia znanego z obróbki struktur IplImage i przeliczać wskaźnik do elementu, który nas interesuje. Przykład poniżej:

Mat frame, result;

// LOOP FOR GRABBING IMAGE FROM WEBCAM 

cap >> frame;

result = frame.clone();

// invert the image
for(i=0; i < frame.rows; i++) 
  for(j=0; j < frame.cols; j++) 
    for(k=0; k < channels; k++) {

      uchar* temp_ptr = &((uchar*)(result.data + result.step*i))[j*3];
      temp_ptr[0] = 255 - temp_ptr[0];
      temp_ptr[1] = 255 - temp_ptr[1];
      temp_ptr[2] = 255 - temp_ptr[2];    
    }

// END LOOP

Sposoby opisane w oficjalnej dokumentacji

Tak jak wspomniałem na początku tego wpisu, w oficjalnej dokumentacji we wpisie Introduction → Fast Element Access pokazano 3 sposoby na to jak dostać się do składowych piksela. Dla mnie osobiście dziwne wydaje się rozbijanie obrazu wielokanałowego na obrazy zawierające jeden kanał i po wykonaniu obliczeń ponowne ich scalanie. Nie dość, że wydłuża to zapis algorytmu obróbki obrazu, to mam wrażenie, że powoduje dodatkowy narzut obliczeniowy. Kod z drobnymi poprawkami względem wersji oryginalnej znajduje się poniżej:

Mat img_frame, img_resultA, img_resultB, img_resultC;
vector planesA,planesB,planesC;

// LOOP FOR GRABBING IMAGE FROM WEBCAM 

cap >> img_frame;
    
// Method 1. process Y plane using an iterator

split(img_frame, planesA); // split the image into separate color planes

MatIterator_ 
  it1     = planesA[0].begin(),
  it1_end = planesA[0].end(),
  it2     = planesA[1].begin(),
  it3     = planesA[2].begin();

for(; it1 != it1_end; ++it1,++it2,++it3 )
{
  *it1 = 255 - *it1;
  *it2 = 255 - *it2;
  *it3 = 255 - *it3;
}

merge(planesA, img_resultA);

// Method 2. process the first chroma plane using pre-stored row pointer.

split(img_frame, planesB);

for( int y = 0; y < img_frame.rows; y++ )
{
  uchar* Uptr1 = planesB[0].ptr(y);
  uchar* Uptr2 = planesB[1].ptr(y);
  uchar* Uptr3 = planesB[2].ptr(y);
  
  for( int x = 0; x < img_frame.cols; x++ )
  {
    Uptr1[x] = 255 - Uptr1[x];
    Uptr2[x] = 255 - Uptr2[x];
    Uptr3[x] = 255 - Uptr3[x];
  }
}

merge(planesB, img_resultB);

// Method 3. process the second chroma plane using
//           individual element access operations

split(img_frame, planesC);

for( int y = 0; y < img_frame.rows; y++ )
{
  for( int x = 0; x < img_frame.cols; x++ )
  {
    uchar& Vxy1 = planesC[0].at(y, x);
    uchar& Vxy2 = planesC[1].at(y, x);
    uchar& Vxy3 = planesC[2].at(y, x);
    
    Vxy1 = 255 - Vxy1;
    Vxy2 = 255 - Vxy2;
    Vxy3 = 255 - Vxy3;        
  }
}

merge(planesC, img_resultC); 

// END LOOP

Ostatnia deska ratunku

Powyżej opisane sposoby dla obrazów wielokanałowych nie wydają się nazbyt wygodne i raczej zniechęcają, a nie zachęcają do stosowania klasy Mat. Na szczęście światełkiem w tunelu jest klasa pochodna po cv::Mat o niemal identycznej nazwie: cv::Mat_. Klasa ta ma opracowane operatory dostępu do składowych piksela poprzez zastosowanie konstrukcji ( x , y ). Możemy w ten sposób uzyskać wskaźnik do konkretnego punktu obrazu, i dalej stosując zapis tablicowy [] możemy dostać się do konkretnej wartości danego kanału.

Przykład 1: Operowanie na oryginalnym obrazie:

Mat frame;

// LOOP FOR GRABBING IMAGE FROM WEBCAM 

cap >> frame;

Mat_& frame_ = (Mat_&)frame;

for(int i = 0; i < frame_.rows; i++)
  for(int j = 0; j < frame_.cols; j++)
    for(int k = 0; k < 3; k++)
      frame_(i,j)[k] = 255 - frame_(i,j)[k];

// END LOOP

Przykład 2: Operowanie na obrazie pomocniczym:

Mat frame;
Mat_ rgb;

// LOOP FOR GRABBING IMAGE FROM WEBCAM 

cap >> frame;

cvtColor(frame, rgb, CV_BGR2RGB);

for(int i = 0; i < rgb.rows; i++)
  for(int j = 0; j < rgb.cols; j++)
    for(int k = 0; k < 3; k++)
      rgb(i,j)[k] = 255 - rgb(i,j)[k];

// END LOOP

Podsumowując zebrane w tym poradniku sposoby dostępu do składowych piksela, najwygodniejsze wydaje się użycie operatora at() dla obrazów jednokanałowych, natomiast dla obrazów wielokanałowych najprostszy i najbardziej czytelny zapis daje klasa cv::Mat_.

OpenCV - instalacja i pierwszy przykład w Ubuntu

2011-03-19T00:01:00.001+01:00

Już od dłuższego czasu przymierzałem się, aby więcej czasu poświęcić systemom interaktywnym, a w szczególności problematyce analizy ruchu. Zagadnieniami wizualizacji i przetwarzania obrazów medycznych oczywiście nie przestaje się dalej zajmować, jednakże opisywanie tej tematyki na blogu nie dość, że było i jest bardzo wymagające czasowo, to niestety interesuje tylko bardzo małą grupę osób. Natomiast analiza ruchu ma wiele różnych zastosowań - nie tylko tych naukowych, ale również rozrywkowych. Podobnie z punktu widzenia nauki przetwarzania informacji obrazowej, dla wielu młodych osób ciekawsze wydaje się analizowanie obrazu z kamerki na żywo, zamiast analizy statycznych obrazów medycznych.

Tym wpisem rozpoczynam serię poradników dotyczących właśnie analizy ruchu. Głównym narzędziem (biblioteką) jak będzie używana będzie OpenCV, o którym pisałem ponad 2 lata temu na tym blogu. Dzisiaj chciałbym opisać proces instalacji tej biblioteki w Ubuntu i pokazać prosty przykład z użyciem kamerki internetowej.

Instalacja z repozytorium

Aby zainstalować OpenCV z repozytorium wpisujemy następujące polecenie w okienku terminala:

sudo apt-get install libcv-dev libcvaux-dev libhighgui-dev

Patrząc na tą komendę można zauważyć, że instalowane są tylko pakiety programistyczne. A co z bibliotekami? Zainstalują się one oczywiście same jako zależności wyżej wymienionych pakietów. Takie podejście jest oczywiście bardziej uniwersalne w przypadku instalacji OpenCV, ponieważ biblioteki te mają dodaną końcówkę 2.1 (np. libcv2.1), a tak nie będzie zawsze. Dla przykładu na stronie projektu jest już dostępna wersja 2.2.

Instalacja ze źródeł

Tak jak wspomniałem powyżej, wersja, która znajduje się w repozytorium nie jest najświeższa i osobom, którym szczególnie zależy, aby pracować na ostatniej wersji tej biblioteki polecam samodzielną kompilację ze źródeł. Nie jest ona skomplikowana, dlatego również zostanie opisana w tym poradniku.

Najnowszą stabilną wersję źródeł OpenCV można pobrać z portalu SourceForge, a dokładnie ze strony: http://sourceforge.net/projects/opencvlibrary/files/opencv-unix/. Można pobrać ją również bezpośrednio z repozytorium, aby mieć dostęp do aktualnie wprowadzanych funkcji. W tym celu wystarczy wpisać w konsoli następujące polecenie:

svn co https://code.ros.org/svn/opencv/trunk

Ja osobiście polecam wersję stabilną. Obecnie jest to wersja 2.2.

Teraz kiedy mamy pobrane już źródła biblioteki OpenCV, możemy przystąpić do jej kompilacji. Wykonujemy w tym celu następujące kroki:

Utworzenie katalogu build i uruchomienie w nim graficznej nakładki na CMake:
```
mkdir build
cd build
cmake-gui ../
```
Przy pierwszej kompilacji najlepiej nie ustawiać zbyt wiele opcji, aby mieć pewność że podstawowa wersja się skompiluje. Ja ustawiłem tylko typ kompilacji na „Release”
```
CMAKE_BUILD_TYPE                 Release
```
Uruchomienie kompilacji. Jeśli mamy wiecej niż jeden rdzeń warto z tego skorzystać stosując przełącznik j:
```
make -j2
```
Jeśli wszystko dobrze się skompiluje można wówczas uruchomić kolejne przebiegi kompilacji z włączonymi następującymi opcjami:
```
BUILD_EXAMPLES                   ON
BUILD_NEW_PYTHON_SUPPORT         ON
OPENCV_BUILD_3RDPARTY_LIBS       ON
```
Oczywiście tych opcji jest dużo więcej, dlatego polecam samodzielne testowanie pozostałych, chociaż te o których napisałem powinny w zupełności wystarczyć.

Jeśli pojawiły się jakieś niespodziewane błędy podczas kompilacji polecam zajrzeć na stronę:
http://opencv.willowgarage.com/wiki/InstallGuide w celu znalezienia rozwiązania.

Pierwsze testy

Na początek warto przetestować przykłady załączone w katalogu samples. Po kompilacji odpowiadające im wersje binarne powinny znaleźć się w katalogu: build/bin/. Ja sprawdziłem wszystkie i od razu mogę podpowiedzieć, że z kamerką działają te z nich:

adaptiveskindetector
bgfg_codebook
bgfg_segm
camshiftdemo
fback
fback_c
laplace
lkdemo
motempl
segment_objects

Pomimo tego, że nie są one szczególnie złożone, na początek warto zacząć od jeszcze prostszych przykładów.

Wyświetlanie obrazu z kamery

Jednym z pierwszych przykładów, które warto przeanalizować i uruchomić w OpenCV jest pobieranie obrazu z kamery i wyświetlenie go na ekranie monitora. Nie jest to oczywiście trudne, ale wymaga znajomości kilku elementarnych funkcji takich jak:

cvCaptureFromCAM - inicjalizacja kamery,
cvQueryFrame - pobranie pojedynczej klatki obrazu,
cvShowImage - wyświetlenie obrazka we wskazanym oknie.

Cały przykład wygląda następująco:

#include "opencv/highgui.h"

int main() 
{
  CvCapture *cam = cvCaptureFromCAM(-1);
  
  const char *window = "Example 1";
  cvNamedWindow(window, CV_WINDOW_AUTOSIZE);
  
  while (cvWaitKey(4) == -1) {
    IplImage *frame = cvQueryFrame(cam);
    cvShowImage(window, frame);
  }
  
  cvDestroyAllWindows();
  cvReleaseCapture(&cam);
  
  return 0;
}

Aby go skompilować wystarczy uruchomić:

gcc camera1.cpp -o camera1 -lhighgui

Ten sam przykład po nowemu

Przykład przedstawiony powyżej działa zarówno w bieżącej wersji OpenCV jak i w wersjach poprzednich. Jednakże własnie od wersji bieżącej 2.2 biblioteka ta została uporządkowana i podzielona na moduły. Dodatkowo zostały wprowadzone nowe funkcje i został zaproponowany bardziej obiektowy model programowania. Wszystkie te zmiany mają za zadanie ułatwić programowanie, ale nie pozwalają już na kompilację nowych programów tam gdzie jest stara wersja biblioteki. Program po zmianach wg nowych zaleceń wygląda tak:

#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>

using namespace cv;

int main(int, char**)
{
  VideoCapture cap(0);
  if( !cap.isOpened() ) return -1;
  
  Mat frame;
  
  const char *window = "Example 2";
  namedWindow(window, CV_WINDOW_AUTOSIZE);
  
  while (cvWaitKey(4) == -1) {
    cap >> frame;
    imshow(window, frame);
  }
  
  return 0;
}

Kompilacja tak napisanego programu w konsoli nie jest już taka trywialna jak poprzednio. W takiej sytuacji najlepiej będzie skorzystać z narzędzia CMake, które jest podstawą budowania całej biblioteki OpenCV. W katalogu ze źródłami omawianych aplikacji tworzymy nowy plik CMakeLists.txt. Powinien on zawierać taką treść:

PROJECT(opencv_example)

cmake_minimum_required(VERSION 2.8)

FIND_PACKAGE( OpenCV REQUIRED )

# Declare the target (an executable)
ADD_EXECUTABLE(camera1 camera1.cpp)
TARGET_LINK_LIBRARIES(camera1 ${OpenCV_LIBS})

ADD_EXECUTABLE(camera2 camera2.cpp)
TARGET_LINK_LIBRARIES(camera2 ${OpenCV_LIBS})

Teraz już kompilacja sprowadza się do wpisania w konsoli:

mkdir build
cd build
cmake-gui ../

i określenia w parametrach CMake ścieżki do katalogu gdzie mamy zbudowany OpenCV. U mnie wygląda to tak:

OpenCV_DIR   /home/rafal/installed/opencv/OpenCV-2.2.0/build

Teraz już wystarczy wpisać make i oba programy zostaną skompilowane.

W ten sposób udało nam się przygotować dwie aplikacje, które niby nie robią wiele, ale stanowią szkielet większości aplikacji interaktywnych w OpenCV.

Nie do końca udana wirtualizacja MeeGo w VirtualBoxie

2011-03-03T00:13:00.001+01:00

Na początek od razu wyjasnię o co chodzi w tytule, bo wiem, że może on nie zachęcać do czytania dalej. Przez ostatnie kilka dni, mając trochę wolnego czasu postanowiłem przetestować pełną wersję MeeGo Netbook w środowisku wirtualnym z którego zawsze korzystam, czyli w VirtualBoxie. Skłoniło mnie do tego nie tylko to, że wersja dostępna w emulatorze QEMU (jak zainstalować środowisko uruchomieniowe pisałem we wpisie MeeGo - pierwsze starcie) jest mocno okrojona, ale również to, że działa ona dosyć powoli. Miałem nadzieję, że w VirtualBoxie będzie inaczej, bo to w końcu uznana marka wśród narzędzi do wirtualizacji. Sama instalacja pomimo tego, że nie obyła się bez problemów zakończyła się sukcesem. Niestety problem z powolnym działaniem systemu i brakiem jego responsywności również tutaj był mocno widoczny. Próbowałem różnych sposobów i ostatecznie żaden nie pomógł. Nawet deweloperzy MeeGo sami twierdzą, że z VirtualBoxem mogą być problemy i w miarę możliwości zachęcają do instalacji systemu na kompatybilnych urządzeniach.

Pomimo tego, że MeeGo w VirtualBoxie nie działa zachwycająco, to dla osób, które nie mają odpowiedniego sprzętu do dyspozycji lub nie chcą instalować kolejnego systemu jedynie w celach testowych na maszynie, na której pracują na co dzień, myślę, że zastosowanie VirtualBoxa może być dobrym rozwiązaniem. W tym wpisie nie będę szczegółowo rozpisywał się na jakie problemy napotkałem podczas instalacji MeeGo w VirtualBoxie, a jedynie przedstawię niezbędne kroki, które pozwolą na instalację i uruchomienie systemu.

Pobranie obrazu instalacyjnego

Płytę z obrazem instalacyjnym MeeGo Netbook pobieramy ze strony: http://meego.com/downloads/releases/netbook. Ponieważ VirtualBox nie widzi płyt img możemy bez żadnego problemu zmienić rozszerzenie pobranego pliku na iso.

Utworzenie nowej maszyny wirtualnej

Dalej należy utworzyć pustą maszynę wirtualną. W kreatorze VirtualBoxa, który do tego służy możemy podać następujące parametry:

nazwa: MeeGo Netbook v1.1
typ systemu: Linux/Fedora
pamięć: 512MB
dysk: dynamicznie rozszerzalny, 8GB

Dodatkowo samodzielnie należy wejść do opcji i ustawić parametry jak poniżej:

System → Procesor → Włącz PAE/NX
Ekran → Wideo → Włącz akcelerację 3D
Nośniki → kontroler IDE → Choose a virtual CD disc file (wskazujemy na wcześniej pobrany plik z obrazem).

Instalacja MeeGo NetBook

Po uruchomieniu systemu wirtualnego powinno nam się pojawić okienko jak poniżej:

Wybieramy na nim opcję "Instalation only". Po chwili czekania powinna się rozpocząć instalacja systemu. Wita nas ona takim obrazkiem:

Na kolejnych ekranach wystarczy jedynie ustawić język i skonfigurować dysk. W przypadku pustego dysku wirtualnego nie jest to zbytnio skomplikowane. Potwierdzamy jedynie komunikaty, które się pojawią. O zakończeniu instalacji zostaniemy powiadomieni obrazem jak poniżej:

Kliknięcie na przycisk Zamknij spowoduje restart maszyny wirtualnej. Warto ją w tym momencie w ogóle zatrzymać i odmontować z napędu CD płytę instalacyjną.

Po ponownym uruchomieniu systemu powinniśmy zobaczyć kreator pierwszego uruchomienia. Pyta nas on o ustawienia klawiatury, strefę czasową i prosi o utworzenie użytkownika.

Jeśli system teraz wystartuje to mamy szczęście :-) Ja tego szczęścia niestety nie miałem i zobaczyłem czarny ekran. Po ponownym restarcie komputera wyświetlił mi się tylko obraz tła.

Problem przy pierwszym uruchomieniu

Przy rozwiązywaniu problemów, które zaczęły się pojawiać bardzo pomocna okazała się ta strona na Wiki MeeGo: http://wiki.meego.com/MeeGo_1.0_Netbook_VirtualBox. Korzystając z porad tam zawartych wykonałem następujące czynności:

Resetujemy maszynę wirtualną i zanim zacznie startować system wciskamy Escape, a następnie Tab.
Pojawi nam się linijka z tekstem jak na obrazku poniżej, którą możemy wyedytować. Kasujemy tutaj słowo 'quiet' i dodajemy literkę 's'.

Klikamy Enter i czekamy. Po chwili powinniśmy zobaczyć wiersz poleceń ze znaczkiem zachęty symbolizującym tryb administracyjny. Skoro już tutaj jesteśmy warto ustawić hasło roota (polecenie 'passwd') i zainstalować 2 przydatne narzędzia (wget i nano), które mogą okazać się niezbędne na kolejnych etapach konfiguracji.
```
zypper install wget nano
```
Następnie w konsoli wpisujemy następujące polecenie:
```
chmod +s /usr/bin/Xorg
```
i restartujemy system:
```
reboot
```

Teraz system powinien wystartować, ale wcale nie ma takiej pewności :-) U mnie na jednym komputerze opisane podejście zadziałało, a na innym nie przyniosło żadnego rezultatu.

Jeśli system ciągle nie startuje warto sprawdzić, czy nie występuje problem jak ten opisany na forum MeeGo w wątku: INIT: Id "x" respawning too fast: disabled. U mnie właśnie tak było i polecam sprawdzić opisane tam rozwiązanie.

Jeśli będziemy mieć szczęście (a na pewno w końcu się uda ;) ) to system powinien wystartować i przywitać nas ekranem jak ten poniżej:

Próba włączenia wsparcia OpenGL

Niestety, tak jak wspomniałem na początku, MeeGo w podstawowej konfiguracji w Virtualboxie nie zachwyca szybkością - chodzi tak samo ociężale jak wersja dostępna na QEMU. Na Wiki MeeGo jest rozwiązanie tego problemu, ale przyznam szczerze, że u mnie nie działa. Testowałem to na kilka sposobów i albo nie było żadnego efektu, albo system nie mógł wystartować. Opiszę jednak kroki, które wykonałem, bo może u kogoś zadziała lub po prostu ktoś będzie w stanie podpowiedzieć mi co źle robiłem.

Po kolei co należy zrobić, aby spróbować uruchomić akcelerację OpenGl w MeeGo zainstalowanego w VirtualBox (w skrócie):

Uruchamiamy okienko terminala: zakładka Aplikacje → Narzędzia systemowe.

Instalujemy następujące pakiety i restartujemy system:

sudo zypper install gcc make kernel-netbook-devel patch nano wget yum yum-utils 
sudo reboot

Instalujemy dodatki VirtualBoxa. Przed wykonaniem poniższych czynności najpierw należy wybrać w opcjach maszyny: Urządzenia → Zainstaluj dodatki.
```
sudo mount /dev/sr0 /mnt 
cd /mnt 
sudo ./VBoxLinuxAdditions-x86.run
sudo reboot
```
Tworzymy katalog tymczasowy i próbujemy pobrać źródła Cluttera z repozytorium:
```
cd ~
mkdir tmp
cd tmp
yumdownloader --source clutter
```
Niestety u mnie ta próba kończy się niepowodzeniem. Dostaję komunikat podobny do tego:
Error: Cannot retrieve repository metadata (repomd.xml) for repository: meego-core. Please verify its path and try again

Nie pozostaje nam zatem nic innego jak samodzielne pobranie odpowiedniego archiwum ze źródłami

wget http://repo.meego.com/MeeGo/releases/1.1/core/repos/source/clutter-1.2.8-2.131.src.rpm
rpm2cpio clutter-1.2.6-2.2.src.rpm|cpio -id
tar jvxf clutter-1.2.6.tar.bz2

Następnie pobieramy zależności do zbudowania Cluttera. Można to zrobić instalując pakiet clutter-devel, co pozwoli na automatyczne dociągnięcie wszystkich zależnych pakietów:
```
sudo zypper install clutter-devel
```

Ostatecznie uruchamiamy procedure budowania i instalacji Cluttera. Między czasie pobieramy i stosujemy dodatkowa łatkę z forum MeeGo.

cd clutter-1.2.8
wget http://wiki.meego.com/images/Clutter-xvisual-patch.txt
patch -p1 < ./Clutter-xvisual-patch.txt
./configure --prefix=/usr
make
sudo make install
reboot

Po wykonaniu opisanych czynności restartujemy komputer. Należ się również upewnić, że jest włączona akceleracja 3D w ustawieniach VirtualBoxa.

Prezentacja systemu

Na koniec wpisu załączam małą galerię slajdów wykonanych nie tylko na kolejnych etapach instalacji i konfiguracji MeeGo w Virtualboxie, ale również slajdy prezentujące wygląd poszczególnych ekranów systemu.

Wyświetl wszystkie

Uzyskaj własny

Pierwsza mobilna aplikacja dla MeeGo

2011-02-25T00:19:00.001+01:00

Witam. Podobnie jak w przypadku poprzednich dwóch postów, dzisiaj również ostrzegam :-), że nie będzie nic odkrywczego względem oficjalnego Wiki dla programistów MeeGo. Pomimo tego, że sporo korzystam z materiałów tam zawartych, to moje wpisy nie są ich tłumaczeniami, ale raczej opisem własnych doświadczeń z testowania dostępnych tam poradników.

Tym razem będzie o tym jak napisać, skompilować i uruchomić swoją pierwszą aplikacje mobilną dla MeeGo. Wpis ten jest mocno inspirowany następującą stroną na Wiki MeeGo:
http://wiki.meego.com/SDK/Docs/1.1/Creating_Hello_World.

Zakładam na początek, że mamy już zainstalowane środowisko wdrożeniowe i uruchomieniowe oraz, że została przeprowadzona wymagana konfiguracja Qt Creatora.

W pierwszym momencie - zapewne jak się nie trudno domyśleć, należy uruchomić Qt Creatora. W następnym kroku przystępujemy do stworzenia nowego projektu wybierając odpowiednio w menu Plik → Nowy plik lub projekt → Mobilna aplikacja Qt. Potwierdzamy klikając Wybierz… .

Określamy następnie nazwę projektu i wybieramy jego docelową lokalizację.

W kolejnym kroku wybieramy jako wersję Qt tą dostępną po instalacji MeeGo SDK.

Możemy również zmienić domyślne nazwy plików, ale skoro ma to być tylko aplikacja testowa polecam pozostawienie tych zaproponowanych przez kreatora.

Ostatecznie dostajemy ogólne podsumowanie nowo utworzonego projektu:

Prawdopodobnie Qt Creator otworzy się w trybie projektowania interfejsu, dlatego przełączamy się do trybu Edycji kodu źródłowego. Posługując się nawigatorem projektu otwieramy plik main.cpp i zamieniamy jego zawartość na następującą:

#include <qapplication>
#include <qlabel>
#include <qsysteminfo>
using namespace QtMobility;

int main(int argc, char *argv[])
{
  QApplication app(argc, argv);
  QSystemInfo s;
  QLabel *label = new QLabel(QObject::tr("hello").
    append(s.currentCountryCode()));
  label->show();
  label->resize(100,30);
  return app.exec();
}

Teraz należy wyedytować plik z ustawieniami projektu *.pro dodając do niego następujące wpisy:

CONFIG += mobility
MOBILITY += systeminfo

Aby zapisać wszystkie wprowadzone zmiany najlepiej skorzystać z menu Plik → Zachowaj wszystko.

Przed uruchomieniem przygotowanej aplikacji należy najpierw przejść do zakładki Projekty i tam na zakładce Produkty docelowe wybrać MeeGo i Uruchom.

Tutaj należy określić jedynie Device configuration, gdzie powinniśmy wskazać na skonfigurowane wcześniej środowisko uruchomieniowe (jak to zrobić pisałem we wpisie "MeeGo SDK - Konfiguracja Qt Creator", w sekcji "Dostęp do środowiska uruchomieniowego MeeGo"). U mnie to jest akurat: MeeGo NetBook Emulator. Oczywiście należy pamiętać o tym, aby wystartować wybrane środowisko uruchomieniowe MeeGo. Możemy to zrobić wpisując w konsoli polecenie tego typu:

sudo mad remote -r meego-netbook-ia32-qemu-1.1.2-runtime poweron

Po tym wszystkim możemy uruchomić projekt klikając na zielony "trójkącik" symbolizujący start aplikacji. Prawdopodobnie w konsoli Qt Creatora zobaczymy komunikat podobny do tego:

Cleaning up remote leftovers first ...
Initial cleanup done.
Files to deploy: /home/rafal/qthello-build-meego/rrpmbuild/qthello-0.0.1-1.i586.rpm.
Deployment finished.
Starting remote application.
access control disabled, clients can connect from any host
Could not find Hal
Could not find Hal

Teoretycznie teraz powinniśmy zobaczyć w testowym środowisku MeeGo wystartowaną aplikację. Ja niestety na pierwszy rzut oka nie dostrzegłem żadnych zmian. Po kilku kliknięciach w interfejs zauważyłem, że aplikacja jest jednak uruchomiona, ale znajduje się "w tle". Aby zobaczyć ją na pełnym ekranie wystarczy kliknąć na pierwszą zakładkę - tą z domkiem, symbolizującą strefę MyZones (widać to na rysunku poniżej).

Teraz już powinniśmy zobaczyć naszą pierwszą mobilną aplikację dla MeeGo :-D :

Czy miałem podczas wykonywania tych kroków jakieś błędy? Tak, był jeden, ale był on związany z tym, że próbowałem uruchomić aplikację w Qt Creatorze nie mając wcześniej wystartowanego środowiska testowego. Dostałem wówczas taki komunikat:

Cleaning up remote leftovers first ...
Error running initial cleanup: Nie można połączyć się z hostem.

Jeśli będą pojawiać się inne komunikaty i inne błędy, polecam najpierw upewnić się, że Qt Creator poprawnie łączy się z środowiskiem uruchomieniowym MeeGo. Można to sprawdzić przechodząc odpowiednio do Narzędzia → Opcje → Projekty → MeeGo Device Configuration i tam wybierając z listy wcześniej przygotowaną konfigurację możemy skorzystać z opcji Test. Jeśli tutaj wszystko pójdzie OK, nie powinno być problemów z wystartowaniem aplikacji.

Mamy już pierwszą aplikację. Co dalej? Czekam na sugestie czytelników o czym chcieli by poczytać :-).

MeeGo SDK - Konfiguracja Qt Creator

2011-02-21T20:43:00.001+01:00

Instalując MeeGo SDK (pisałem o tym więcej w poprzednim wpisie) dostajemy pełne środowisko programistyczne, które zawiera nie tylko wymagane biblioteki i środowisko uruchomieniowe, ale również wygodne narzędzie do programowania: Qt Creator. Jest to w pełni funkcjonalne środowisko programistyczne dla Qt, które zawiera wiele wygodnych mechanizmów ułatwiających wykonywanie często żmudnych czynności: pełna obsługa kilku systemów śledzenia wersji, wspomaganie procesu kompilacji, narzędzia do testowania i debugowania, zintegrowaną dokumentację, kolorowanie składni i wiele innych. Narzędzie to zostało również przystosowane przez firmę Nokia do programowania pod platformę MeeGo. Wystarczy wskazać i skonfigurować dostęp do środowiska wdrożeniowego (MeeGo Target) oraz środowiska uruchomieniowego (MeeGo Runtime), aby łatwo zacząć programować aplikacje mobilne i tym się właśnie zajmę w dzisiejszym wpisie. Od razu na początku wspomnę, że wszystkie opisane w tym poradniku kroki są bardzo dobrze opisane na Wiki projektu, na którym się wzorowałem. W razie problemów polecam zajrzeć na strony:

Konfiguracja narzędzi kompilujących i bibliotek MeeGo

Aby skonfigurować w Qt Creator dostęp o narzędzi kompilujących i bibliotek MeeGo (tzw. MeeGo Toolchain) wykonujemy następujące czynności:

Uruchamiamy Qt Creator. Może to być ten dostarczony z MeeGo, lub ten z którego do tej pory korzystaliśmy w systemie (najlepiej oczywiście jakby była to najnowsza dostępna wersja, aby mieć pewność, że będzie wspierała MeeGo). Ja wybrałem to drugie podejście, aby nie rozdrabniać sobie środowiska programistycznego. Zresztą na stronie Wiki również tak proponują.
Wchodzimy do Narzędzia → Opcje → Qt4 → Wersje Qt.
Po prawej stronie zakładki Wersje Qt klikamy przycisk z plusikiem, aby dodać nową wersję.
W polu Nazwa wersji wpisujemy własną nazwę określającą wersję Qt. Może to być np. MeeGo NetBook IA32 1.1.2.
Podajemy również ścieżkę do qmake zainstalowanego w katalogach MeeGo. W moim systemie 64-bitowym było to akurat /usr/lib/madde/linux-x86_64/targets/meego-netbook-ia32-1.1.2/bin/qmake. Z dokumentacji wynika, że dla architektur 32-bitowych powinno to być podobnie do /usr/lib/madde/linux-i686/targets/meego-netbook-ia32-1.1.2/bin/qmake, jednak nie mam co do tego pewności i polecam sprawdzić samodzielnie.
Klikamy Przebuduj, Zastosuj i Ok.
Aby zobaczyć więcej informacji o własnie skonfigurowanej wersji Qt wystarczy jeszcze raz wejść do tego samego okienka i kliknąć oraz przytrzymać wskaźnik myszy na etykiecie Ustawienia ręczne → MeeGo NetBook IA32 1.1.2. Powininny się wyświetlić informacje podobne jak na rysunku poniżej.

Dostęp do środowiska uruchomieniowego MeeGo

Aby skonfigurować dostęp do wybranego środowiska uruchomieniowego MeeGo (tzw. MeeGo Runtime) z poziomu Qt Creatora wystarczy wykonać następujące czynności:

Otwieramy Narzędzia → Opcje → Projekty → MeeGo Device Configuration
i klikamy tutaj przycisk Add
Warto ustalić od razu nazwę dla tej konfiguracji. Może to być np. MeeGo NetBook Emulator.
Uzupełniamy pozostałe pola (przykład na rysunku poniżej):

Device type: MeeGo emulator
Authentication type: Password
Host name: localhost (wartość domyślna)
SSH port: 6666 (wartość domyślna)
Gdb serwer port: 13219 (wartość domyślna)
Connection timeout: 30s (wartość domyślna)
Username: root
Password: meego

Klikamy Zastosuj

Aby przetestować właśnie skonfigurowane ustawienia należy najpierw uruchomić wybrane środowisko - można to zrobić wpisując w konsoli:

sudo mad remote -r meego-netbook-ia32-qemu-1.1.2-runtime poweron

a następnie klikając przycisk Test w okienku MeeGo Device Configuration. Jeśli wszystko jest OK powinniśmy zobaczyć okienko takie jak na zrzucie poniżej:

Co z tego wynika i po co to wszystko opiszę w kolejnym wpisie z przykładem pierwszej aplikacji dla MeeGo :-)

MeeGo - pierwsze starcie

2011-02-18T22:17:00.002+01:00

Głośno w ostatnim czasie zrobiło się o MeeGo i to nie za sprawą wysypu urządzeń z tą platformą mobilną, a wręcz przeciwnie - ostatnia decyzja kluczowego partnera projektu, Nokii o wyborze Windows Phone 7 jako głównego systemu dla kolejnych generacji smartfonów postawiła duży znak zapytania co do przyszłości rozwoju MeeGo. Na szczęści drugi duży partner w rozwoju MeeGo - Intel, zamierza ciągle intensywnie inwestować w tą platformę i zachęca do tego również inne firmy. A tych firm już teraz jest sporo. Do firm, które zadeklarował sie wspierać i używać MeeGo w swoich produktach mozna wyróżnić nie tylko takich gigantów branży elektronicznej jak AMD, Asus, Acer, Cisco, ale również wiele innych firm na czele z BMW.

Ja od dawna kibicuję MeeGo, aby jak najszybciej weszło i zdobyło rynek urządzeń mobilnych i multimedialnych. Głównym powodem jest to, że bardzo wygodnie pracuje mi się z biblioteką Qt, a myśl, że program, który napiszę w Linuksie będzie działał nie tylko na MS Window i Mac iOS, jak to miało miejsce dotychczas, ale również na wszystkich urządzeniach obsługujących MeeGo wydaje się naprawdę ekscytująca. Ostatnie decyzje Nokii również mnie nie wprawiły w najlepsze samopoczucie, ale już zdążyłem ochłonąć :) i wiem, że najlepszą rzeczą, którą mogę w takim momencie zrobić to promować tą platformę i zachęcać do niej innych. W związku z tym chciałbym rozpocząć serię artykułów pokazujących jak rozpocząć przygodę z tym systemem. Od razu również dodam, że do tej pory nie miałem żadnego doświadczenia z MeeGo i moje wpisy raczej będą opisywać pierwsze kroki, które sam postawiłem, a nie zaawansowane zagadnienia z punktu widzenia eksperta w tej dziedzinie.

Na początek przygotowałem mały poradnik jak zainstalować podstawowe środowisko uruchomieniowe i jak skonfigurować zestaw narzędzi, które będą niezbędne do implementacji własnych programów. Poradnik ten został przygotowany w oparciu o oficjalną dokumentację znajdująca się na Wiki projektu: http://wiki.meego.com/SDK/Docs/1.1/
Getting_started_with_the_MeeGo_SDK_for_Linux. Jest ona naprawdę dobrze przygotowana i mój opis będzie raczej jej skrótem, a nie rozwinięciem. Wszystkie instrukcje zostaną pokazane na przykladzie systemu Ubuntu w wersji 10.10.

Ustawienie repozytorium

Wielkim ułatwieniem dla osób interesujących się testowaniem i rozwojem MeeGo w Ubuntu jest przygotowane dla tej dystrybucji repozytorium, które zawiera wszystkie niezbędne narzędzia do dalszej pracy. Konfigurujemy je w sposób opisany poniżej.

Tworzymy nowy plik

sudo nano /etc/apt/sources.list.d/meego-sdk.list

do którego zapisujemy:

deb http://repo.meego.com/MeeGo/sdk/host/repos/ubuntu/10.10/   /

Pobieramy klucze do repozytorium:

gpg --keyserver pool.sks-keyservers.net --recv 0BC7BEC479FC1F8A
gpg --export --armor 0BC7BEC479FC1F8A | sudo apt-key add -

Aktualizujemy listę pakietów:

sudo apt-get update

Sprawdzamy poprawność repozytorium:

apt-cache policy madde

Instalacja MeeGo SDK

Aby zainstalować pakiet narzędzi MeeGoo (tzw. SDK) wystarczy wskazać do instalacji meta-pakiet meego-sdk. Dzięki temu wszystkie wymagane pakiety zostaną zainstalowane.

sudo apt-get install meego-sdk

Instalacja środowiska wdrożeniowego (Target)

Należy również zainstalować wybrane środowisko wdrożeniowe MeeGo (tzw. MeeGoo Target). W jego skład wchodzi zestaw aplikacji do kompilacji, linkowania i debugowania (tzw. MeeGoo Toolchain) oraz biblioteki systemowe.

Aby sprawdzić jakie środowiska wdrożeniowe mamy do dyspozycji wydajemy polecenie:

sudo mad-admin list

Ja wybrałem do instalacji dwa z nich:

sudo mad-admin create -f meego-netbook-ia32-1.1.2
sudo mad-admin create -f meego-handset-ia32-1.1.2

Aby przetestować działanie wybranego środowiska, warto utworzyć dla niego przykładową aplikację. Można to szybko zrobić stosując narzędzia dostępne w MeeGo SDK:

mad -t meego-netbook-ia32-1.1.2 pscreate -t qt-simple qthello

Przechodzimy do katalogu z projektem i uruchamiamy kompilację:

cd qthello
mad -t meego-netbook-ia32-1.1.2 qmake
mad -t meego-netbook-ia32-1.1.2 make

Sprawdzamy czy plik wykonywalny istnieje:

file build/qthello

Aplikację również możemy uruchomić wydając polecenie: build/qthello. Powinno nam się pojawić okienko programu z widocznym przyciskiem „Hello world”. Okienko należy wyłączyć zamykając program w konsoli ponieważ nie zawiera ono paska tytułowego z przyciskami sterującymi (zamknij, minimalizuj, itp.).

Instalacja i testowanie środowiska uruchomieniowego (Runtime)

Środowisko wdrożeniowe to za mało, aby wygodnie pisać i testować programy napisane dla MeeGo. Potrzebne nam jest również środowisko uruchomieniowe (ang. MeeGo Runtime), na którym będziemy mogli przetestować na żywo jak się sprawuje nasza aplikacja. Najlepiej jakbyśmy dysponowali jakimś urządzeniem, na którym jest zainstalowany MeeGo. Jeśli jednak takim nie dysponujemy możemy skorzystać z testowego środowiska przygotowanego przez twórców MeeGo w postaci maszyn wirtualnych QEMU. Oczywiście do ich działania wymagana jest sprzętowa akceleracja wirtualizacji wbudowana w procesor. W sumie nie jest to wymóg samego MeeGo, a jedynie QEMU.

Instalacja środowiska uruchomieniowego jest dobrze opisana na Wiki MeeGo, gdzie również polecam zajrzeć: http://wiki.meego.com/SDK/Docs/1.1/Configuring_QEMU_runtimes.

Aby sprawdzić jakie środowiska mamy do dyspozycji wydajemy polecenie:

mad-admin list runtimes

Ja zainstalowałem na początek dwa z nich (uwaga: każde zajmuje ok. 650MB!):

sudo mad-admin create -f -e meego-netbook-ia32-qemu-1.1.2-runtime
sudo mad-admin create -f -e meego-handset-ia32-qemu-1.1.2-runtime

Po instalacji możemy już przetestować na własnym komputerze czy to naprawdę działa:

sudo mad remote -r meego-netbook-ia32-qemu-1.1.2-runtime poweron
sudo mad remote -r meego-handset-ia32-qemu-1.1.2-runtime poweron

Po zakończonych testach wyłączamy wirtualną maszynę poleceniem:

sudo mad remote -r meego-netbook-ia32-qemu-1.1.2-runtime poweroff
sudo mad remote -r meego-handset-ia32-qemu-1.1.2-runtime poweroff

Napotkane problemy

Niestety przy podczas pierwszej próby włączenia dowolnego środowiska dostawałem komunikat:
```
Starting QEMU runtime meego-handset-ia32-w32-qemu-1.1.20101031.2201-sda-runtime
This may take some time ...
```
i nic się więcej nie działa. Nic nie startuje. Nic nie zjada zasobów procesora. Wyszło na to, że mój procesor (AMD Phenom™ II X4 925) ma jakieś problemy ze wspomaganiem wirtualizacji sprzętowej. Jest też odpowiedni wpis na Wiki Meego, który dotyczy tego problemu i tam polecam najpierw zajrzeć: http://wiki.meego.com/SDK/Docs/1.1/MeeGo_SDK_Graphics_Acceleration. U mnie problem rozwiązał się po instalacji następujących pakietów:
```
sudo apt-get install qemu-kvm kvm
```
wydaniu polecenia:
```
sudo modprobe kvm_amd
```
i restarcie komputera. Później już wszystko ruszyło z miejsca :)
Na innym komputerze, co do którego miałem pewność, że procesor, który się w nim znajduje (Intel i3 530) powinien sobie poradzić był taki sam problem ze uruchomieniem środowiska Runtime. Rozwiązanie było podobne jak poprzednio. Tutaj wystarczyło jedynie wpisać:
```
sudo modprobe kvm_intel
```
Niestety na komputerze z AMD nie udało mi się uruchomić, żadnego środowiska uruchomieniowego dla telefonów. Domyślam się, że może to być związane z tym, że mam na nim kartę i sterowniki NVidi. Na komputerze z Intelem wszystko było OK.

Podsumowanie i zrzuty ekranu

Na koniec jeszcze dwa przykładowe zrzuty ekranu jak to wygląda na żywo.

Środowisko dla netbooków

Środowisko dla telefonów

Więcej zrzutów można obejrzeć na poniższym pokazie slajdów:

Wyświetl wszystkie

Uzyskaj własny

Pomimo tego, że środowisko dla netbooków, wygląda tak jak wielu czytelników zapewne widziało na różnych screenach w Internecie to nie można powiedzieć już tego samego o wersji na telefony. Jest ona bardzo okrojona, zawiera jedynie kilka dodatkowych aplikacji i w ogóle nie prezentuje się najlepiej. Ale przecież, nie jest to środowisko do codziennego używania, a jedynie do testów i rozwoju własnych aplikacji.

Na razie to tyle :) Kolejnym razem opiszę jak do tego wszystkiego podłączyć Qt Creatora.

Kompilacja KDE ze źródeł dla niewtajemniczonych

2010-12-11T23:58:00.001+01:00

Kilka dni temu postanowiłem zmierzyć się z wyzwaniem samodzielnej kompilacji KDE ze źródeł. To co po pierwszych próbach wydawało mi się niemal niemożliwe, ostatecznie okazało się nie tak skomplikowane jak sądziłem. Podstawowy błąd jaki robiłem na początku był taki, że kompilację uruchamiałem na starszym wydaniu Kubuntu 10.04. Jest to wersja o dłuższym okresie serwisowania (tzw. LTS - Long Term Support), więc byłem przekonany, że programiści KDE będą ją również wspierać w procesie kompilacji. Tak poza tym, to właśnie tą wersję miałem zainstalowaną na komputerze stacjonarnym i to był główny powód, dlaczego z niej skorzystałem. O problemach jakie wtedy napotkałem nie będę pisał, bo nie występowały one już w Kubuntu 10.10. Tutaj jedynym problemem było zainstalowanie wszystkich wymaganych zależności na potrzeby kompilacji.

Poniższy opis/poradnik powstał przy znacznym wykorzystaniu następujących materiałów dostępnych w Internecie:

KDE TechBase: Build KDE4.6 on Kubuntu (opis kompilacji KDE 4.6 w Kubuntu 10.04)
KDE TechBase: Getting Started/Build/KDE4 (oficjalna dokumentacja kompilacji KDE)
Blog: Who Says Penguins Can't Fly?: Building KDE SC from SVN.

Warto do nich zajrzeć w razie pojawienia się innych niż opisane w tym tekście problemów, lub jeśli będzie potrzeba bardziej dokładnego doczytania się co skąd się bierze, bo ja nie zawsze dokładnie to przedstawiam.

Aktualizacja oprogramowania

Kubuntu w podstawowej konfiguracji zawiera jedynie wpisy do przetestowanych repozytoriów, co do których w miarę jest pewność, że pakiety tam zawarte będą działać stabilnie. Nie ma dodanych tych, które zawierają rozwojowe i testowe wersje pakietów. One właśnie są potrzebne w momencie kompilacji KDE. Dodajemy zatem te repozytoria i instalujemy aktualizacje:

sudo add-apt-repository ppa:kubuntu-ppa/backports
sudo add-apt-repository ppa:kubuntu-ppa/beta
sudo apt-get update
sudo apt-get upgrade

Nie wiem dlaczego, ale po wykonaniu tych kroków narzędzie do aktualizacji z Kubuntu poinformowało mnie (trzeba sprawdzić odpowiednią ikonkę w zasobniku systemowym koło zegara), że jeszcze nie wszystkie zostały zainstalowane. Instalujemy wszystkie aktualizacje, które zostały zaproponowane.

Instalujemy dodatkowe pakiety

Tak jak wspomniałem na początku tego wpisu, na potrzeby kompilacji wymagane jest zainstalowanie wielu dodatkowych pakietów. Poniższa lista została opracowana na podstawie oficjalnej dokumentacji kompilacji KDE pod Debiana i Ubuntu/Kubuntu: http://techbase.kde.org/Getting_Started/Build/KDE4/Kubuntu_and_Debian oraz na podstawie własnych doświadczeń zebranych podczas kilku prób kompilacji KDE.

sudo apt-get install subversion git-core gcc g++

sudo apt-get install build-essential xorg-dev cdbs debhelper cmake kdesdk-scripts subversion ssh xserver-xephyr doxygen dbus-x11 libxml2-dev libxslt1-dev shared-mime-info libical-dev libgif-dev libssl-dev libboost-dev libboost-program-options-dev libboost-graph-dev libgpgme11-dev libxine-dev libqimageblitz-dev libbz2-dev libdbus-1-dev libpam0g-dev libpcre3-dev libkrb5-dev libsm-dev libclucene0ldbl libclucene-dev libjpeg62-dev libxtst-dev xsltproc libxrender-dev libfontconfig1-dev automoc librdf0-dev libdbusmenu-qt-dev docbook-xsl docbook-xml libattica-dev libqt4-webkit-dev shared-desktop-ontologies libphonon-dev

sudo apt-get install graphviz libqt4-dev libstreamanalyzer-dev libstrigiqtdbusclient-dev libxml2-utils libopenexr-dev libjasper-dev libenchant-dev libavahi-common-dev libaspell-dev libasound2-dev libldap2-dev libsasl2-dev libsmbclient-dev libxkbfile-dev libxcb1-dev libxklavier-dev libxdamage-dev libxcomposite-dev libbluetooth-dev libusb-dev network-manager-dev libsmbclient-dev libsensors-dev libnm-util-dev libusb-dev libcfitsio3-dev libnova-dev libeigen2-dev libopenbabel-dev libfacile-ocaml-dev libboost-python-dev libsvn-dev libsvncpp-dev libqt4-dev libqca2-dev libstreamanalyzer-dev libstrigiqtdbusclient-dev libcommoncpp2-dev libidn11 libidn11-dev libpci-dev libxss-dev libxft-dev libpoppler-qt4-dev libpolkit-agent-1-dev libpolkit-backend-1-dev libpolkit-qt-1-dev libspectre-dev

sudo apt-get install kdesdk kdelibs5-dev kdebase-workspace-dev libakonadi-dev libsoprano-dev libkonq5-dev libv4l-dev

sudo apt-get install flex bison libacl1-dev hspell

Utworzenie nowego użytkownika

Przed przystąpieniem do właściwego procesu kompilacji KDE, warto zadać sobie pytanie: w jaki sposób chcemy mieć dostęp zarówno do nowego środowiska pracy jak również do wersji stabilnej, której używaliśmy do tej pory? W Internecie można znaleźć wiele odpowiedzi na to pytanie, m.in.: skorzystanie z środowiska wirtualnego (np. VirtualBox) lub przełączanie głównej gałęzi struktury plików przy użyciu chroot. W tym poradniku zostanie opisane jeszcze inne podejście, które jest zalecane w oficjalnej dokumentacji KDE. Zostanie utworzony nowy użytkownik, na koncie którego zostanie przeprowadzona kompilacja i lokalna instalacja KDE. "Lokalna" w tym wypadku oznacza, że tylko ten użytkownik będzie mógł korzystać z tej wersji KDE.

Tworzymy nowego użytkownika i dodajemy go do grup. Jeśli chcemy, aby użytkownik miał dostęp do trybu poleceń administratora (sudo) zamiast do grupy users dodajemy go do grupy admin.

sudo useradd -m -G users,audio,video,cdrom,plugdev -s /bin/bash kde-devel
sudo passwd kde-devel

Logujemy się na konto właśnie utworzonego użytkownika:

su - kde-devel

Konfiguracja skryptów startowych

Oficjalna dokumentacja zaleca, aby zaraz po zalogowaniu skonfigurować skrypty startowe w celu usprawnienia procesu kompilacji. Można to zrobić wykonując następujące czynności:

Robimy kopię zapasową oryginalnego pliku .bashrc:
```
cp .bashrc .bashrc_backup
```
Ze strony http://techbase.kde.org/Getting_Started/Increased_Productivity_in_KDE4_with_Scripts/.bashrc kopiujemy zawartość przykładowego pliku .bashrc i wklejamy go do pliku .bashrc_KDE:
```
nano .bashrc_KDE
```
Dodajemy do oryginalnego pliku .bashrc ładowanie pliku .bashrc_KDE:
```
echo "source ~/.bashrc_KDE" >> ~/.bashrc
```
Wczytujemy ponownie zawartość pliku .bashrc, aby jego zawartość była widoczna również dla bieżącej sesji:
```
source ~/.bashrc
```

Konfiguracja narzędzia ''kdesrc-build''

Na potrzeby kompilacji KDE najłatwiej skorzystać ze skryptu kdesrc-build, który można pobrać ze strony: http://kdesvn-build.kde.org/. Skrypt ten automatyzuje wiele zadań, takich jak pobieranie źródeł, przygotowanie i uruchamianie procesu kompilacji.

Pobranie i konfigurację skryptu kdesrc-build wykonujemy za pomocą poniższych poleceń (na stronie projektu warto najpierw sprawdzić, czy nie ma nowszej wersji tego narzędzia):

mkdir -p ~/kdesrc/kdesrc-build
wget http://kdesvn-build.kde.org/releases/kdesrc-build-1.12.tar.bz2
tar xjvf kdesrc-build-1.12.tar.bz2 -C ~/kdesrc/kdesrc-build/
rm kdesrc-build-1.12.tar.bz2
cp ~/kdesrc/kdesrc-build/kdesrc-build-1.12/kdesrc-buildrc-sample ~/.kdesrc-buildrc

Uruchomienie procesu kompilacji:

~/kdesrc/kdesrc-build/kdesrc-build-1.12/kdesrc-build

Domyślnie proces kompilacji jest uruchamiany w trybie zrównoleglonym (opcja -j programu make) w 2 procesach. Warto jednak pamiętać, że:

jeśli mamy 1 jeden rdzeń obliczeniowy to nie przyniesie to żadnego efektu;
w przypadku większej liczby rdzeni warto z nich skorzystać i uruchomić proces kompilacji z odpowiednio ustawionym parametrem make-options skryptu kdesrc-build. Przykład dla 4 procesorów:

~/kdesrc/kdesrc-build/kdesrc-build-1.12/kdesrc-build --make-options=-j4

Problemy

Podczas kompilacji pojawił mi się następujący komunikat o błędzie:

Building phonon-git (3/15)
  Waiting for source code update.
  Source update complete for phonon-git: 0 files affected.
  Compiling...
  Build succeeded after 1 second.
  Installing phonon-git.
  Unable to install phonon-git!
  Overall time for phonon-git was 1 second.

Warto podejrzeć co znajduje się w logach. U mnie odpowiedni plik znajdował się w następującej lokalizacji:

cat ~/kdesvn/log/2010-12-05-03/phonon-git/install.log

CMake Error at cmake_install.cmake:40 (FILE):
  file INSTALL cannot copy file
  "/home/kde-devel/kdesvn/phonon-git/qt_phonon.pri" to
  "/usr/share/qt4/mkspecs/modules/qt_phonon.pri".

Wynika z niego, że pomimo przyjętych założeń o lokalnej instalacji KDE na koncie użytkownika kde-devel, instalator Photona próbuje umieścić coś w głównej strukturze plików. Można to wyłączyć edytując następujący plik:

nano kdesvn/phonon-git/CMakeLists.txt

i umieszczając w komentarzu tą linię (znajduje się ona na końcu pliku):

#install(FILES qt_phonon.pri DESTINATION  ${QT_MKSPECS_DIR}/modules)

Uwaga: Oczywiście nie mam pewności, czy to jest najlepsze z możliwych rozwiązań i czy później nie wpłynie to na błędy podczas używania nowego KDE. Najważniejsze jest jednak to, że kompilacja idzie dalej :-)

Kompilujemy dodatkowe programy

Skrypt kdesrc-build poza domyślnym zestawem modułów, które mogliśmy zobaczyć podczas jego działania, obsługuje jeszcze kilka, które domyślnie są wyłączone. Aby je włączyć do procesu kompilacji, należy wedytować poniższej wskazany plik i odkomentować potrzebne nam moduły:

nano ~/.kdesrc-buildrc

Zauważyłem jednak, że pewne moduły, które są tutaj umieszczone nie działają. Przykładem jest zestaw narzędzi developerskich KDE: kdevplatform, kdevelop, quanta. Problem z ich kompilacją wynika stąd, że ich kod nie jest dłużej dostępny w repozytorium subversion i został przeniesiony do repozytorium git. Mi osobiście zależało na tym, aby mieć te moduły skompilowane, dlatego poniżej znajduje się opis, jak można to zrobić samodzielnie.

Zakładamy katalog, w którym będziemy umieszczać dodatkowe programy KDE, które będziemy samodzielnie kompilować:

mkdir kdesoftware
cd kdesoftware

Pobieramy źródła programów związanych z KDevelopem:

git clone git://gitorious.org/kdevelop/kdevplatform.git
git clone git://gitorious.org/kdevelop/kdevelop.git
git clone git://gitorious.org/kdevelop/quanta.git

Tworzymy katalogi budowania:

mkdir -p build/{kdevplatform,kdevelop,quanta}

Uruchamiamy procedurę kompilacji i instalacji:

cd ~/kdesoftware/build/kdevplatform/
cmake -DCMAKE_INSTALL_PREFIX=~/kde/ ../../kdevplatform/
make && make install

cd ~/kdesoftware/build/kdevelop/
cmake -DCMAKE_INSTALL_PREFIX=~/kde/ ../../kdevelop/
make && make install

cd ~/kdesoftware/build/quanta/
cmake -DCMAKE_INSTALL_PREFIX=~/kde/ ../../quanta/
make && make install

Testowanie nowego KDE

Jeśli chcemy przetestować pojedynczy program z właśnie skompilowanego KDE, a zarazem nie chcemy uruchamiać całego środowiska, najlepiej skorzystać z narzędzia sux:
```
sudo apt-get install sux
sux - kde-devel
dolphin
```
Aby przetestować działanie pełnego środowiska KDE wystarczy zalogować się na użytkownika kde-devel wybierając jako typ sesji na „Bezpieczne logowanie” i uruchomić program:
```
~/kde/bin/startkde
```
Jeśli chcielibyśmy to zrobić „bardziej elegancko” najlepszym rozwiązaniem wydaje się przygotowanie nowego typu sesji, którą będziemy mogli wybrać podczas logowania. Należy w tym celu wykonać następujące operacje (jako użytkownik z prawami administracyjnymi):
```
cd /usr/share/kde4/apps/kdm/sessions/
sudo cp kde-plasma.desktop kde-plasma-trunk.desktop
sudo nano kde-plasma-trunk.desktop
```
Do pliku kde-plasma-trunk.desktop wklejamy poniższą zawartość:
```
[Desktop Entry]
Encoding=UTF-8
Type=XSession
Exec=/home/kde-devel/kde/bin/startkde
TryExec=/home/kde-devel/kde/bin/startkde
Name=KDE Trunk           
Comment=The desktop made by KDE
```
Teraz już podczas logowania zamiast tradycyjnej sesji KDE, wybieramy z listy sesję KDE Trunk.

Podsumowanie
Powyższy opis tak jak tytuł wskazuje, został przygotowany dla użytkowników początkujących lub średnio obeznanych z administracją i programowaniem w Linuksie. Domyślam się, że zaawansowani użytkownicy KDE znaleźli by tu kilka błędów, lub przedstawili bardziej zoptymalizowany proces kompilacji. Dla mnie najważniejszym jednak jest to, że kompilację udało mi się nie tylko rozpocząć, ale również zakończyć :-), co pozwala mi się czuć bardziej wtajemniczonym w obsługę tego systemu, aniżeli jeszcze kilkanaście dni temu.

Zachęcam do zadawania pytań lub do wpisywania komentarzy, co można poprawić w powyższym poradniku. W razie problemów poszukiwanie odpowiedzi najlepiej zacząć od oficjalnej dokumentacji na stronie: http://techbase.kde.org/Getting_Started/Build/KDE4/Troubleshooting. Zostały tam opisane najczęstsze problemy i ich rozwiązania.

Wygodna integracja Windows7 z Ubuntu za pomocą VirtualBoxa

2010-11-18T01:14:00.003+01:00

Pisałem ostatnio o konfiguracji lokalnego repozytorium pakietów na potrzeby sal dydaktycznych, którymi się opiekuję na Politechnice Krakowskiej. Na salach tych, o których mowa nie będzie zainstalowany jedynie Ubuntu, ale również Windows7. Aby ułatwić sobie dalszą pracę w zarządzaniu tym systemem, postanowiłem zainstalować go w maszynie wirtualnej stosując VirtualBoxa. Jest wiele innych narzędzi do wirtualizacji, jednakże po lekturze różnych porównań w Internecie przekonałem się właśnie do wyboru narzędzia firmowanego logo Oracle. Oczywiście poza moją wygodą w administracji obu systemami na raz, najważniejsza jest wygoda i prostota obsługi przez potencjalnych użytkowników, którymi są studenci różnych kierunków Wydziału Mechanicznego. Ilość osób, które przewija się przez te sale w 2 tygodniowym toku zajęć (tygodnie parzyste i nieparzyste) zdecydowanie przewyższa pół tysiąca osób. Fakt ten wymaga, aby na sali wszystko działało bez zarzutu.

W tym poradniku chciałem przedstawić poszczególne kroki konfiguracji wirtualnej maszyny z Windows7 na potrzeby zajęć dydaktycznych. Na ile to będzie możliwe poszczególne czynności będą wykonywane za pomocą poleceń w konsoli, a nie za pomocą narzędzi graficznych.Takie podejście pozwala na pisanie skryptów, które potrafią znacznie ułatwić pracę w przypadku kiedy te same czynności należy wykonać kilka/kilkanaście razy.

Jedną z najbardziej przydatnych, a niestety mało znanych funkcji VirtualBoxa, która zostanie omówiona jest możliwość zmiany trybu pracy dysku i przełączenie go w stan resetu danych po każdym wyłączeniu maszyny wirtualnej.

Mam nadzieje, że przedstawione porady okażą się również przydatne dla typowego użytkownika komputera, a nie tylko dla osoby przygotowującej sale na zajęcia lub szkolenia.

Czynności wstępne

Na początek gorąco polecam zapoznać się z oficjalną dokumentacją narzędzia VBoxManage, które pozwala na wykonanie tych samych (a nawet więcej) czynności co ogólnie znany interfejs graficzny VirtualBoxa (strona dokumentacji tego narzędzia). Większość kroków w tym poradniku wykonanych jest za jego pomocą. Nie piszę jednak szczegółowych opisów dla poszczególnych poleceń, dlatego właśnie odsyłam do dokumentacji.

Pierwszą czynnością administracyjną, którą polecam na początek jest przygotowanie dodatkowego użytkownika, którego możemy nazwać np. "windows". Docelowo dla tego użytkownika zostanie ustawione, aby zaraz po zalogowaniu do systemu startowała wirtualna maszyna z Windows7. Można oczywiście ten krok pominąć i skonfigurować sobie VirtualBoxa do pracy na obecnie używanym koncie użytkownika.

Dodać nowego uzytkownika w Ubuntu możemy wybierając odpowiednio w menu:
System → Administracja → Użytkownicy i grupy → Dodaj.

Instalacja VirtualBox
Instalację VirtualBoxa najlepiej przeprowadzać zgodnie z oficjalnym opisem zamieszczonym na stronie: http://www.virtualbox.org/wiki/Linux_Downloads. W Ubuntu sprowadza się to do dodania odpowiedniego repozytorium, pobrania i dodania kluczy uwierzytelniających oraz instalacji następujących pakietów:

sudo apt-get install virtualbox-3.2 dkms

Utworzenie wzorcowej maszyny wirtualnej
Przed stworzeniem pierwszej maszyny wirtualnej, która może być wzorcem do tworzenia kolejnych maszyn trzeba zalogować się na konto "windows" i tam uruchomić VirtualBoxa. Zaraz po zaakceptowaniu licencji można wyłączyć program.

W tym momencie można jeszcze utworzyć katalog, który będzie współdzielony pomiędzy Ubuntu, a Windowsem:

mkdir /home/windows/share

Tworzenie maszyny wirtualnej można wykonać w prosty sposób w konsoli. Takie podejście zostanie tutaj omówione. Osobom, które nie chcą szczegółowo wgłębiać się w poszczególne parametry i czytać dokumentację VBoxManage, polecam jednak interfejs graficzny. Tam wygodny kreator poprowadzi nas za rękę i znaczną część pracy zrobi za nas w tle. Później dla przećwiczenia polecam przygotowanie odpowiednich poleceń konsoli, które zrobią dokładnie to samo, co wcześniej ustawiliśmy w narzędziu graficznym.

Tworzenie wirtualnej maszyny dla Windows7 może składać się z następujących kroków:

Utworzenie i automatyczne zarejestrowanie wirtualnej maszyny dla 32-bitowego Windows7:
```
VBoxManage createvm --name Windows7_01 --ostype Windows7 --register
```

Szczegółowa konfiguracja parametrów wirtualnej maszyny (szczegóły można doczytać w dokumentacji polecenia modifyvm):

VBoxManage modifyvm Windows7_01 --memory 1780 --vram 40 --accelerate3d on --accelerate2dvideo on --boot1 dvd --boot2 disk --boot3 none --cpus 2 --pae on --hwvirtex on --largepages on --ioapic on --clipboard bidirectional --usb on --usbehci on

Udostępnianie lokalnego katalogu dla zwirtualizowanego systemu:

VBoxManage sharedfolder add Windows7_01 --name "share" --hostpath "/home/windows/share"

Utworzenie kontrolerów IDE i SATA dla nośników danych:

VBoxManage storagectl Windows7_01 --name "Kontroler SATA" --add sata --hostiocache on --controller IntelAhci
VBoxManage storagectl Windows7_01 --name "Kontroler IDE" --add ide --hostiocache on --controller PIIX4

Utworzenie i podpięcie dysku twardego (dysk rozszerzalny o maksymalnym rozmiarze 60GB):

VBoxManage createhd --filename /home/windows/.VirtualBox/HardDisks/Windows7_01.vdi --size 60000
VBoxManage storageattach Windows7_01 --storagectl "Kontroler SATA" --port 0 --device 0 --type hdd --medium /home/windows/.VirtualBox/HardDisks/Windows7_01.vdi

Podłączenie napędu CD/DVD z włączoną funkcją zapisu (oczywiście ma to sens jeśli mamy nagrywarkę):

VBoxManage storageattach Windows7_01 --storagectl "Kontroler IDE" --port 1 --device 1 --type dvddrive --medium host:/dev/sr0 --passthrough on

Tak przygotowana maszyna powinna być już widoczna i gotowa do uruchomienia z poziomu okienkowego interfejsu VirtualBoxa.

Zarządzanie VirtuaBoxem z poziomu konsoli
Do innych czynności, które możemy wykonać w konsoli można zaliczyć:

Uruchamianie maszyny wirtualnej. Maszynę możemy uruchamiać na dwa sposoby:
```
VBoxManage startvm Windows7_01
VirtualBox -startvm Windows7_01
```
Generalnie skutek wykonania obu poleceń będzie ten sam. Jedyną różnicą jaką ja zauważyłem jest uruchomienie zadania w tle przez pierwsze polecenie, w odróżnieniu od drugiego polecenia, gdzie wiersz polecenia oczekuje na zamkniecie programu VirtualBox. To drugie polecenie przyda się właśnie na etapie konfiguracji GDM (opis w dalszej części poradnika).
Rejestrowanie maszyny wirtualnej. Przydaje się szczególnie jeśli przekopiujemy maszynę na inny komputer i chcemy z niej korzystać.
```
VBoxManage registervm /home/windows/.VirtualBox/Machines/Windows7_01/Windows7_01.xml
```
Wyrejestrowywanie. Jeśli maszyna nie będzie dłużej wykorzystywana na bierzącym komputerze, bo np. została przeniesiona na inny, warto ją usunąć z wewnętrznego rejestru maszyn wirtualnych VirtualBoxa.
```
VBoxManage unregistervm Windows7_01
```

Tworzenie kopii maszyny wirtualnej
Kiedy mamy już przygotowaną wzorcową maszynę wirtualną z Windows7 i chcielibyśmy ją powielić na inne komputery, warto najpierw zmniejszyć rozmiar wirtualnego dysku. W tym celu należy wykonać dwie czynności:

Zerowanie pustych bloków na dysku w Windows7 (uwaga: dysk musi być w trybie normal, a nie immutable - tryby te opisane są w dalszej części poradnika). Pomocne w tej czynności będzie małe narzędzie sdelete, które można pobrać ze strony Technet Microsoft (link do narzędzia). W wierszu poleceń w systemie Windows wpisujemy:
```
sdelete -c
```

Kompaktowanie dysku w VirtualBox. Stosujemy polecenie:

VBoxManage modifyhd /home/windows/.VirtualBox/HardDisks/Windows7_01.vdi --compact

Zabiegi te w moim wypadku pozwoliły na odchudzenie dysku wirtualnego z 9.4GB na 8.3GB. Ten 1GB potrafi zrobić różnicę podczas klonowania wielu dysków wirtualnych i ich późniejszego kopiowania na inne komputery.

Kolejnym krokiem jest tzw. proces klonowania dysku. Jest to nic innego jak jego kopiowanie z nadaniem mu unikalnego identyfikatora.

VBoxManage clonehd /home/windows/.VirtualBox/HardDisks/Windows7_01.vdi /home/windows/.VirtualBox/HardDisks/Windows7_02.vdi --format VDI

Na sam koniec, kiedy przekopiujemy katalog z ustawieniami maszyny wirtualnej oraz dysk wirtualny na inny komputer warto się upewnić, że są ustawione odpowiednie prawa dostępu dla użytkownika windows:

sudo chown windows -R /home/windows/.VirtualBox
sudo chgrp windows -R /home/windows/.VirtualBox

Blokada dysków do zapisu
Dyski w VirtualBoxie mogą pracować w różnych trybach zapisu (po szczegóły odsyłam do oficjalnej dokumentacji). Co ciekawe przełaczać się między tymi trybami można jedynie za pomocą narzędzia VBoxManage - okienkowa wersja tego nie umożliwia. Mnie osobiście poza standardowym trybem normal, zainteresował szczególnie tryb immutable, który nie zezwala na zapisywanie trwałych zmian na wirtualnym dysku. Dzięki temu po każdych zajęciach ze studentami, system Windows jest przywracany do pierwotnego, wzorcowego stanu.

Technicznie działa to w ten sposób, że wszystkie zmiany jakie wprowadzi użytkownik podczas pracy w systemie zapisywane są na tak zwanym dysku różnicowym. Stan tego dysku jest resetowany po każdym wyłączeniu maszyny. W przypadku restartu maszyny stan nie jest kasowany, co ma zabezpieczać naszą tymczasową pracę na wypadek zawieszenia się systemu goszczącego (w tym wypadku Windows7).

Do przełączania między tymi dwoma stanami najwygodniej będzie przygotować osobne skrypty:

Przejście z trybu normal do immutable:

#!/bin/bash

VBoxManage storageattach Windows7_01 --storagectl "Kontroler SATA" --port 0 --device 0 --type hdd --medium none
VBoxManage modifyhd /home/windows/.VirtualBox/HardDisks/Windows7_01.vdi settype immutable
VBoxManage storageattach Windows7_01 --storagectl "Kontroler SATA" --port 0 --device 0 --type hdd --medium /home/windows/.VirtualBox/HardDisks/Windows7_01.vdi

echo `date`" : convert normal to immutable" >> vm_log.txt

Przejście z trybu immutable do normal:

#!/bin/bash

VBoxManage storageattach Windows7_01 --storagectl "Kontroler SATA" --port 0 --device 0 --type hdd --medium none
VBoxManage modifyhd /home/windows/.VirtualBox/HardDisks/Windows7_01.vdi settype normal

for file in `ls /home/windows/.VirtualBox/Machines/Windows7_01/Snapshots/*.vdi`
do
  VBoxManage closemedium disk $file --delete
done

VBoxManage storageattach Windows7_01 --storagectl "Kontroler SATA" --port 0 --device 0 --type hdd --medium /home/windows/.VirtualBox/HardDisks/Windows7_01.vdi

echo `date`" : convert immutable to normal" >> vm_log.txt

W obu skryptach pierwszą i ostatnia czynnością jest odpowiednio odłączenie i podłączenie dysku do wirtualnego kontrolera SATA. W drugim skrypcie mamy dodatkowo odłączenie i skasowanie dysków różnicowych. Czynność ta zapewnia poprawną pracę w trybie normal i umożliwia wprowadzania dalszych zmian na wzorcowych dyskach wirtualnych (np. doinstalowanie kolejnych programów niezbędnych do zajęć).

Konfiguracja GDM
Do tej pory opisywane kroki należały raczej do standardowych czynności administracyjnych dotyczących zarządzania wirtualna maszyną VirtualBox. Jakiejś szczególnej wygody, o której jest mowa w tytule nie widać. Trzeba się zwyczajnie zalogować do systemu, uruchomić VirtualBoxa i wystartować maszynę z Windows7. Może nie jest to jakość szczególnie skomplikowane, ale każdorazowo wymaga wykonania kilku tych samych czynności. Aby to zmienić i nieco usprawnić uruchamianie Windowsa można przygotować specjalną sesja dla menadżera logowania GDM. Dzięki temu już podczas logowania użytkownik będzie mógł wybrać sesję z VirtualBoxem i automatycznym startem maszyny wirtualnej.

Na początek tworzymy i edytujemy skrypt vm_start.bsh do uruchamiania maszyny wirtualnej:

#!/bin/bash
VirtualBox -startvm Windows7_01

Później tworzymy nowy plik z ustawieniami dla sesji GDM:

sudo touch /usr/share/xsessions/windows7.desktop
sudo nano /usr/share/xsessions/windows7.desktop

do którego wpisujemy takie ustawienia:

[Desktop Entry]
Encoding=UTF-8
Name=Windows7
Comment=Sesja skonfigurowana dla użytkownika "windows". Dla pozostałych nie działa.
Exec=/home/windows/.VirtualBox/vm_start.bsh
TryExec=/home/windows/.VirtualBox/vm_tools/vm_start.bsh
Icon=
Type=Application

Teraz wystarczy się już wylogować i zalogować ponownie wybierając z listy sesję "Windows7". Powininna wystartować sama maszyna wirtualna bez startu sesji środowiska Gnome. Po wyłączeniu Windows w maszynie wirtualnej zamknie nam się również VirtualBox i zostaniemy automatycznie wylogowani z systemu.

Logowanie bez podawania hasła
Aby jeszcze bardziej ułatwić dostęp do Windowsa można wyłączyć konieczność podawania hasła przez użytkownika "windows". W tym celu logujemy się na konto z uprawnieniami roota i zmieniamy ustawienia użytkownika "windows" ustawiając opcję "Bez pytania o hasło przy logowaniu". Dzięki temu przy kolejnym logowaniu nie będzie trzeba podawać hasła i od razu wystartuje maszyna wirtualna. Warto również zwrócić uwagę, że dla użytkownika "windows" nie będzie już możliwości zmiany sesji na inną (nie pojawi się okienko wyboru sesji, tylko użytkownik od razu zostanie zalogowany). Jeśli zależało by nam jednak na tym, aby znowu z poziomu użytkownika "windows" dostać do Gnome, w celu zmiany jakichś ustawień, to na powrót ustawiamy konieczość podawania hasła przez tego użytkownika. Można to również zrobić z linii komend poleceniem:

Logowanie bez podawania hasła:

sudo usermod -a -G nopasswdlogin windows

Konieczność podawania hasła:
```
sudo gpasswd -d windows nopasswdlogin 
```

Problemy i rozwiązania
Jedynym problemem jaki do tej pory spotkałem w korzystaniu z VirtualBoxa, było okresowe blokowanie się klawiatury w maszynie goszczącej. Zauważyłem, że dzieje się to zawsze po dłuższym czasie braku aktywności na komputerze, kiedy włączy się wygaszać ekranu w Ubuntu. Rozwiązanie oczywiście jest banalne - wystarczy wyłączyć wygaszać dla użytkownika "windows". W menu otwieramy kolejno: System → Preferencje → Wygaszacz ekranu i dla pewności ustawiamy:

Przejęcie w stan bezczynności po: 2 godzinach
Uruchomienie wygaszacza ekranu gdy komputer jest w stanie bezczynności: wyłączyć
Blokowanie ekranu, gdy wygaszacz jest aktywny: wyłączyć

Podsumowanie
Przedstawiony poradnik oczywiście nie wyczerpuje tematu konfiguracji VirtualBoxa w Linuksie. Nie jest to prawdopodobnie również jedyne rozwiązanie postawionych problemów, a pewne rzeczy może dało by się zrobić lepiej. Co sądzicie? Czekam na komentarze i spostrzeżenia z używania tego poradnika. Tylko proszę nie pisać do mnie per Pan, bo przecież nie jesteśmy na zajęciach, tylko na blogu :)

Konfiguracja lokalnego serwera pakietów Apt-Cacher NG

2010-11-12T08:55:00.000+01:00

W ostatnim czasie stanąłem naprzeciwko wyzwania szybkiej wymiany komputerów i oprogramowania na salach dydaktycznych, którymi się opiekuję na Politechnice Krakowskiej. Całościowy poradnik z przebiegu tej pracy przygotuję niebawem, jednakże już dzisiaj chciałem się podzielić doświadczeniami z konfiguracji lokalnego serwera pakietów Apt-Cacher NG.

Jednym z systemów, który miał zostać zainstalowany na każdym z 20 nowych komputerów miał być Ubuntu 10.04.1 LTS w wersji 64 bitowej. Najpierw postanowiłem przeprowadzić próbną instalację na jednej z maszyn, a dopiero później na pozostałych. Nie wiem z jakich powodów, ale po instalacji systemu, instalacja dodatkowych pakietów, a raczej ich pobieranie z Internetu trwało ok. 3 godziny! Na to nie mogłem sobie pozwolić podczas właściwej instalacji, ponieważ na montaż sprzętu i instalację systemu przed pierwszymi zajęciami miałem niewiele więcej czasu. Dodam jeszcze, że instalator zakomunikował mi pobranie z Internetu ok. 350MB danych do aktualizacji.

Sytuację udało się opanować dzięki skonfigurowaniu jednego komputera jako lokalnego systemu pakietów. Jego rolą miało być buforowanie (w slangu polsko-angielskim można by powiedzieć keszowanie ;-) ) pakietów pobranych z Internetu i udostępnienie ich innym maszynom w sieci lokalnej. W tym momencie w Ubuntu najłatwiej to osiągnąć stosując narzędzie Apt-Cacher NG (strona projektu). Poniższy poradnik udało mi się przygotować na podstawie kilku materiałów z Internetu, do których odsyłam w razie problemów:

Konfiguracja lokalnego serwera pakietów

Uaktualniamy lokalną bazę repozytoriów i pobieramy najnowsze aktualizacje:

sudo apt-get update
sudo apt-get upgrade

Instalacja narzędzia apt-cacher-ng z repozytorium:

sudo apt-get install apt-cacher-ng

Konfiguracja serwera i klientów

Uwaga: Należy pamiętać o właściwym ustawieniu adresu IP lokalnego serwera pakietów. Ja używam IP: 192.168.120.102. Należy go oczywiście zmienić na własny.

Konfigurujemy system pakietów apt (aplikacje apt-get, aptitude i inne), aby używał apt-cacher-ng:

sudo echo 'Acquire::http { Proxy "http://192.168.120.102:3142"; };' | sudo tee /etc/apt/apt.conf.d/01apt-cacher-ng-proxy

Możemy to oczywiście wyłączyć poleceniem:

sudo rm /etc/apt/apt.conf.d/01apt-cacher-ng-proxy

Konfiguracja Synaptic z konsoli:

Uwaga: Jeśli pracujemy na nowym komputerze zaraz po instalacji, należy najpierw uruchomić na nim Synaptica i odświeżyć listę pakietów. Można to zrobic również przez ssh łącząc się z opcją -X.
```
sudo grep --color -i 'proxy' /root/.synaptic/synaptic.conf || sudo nano /root/.synaptic/synaptic.conf
```
zamieniamy ostatnią linijkę, czyli znaki: ”};” na:
```
useProxy "1";
  httpProxy "192.168.120.102";
  httpProxyPort "3142";
  ftpProxy "192.168.120.102";
  ftpProxyPort "3142";
  noProxy "";
};
```
Sprawdzamy jeszcze raz, czy wprowadzone zmiany znajdują się w pliku:
```
sudo grep --color -i 'proxy' /root/.synaptic/synaptic.conf
```
Wczytujemy ponownie listę pakietów:
```
sudo apt-get update
```

Import lokalnych plików instalacyjnych

Uwaga: Poniższe czynności wykonujemy tylko na serwerze!

W tym kroku zostaną zaimportowane lokalne pliki *.deb do repozytorium apt-cacher-ng. Dzięki temu narzędzie apt-cacher-ng nie będzie pobierać ponownie już raz pobranych plików.

test -x /var/cache/apt-cacher-ng/_import || sudo mkdir -p -m 2755 /var/cache/apt-cacher-ng/_import
sudo mv -uf /var/cache/apt/archives/*.deb /var/cache/apt-cacher-ng/_import/

Rozpoczynamy importowanie uruchamiając skrypt znajdujący się w dostarczonym panelu kontrolnym: http://localhost:3142/acng-report.html?doImport=Start+Import#bottom

Panel kontrolny i dostęp do dokumentacji

Twórcy narzędzia Apt-Cacher NG przygotowali bardzo prosty panel kontrolny (Dashboard), w którym użytkownik może zobaczyć statystyki z jego działania. Jest on dostępny pod adresem: http://localhost:3142/acng-report.html.

Warto również zajrzeć do oficjalnej dokumentacji, która po instalacji pakietu będzie znajdować się w poniższej lokalizacji (można kliknąć link i otworzyć w przeglądarce): file:///usr/share/doc/apt-cacher-ng/html/index.html.

Własne spostrzeżenia

Już teraz, po pierwszych próbach muszę przyznać, że narzędzie to oszczędziło mi sporo czasu i oczywiście sporo nerwów (oczekiwanie na zakończenie aktualizacji, lub też na instalację dodatkowych programów niezbędnych do zajęć, potrafi być stresujące, jeśli te zajęcia rozpoczynają się za kilka minut). Dla przykładu pobranie aktualizacji na 20 maszynach z Ubuntu, nie trwało tak jak wcześniej wspominałem 3 godziny, a zaledwie 2 minuty. Taką różnicę naprawdę się czuje :-)

Poza aktualizacjami zainstalowałem też kilkanaście dodatkowych pakietów. Nie wiem ile to było MB dla jednego komputera, ale wiem ile to było w sumie dla wszystkich. Poniżej załączam zrzut ekranu z Panelu kontrolnego, prezentujące statystyki pobrań pakietów z lokalnego serwera pakietów:

Jak widać ok. 16 GB! danych zostało pobranych z lokalnego serwera pakietów. Jestem przekonany, że fakt ten tak samo cieszy (a może bardziej) administratorów naszej uczelnianej sieci i oczywiście administratorów głównych serwerów pakietów dla Ubuntu.

Pozostałe uwagi i spostrzeżenia przedstawiam już w skróconej formie:

Idea działania Apt-Cacher NG jest taka, że po instalacji danego pakietu z dowolnego komputera w sieci lokalnej, pakiet ten powinien być już dostępny dla innych maszyn na serwerze. Ja jednak dla pewności przyjąłem taką strategię, że dany pakiet najpierw instaluje na serwerze, a później na wszystkich klientach na raz.
Wydawać by się mogło, że importowanie pakietów trzeba wykonać tylko raz. Jednak zdarzyło mi się już kilka razy, że niektóre pakiety pomimo pierwszej instalacji z głównego serwera, znowu były z niego pobierane jeśli instalowałem go ponownie na innej maszynie. Po zauważeniu takiego faktu, warto ponownie zaimportować pakiety.
Wyliczanie statystyk transferu przez panel kontrolny potrafi zawiesić Apt-Cacher NG. Ostatnio 2-krotnie po uruchomieniu ich zliczania Apt-Cacher NG przestawał odpowiadać na zapytania maszyn klienckich. Możliwe, że po prostu nie radził sobie z analizą logów i gdzieś się zawieszał.

Moim zdaniem Apt-Cacher NG jest narzędziem jak najbardziej godnym polecenia.

Nowe witryny po wakacjach

2010-09-12T14:40:00.002+02:00

Na moim blogu w czasie wakacji (jak również wcześniej) niewiele się działo. Nie oznacza to wcale, że moja aktywność w sieci została zupełnie zawieszona. Korzystając z odrobiny wolnego czasu, którą udało mi się znaleźć pomiędzy innymi obowiązkami, uporządkowałem uprzednio prowadzone Wiki (nie podaje linku, ponieważ zostanie ono niedługo wyłączone) i przygotowałem dwie nowe witryny:

Moje zainteresowania naukowe i realizowane projekty [link]
	Strona zawiera opis moich zainteresowań naukowych oraz zestawienie programów, które udostępniłem jako Open Source. Aby dotrzeć do szerszego grona odbiorców jest ona prowadzona w języku angielskim.
Materiały dydaktyczne, kursy, poradniki [link]
	Tutaj będą umieszczane wszystkie materiały dydaktyczne, które przygotowuję na potrzeby prowadzonych przeze mnie zajęć. Dodatkowo, planuję umieścić na niej inne opracowania (np. poradniki techniczne), które do tej pory pisałem do własnych celów.

Obie witryny pomimo tego, że mają opracowaną strukturę treści, to zawierają tylko część materiałów, które docelowo planuję tam umieścić. Obie również prowadzone są w oparciu o mechanizm Wiki, dlatego treść nie zawsze będzie kompletna i dopracowana (teksty redaguję bezpośrednio na tych stronach, a nie wklejam gotowe z zewnętrznych edytorów).

Mam nadzieje, że będą one ciekawym uzupełnieniem dla obecnych (i przyszłych) czytelników bloga.

Moduły GUI do anlalizatora obrazu Pandore - Łączenie segmentów

2010-08-31T16:54:00.003+02:00

Pełny kod źródłowy

Korzystając wyłącznie z algorytmu działów wodnych podczas segmentacji obrazu trudno uzyskać zadowalające efekty. Algorytm ten zależy nie tylko od ilości i położenia punktów startowych, ale również od obrazu wskazującego krawędzie. Jak można było przeczytać (i zobaczyć) w poprzednim wpisie, często dla obrazów o zróżnicowanym tle i niejednorodnych obiektach ilość segmentów jest znacznie wyższa od tej, którą byśmy sami wskazali. Warto zdawać sobie sprawę, że wskazane problemy w podobnym stopniu dotyczą wszystkich algorytmów segmentacji. Dlatego, aby poprawić jakość wyników celowe może się okazać wprowadzenie kolejnego etapu przetwarzania obrazu. Najczęściej stosuje się różnego rodzaju metody łączenia segmentów, tak aby ich wielkość lepiej odpowiadała wielkości rzeczywistych obiektów. Na szczęście analizator obrazu Pandore posiada zestaw popularnych operatorów służących do tego celu. Jednak są to operatory bez graficznego interfejsu użytkownika, przez co ich stosowanie może być kłopotliwe zarówno dla nowego użytkownika, który musi nauczyć się składni poszczególnych poleceń, jak również dla bardziej doświadczonego użytkownika, których od razu chce zobaczyć efekty ich działania po zmianie odpowiednich parametrów. Dlatego, podobnie jak w przypadku działów wodnych, przygotowałem graficzny interfejs, który ma ułatwiać korzystanie z operatorów łączenia segmentów dostępnych w Pandore. Jego pełny kod źródłowy na licencji BSD został umieszczony w publicznym repozytorium na GitHub.

Interfejs użytkownika

Okienko programu podobnie jak w przypadku modułu działów wodnych zostało podzielone na dwie części: panel opcji i ramkę wyświetlającą obrazy wejściowe lub wyniki działania wybranego algorytmu. Obrazy wejściowe mogą zostać otwarte za pomocą menu [File]. Mamy tutaj do wyboru następujące opcje:

[Open oryginal image] - otwarcie oryginalnego obrazka, który służy jedynie do prezentacji wyników,
[Open image for computation] - otwarcie obrazka, na podstawie którego będą wykonywane obliczenia spójności sąsiednich regionów; obraz ten warto wcześniej przygotować (można np. usunąć szum),
[Open prelabeled image] - poindeksowany obraz segmentów przygotowany za pomocą algorytmu działów wodnych lub innego algorytmu segmentacji.

Każdy z obrazów wejściowych jest wyświetlany automatycznie po otwarciu. Można je oczywiście w każdym momencie obejrzeć korzystając z ramki [Display] na panelu opcji. Poza wyświetleniem obrazów wejściowych w oryginalnej formie (3 pierwsze obrazki na rysunku poniżej), dodano jeszcze trzy opcje prezentujące w sposób graficzny wyniki łączenia segmentów (3 kolejne obrazki na rysunku poniżej):

[Color labeled image] - dla każdego segmentu zostaje przypisany losowy kolor; jeśli wybrane kolory nie są najlepiej dobrane można losować do skutku,
[Image with transparen labels] - kolorowe segmenty nanoszone są na obraz wejściowy; użytkownik ma możliwość zmiany ich przezroczystości,
[Image with border of labels] - na obrazie oryginalnym zaznaczane są kontury segmentów; istnieje możliwość określenia koloru.

Możliwości

W chwili obecnej program zawiera prawie wszystkie operatory łączenia segmentów dostępne w Pandore. Nie ma na razie operatora pmumfordshahmerging, który ma inną strukturę parametrów wywołania w porównaniu do pozostałych operatorów. Listę dostępnych w programie operatorów można zobaczyć na rysunku poniżej. Są to odpowiednio:pcontrastmerging, pentropymerging, pmeanmerging, puniformitymerging, pvariancemerging, pboundarymerging, phistomerging (wymieniam ponownie dodając odnośniki do oficjalnej dokumentacji).

Wybór określonego algorytmu powoduje jego automatyczne uruchomienie, a co zatem idzie wyświetlenie wyników jego działania. Dla każdego algorytmu dostępny jest opis jego działania (przycisk [?]) pochodzący z oficjalnej dokumentacji Pandore (pomoc jest on-line, dlatego do jej działania wymagane jest aktywne połączenie z Internetem). Dostępne są również podpowiedzi na suwakach opcji [Number of merging] i [Threshold].

Opisany interfejs działa w trybie pełnej interakcji. Zmiana algorytmu lub jego parametrów skutkuje natychmiastowym wyświetleniem wyników. Na szybkich komputerach sprawdza się to bardzo dobrze. Na starszych maszynach czas oczekiwania może być zauważalny.

Sposób działania opisanego programu można prześledzić na dołączonym filmie video.

Oglądaj film w rozdzielczości HD na pełnym ekranie.

Moduły GUI do anlalizatora obrazu Pandore - Działy wodne

2010-08-11T14:48:00.016+02:00

Pełny kod źródłowy

Analizatora obrazu Pandore używam już od dłuższego czasu. Pomimo tego, że do większości zadań pisanie skryptów w konsoli jak najbardziej mi odpowiada, to czasami brakuje mi okienkowego interfejsu użytkownika, który mógłby przyspieszyć poszukiwanie optymalnych parametrów, dla poszczególnych operatorów. Częściowo w takich sytuacjach można posłużyć się interfejsem Ariane, o którym pisałem jakiś czas temu. Niestety każdorazowa edycja parametrów zapisanych w bloczkach i późniejsze wyświetlenie wyniku wymagają kilku kliknięć, a to wcale nie przyśpiesza pracy. Dlatego postanowiłem napisać własne (mini) programy, aby jeszcze bardziej usprawnić interakcję z użytkownikiem. Korzystając z biblioteki Qt, przygotowałem dwie aplikacje (możliwe, że pojawi się więcej), które bardziej szczegółowo opiszę w tym i następnym wpisie. Pełny kod źródłowy na licencji BSD został umieszczony w publicznym tepozytorium na GitHub.

Pierwsza aplikacja (używam też nazwy moduł GUI) została poświęcona algorytmowi Działów wodnych. Jej celem jest nie tylko uruchomienie tego algorytmu, ale również odpowiednie przygotowanie danych wejściowych. Dla niewtajemniczonych przypomnę, że algorytm ten umożliwia segmentację obrazu - rozbicie na obszary, które powinny odpowiadać rzeczywistym obiektom. Jego działanie zależy od właściwego przygotowanie obrazów wejściowych. Jednym z nich powinien być obraz wskazujący punkty (lub obszary) startowe, od których rozpoczyna się proces tzw. zalewania. Drugi obraz określa obszar i kierunek, w którym to zalewanie następuje (więcej na ten temat poniżej).

Interfejs użytkownika

Okienko programu zostało podzielone na dwie części - lewa zawiera panel opcji, natomiast prawa podgląd obrazów wejściowych lub wyniki segmentacji. Obraz po wczytaniu (menu [File] → [Open oryginal image]) można poddać operacji negatywu [Invert] lub rozmyciu [Blur]. Ta druga operacja jest szczególnie zalecana ponieważ usuwa nadmiar szumu z obrazu, a tym samym zmniejsza ilość wynikowych segmentów. Następna opcja na panelu [Show] pozwala obejrzeć obraz, na podstawie którego wyliczany jest obszar zalewania (opcja [Image for computations]). Obraz ten można przygotować na dwa sposoby (panel [Set image for computations]):

Obraz gradientowy [Gradient image] - wskazuje na granice obiektów,
Mapa odległości [Distance map] - określa odległość od wcześniej obliczonych obiektów z wykorzystaniem opcji [Binary image] na panelu [Set initial image].

Punkty startowe [Show] → [Initial image] dla algorytmu działów wodnych można wyznaczyć na kilka sposobów (panel [Set initial image]):

Lokalne minima [Local minimum point] - punkty, których wszystkie sąsiednie punkty mają wyższe wartości,
Obraz binarny [Binary image] - każdy obiekt jasny (biały) będzie podstawą do zbudowania osobnego segmentu,
Ręczne zaznaczenie obszarów startowych [Marker].

A teraz krótko, co jest pod maską aplikacji, czyli jakie operatory Pandore są używane:

pgaussianfiltering - rozmycie obrazu filtrem Gaussa,
pbinarization - binaryzacja obrazu,
psobel - jeden z operatorów gradientu,
pdistance - mapa odległości,
plocalminima - wyliczanie lokalnych minimów,
pwatershed - algorytm działów wodnych.

Możlwości

Poniżej zostaną wskazane przykładowe sposoby wykorzystania aplikacji. Nie każda kombinacja omówionych powyżej opcji ma sens, dlatego posłużę się dwoma różnymi obrazami - obrazem naturalnym przedstawiającym chłopca w kapeluszu (przykład 1 i 2) i obrazem pokazującym kilka podobnych elementów (przykład 3, 4 i 5).

1. Automatyczna segmentacja obiektów.

obraz do obliczeń: [Gradient image]
punkty startowe: [Local minima point]

Komentarz: Pomimo rozmycia obrazu filtrem Gaussa o wartości sigma = 1,1 otrzymano znaczne rozdrobnienie segmentów. Dalsze zwiększanie tej wartości skutkowało powstawaniem błędnych obiektów, które zawierały fragmenty dwóch obiektów.

2. Manualna segmentacja obiektów.

obraz do obliczeń: [Gradient image]
punkty startowe: [Marker]

Komentarz: Zastosowanie obrazu gradientowego i manualnie wskazywanych znaczników (markerów) pozwala na poprawną segmentację obiektów.

3. Wyznaczenie strefy wpływu poszczególnych obiektów.

obraz do obliczeń: [Distance map]
punkty startowe: [Binary image]

Komentarz: Algorytm działów wodnych może służyć do wyznaczenia tzw. strefy wpływu poszczególnych obiektów. W tym celu należy wykonać binaryzację obrazu (tutaj wartość progowa wynosiła 100) i policzyć mapę odległości.

4. Automatyczna segmentacja obiektów.

obraz do obliczeń: [Gradient image]
punkty startowe: [Binary image]

Komentarz: Korzystając z wcześniej przygotowanego obrazu binarnego i obrazu gradientowego można wyznaczyć granice obiektów. Niestety został pominięty jeden element na obrazie. Powodem tego jest brak punktu startowego wskazującego tło. Można to oczywiści rozwiązać w podejściu automatycznym, jednak aplikacja nie ma na razie takiej opcji. Jak to zrobić za pomocą Pandore, opiszę niebawem.

5. Manualna segmentacja obiektów.

obraz do obliczeń: [Gradient image]
punkty startowe: [Marker]

Komentarz: Wskazany powyżej problem można oczywiście rozwiązać poprzez manualne zaznaczenie wszystkich obiektów i tła.

Aby prześledzić sposób obsługi programu zachęcam do obejrzenia krótkiego filmu. Zostały na nim jeszcze raz pokazane wszystkie opisane przed chwilą przypadki użycia, co powinno jeszcze lepiej przybliżyć czytelnikowi możliwości jego działania.

Oglądaj film w rozdzielczości HD na pełnym ekranie.

Zbiory ogólnodostępnych obrazów medycznych

2010-07-23T15:51:00.006+02:00

Trudno zajmować się przetwarzaniem obrazów medycznych, nie mając dostępu do takich danych. Najlepiej oczywiście mieć stalą współpracę z dużym szpitalem, który ma dobrze zorganizowany zakład radiologiczny lub też mieć znajomego lekarza, który z chęcią podzieli się takimi obrazami i dodatkowo wskaże problem badawczy. Jeśli jednak nie mamy tego szczęścia, to nic straconego, ponieważ zawsze można skorzystać z publicznie dostępnych zbiorów w Internecie. Do ich poszukiwania skłoniła mnie potrzeba lepszego przetestowania algorytmu nad którym ostatnio pracowałem, a do tej pory miałem do dyspozycji jedynie kilkanaście obrazów.

Poniższa lista nie zawiera opisu baz danych - tego jak i przez kogo zostały organizowane. Zawiera jedynie praktyczne wskazówki odnośnie możliwości dostępu do tych danych i ich wykorzystania we własnej pracy (ograniczenia licencyjne). Pozostałe informacje można znaleźć nie tylko na wskazanych stronach, ale również przy poszczególnych obrazach (jak i gdzie zostały zrobione).

Casimage - jedna z najstarszych baz danych, liczy ok. 10 000 obrazów. Sprawia wrażenie już nie rozwijanej (linki do strony organizatorów nie działają). Brak jednego archiwum danych. Dostęp jest możliwy przez interfejs WWW. Obrazy można pobierać indywidualnie. Na szczęście obrazy umieszczone są na serwerze począwszy od pliku 0 do 9735. Dzięki temu można szybko pobrać je korzystając z przygotowanego przeze mnie skryptu [linux, wget]:
```
for i in $(seq 9735); do wget "http://pubimage.hcuge.ch/4DCGI/FULLIMAGE/$i"; echo $i; done
```
Niestety nie wszystkie pliki chcą się od razu pobrać, dlatego polecam kilkukrotne uruchomienie nieznacznie zmodyfikowanej wersji poprzedniego skryptu:
```
#!/bin/bash
for i in $(seq 9735)
do
  if [ ! -f $i ]
  then
    wget "http://pubimage.hcuge.ch/4DCGI/FULLIMAGE/$i";
    echo $i;
  fi
done
```
RSNA - zbiór baz danych zorganizowanych przez Stowarzyszenie Radiologów Ameryki Północnej. Dostęp do wielu medycznych baz danych za pomocą interfejsu WWW.
MyPacs - prawdopodobnie największy (ok. 120 000) publicznie dostępny zbiór obrazów medycznych. Dostęp przez interfejs Flash, bez możliwości pobierania danych. Możliwość taka jest po przełączeniu się do uproszczonego trybu html.
MedGift - demo systemu wyszukiwania obrazów MedGift, który bazuje na innym systemie, a mianowicie: Gift. Dane pochodzą prawdopodobnie z bazy Casimage. Zaletą tego systemu jest możliwość szybkiego stworzenia zbioru podobnych obrazów, co w przypadku pozostałych baz trzeba zrobić samemu (lub można skorzystać z zaproponowanego podziału na kategorie).
MedPix - druga co do wielkości baza obrazów. Dostępny interfejs WWW utrudnia pobieranie obrazów (zablokowany prawy przycisk myszy). Można się jednak do nich dostać przez Google Images (link do wyszukiwania). Niestety obrazki mają dodane wizualne adnotacje, co jeszcze bardziej utrudnia swobodne ich przetwarzanie.
IRMA - zbiór ok. 15 000 obrazów podzielonych na ok. 200 kategorii. Dostęp do archiwum z plikami możliwy jest po podpisaniu warunków użycia (do zastosowań naukowych, nie komercyjnych, bez możliwości udostępniania pełnego zbioru dalej) i przefaksowaniu na podany adres.
ImageCLEF - ok 80 000 obrazów, dostępnych prawdopodobnie w postacie jednego lub kilku archiwów. Obrazy pochodzą m.in. z bazy IRMA, Casimage. Warunki użycia są podobne jak w przypadku bazy IRMA, tylko muszą one zostać podpisane przez osobę na stanowisku kierowniczym w jednostce naukowej.
Midas - baza danych pod patronatem firmy Kitware, która patronuje m.in. VTK i Insight Toolkit. Związana z elektronicznym czasopismem naukowym Insight Journal. Obrazy dostępne przez interfejs WWW najczęściej w formatach źródłowych: DICOM lub binarnym.
Springer Images - obrazy dołączone do publikacji Springer. Każdy obraz ma indywidualną licencję jednak w trakcie wyszukiwania można wybrać grupę licencji otwartych.
Images from the History of Medicine (NLM) - obrazy związane z historią medycyny zebrane przez National Library of Medicine USA.

Poza wyżej wymienionymi bazami danych warto jeszcze zajrzeć na spis plików opracowany na stronie biblioteki GDCM (link) oraz programu OsiriX (link).

Mam nadzieje, że przedstawione przeze mnie bazy obrazów medycznych pozwolą czytelnikowi na znalezienie ciekawego materiału badawczego i zaowocują powstaniem ciekawych prac naukowych. Powodzenia.