Individální projekty MPOA

Tato stránka je pouze pro čtení. Můžete si pouze prohlédnout zdrojový kód, ale ne ho měnit. Zeptejte se správce, pokud si myslíte, že něco není v pořádku.
========= Zpracování obrazu na Raspberry Pi ======

Vypracoval: Tomáš Bravenec

===== Zadání =====
Naprogramujte aplikaci pro segmentaci a zpracování obrazu určenou pro běh v operačním systému Raspbian na platformě Raspberry Pi 3 Model B. Mezi implementovanými metodami pro zpracování obrazu by mělo být prahování, detekce hran a K-Means clustering. Samotný výpočet by měl probíhat s využitím volitelného množství jader procesoru. Aplikace by též měla obsahovat grafické rozhraní pro volbu obrazu, nastavení pro zpracování a zobrazení vstupu a výstupu.c

----

====== Úvod ======

===== Raspberry Pi 3 Model B =====

====== Implementace ======
Aplikace byla vytvořena s využitím knihoven gtkmm, OpenCV 4 a OpenMP. Pro kompilaci je navíc potřeba mít nainstalovaný balíček Cmake. V případě použití knihoven OpenCV jiné verze než 4, bude potřeba změnit cesty u #include direktiv, jenž počítají s OpenCV 4. Pro snadnou kompilaci OpenCV, stačí následovat  tento návod:[[https://www.pyimagesearch.com/2018/08/15/how-to-install-opencv-4-on-ubuntu/|Kompilace OpenCV]]

Pro úspěšnou kompilaci musí být v systému také nainstalovány balíčky:
  * libgtkmm-3.0-dev
  * libglibmm-2.4-dev
  * libomp-dev

Kompilace samotné aplikace, poté co jsou zajištěny všechny závislosti probíhá dvěma příkazy v terminálu:
  - cmake .
  - make

Nebo jejich kombinací:
  * cmake . && make


===== Grafické rozhraní =====
Pro tvorbu grafického rozhraní bylo využito GTK, přesněji knihovny gtkmm, která je objektovou verzí knihoven GTK určenou pro C++. Samotné rozhraní bylo vytvořeno pomocí programu Glade, který vygeneruje soubor strukturu xml s popisem všech widgetů v okně. 

Celé grafické rozhraní je vytvořeno jako třída, obsahující ukazatele na jednotlivé ovládací prvky, callback funkce reagující na stisky tlačítek a změnu nastavení, vstupní a výstupní obraz. Struktura třídy je v následujícím kódu:
<code cpp>
class ApplicationGUI
{
private:
    Gtk::ComboBox *method;
    Gtk::ComboBox *implementation;
    Gtk::MenuItem *menuItemOpen;
    Gtk::MenuItem *menuItemSave;
    Gtk::MenuItem *menuItemClose;
    Gtk::MenuItem *menuItemStart;
    Gtk::MenuItem *menuItemClear;
    Gtk::MenuItem *menuItemAbout;
    Gtk::SpinButton *cores;
    Gtk::Image *inputImageBox;
    Gtk::Image *outputImageBox;
    Gtk::AboutDialog *aboutDialog;
    Glib::RefPtr<Gtk::Builder> builder;

    cv::Mat inputImage;
    cv::Mat outputImage;

    Glib::RefPtr<Gdk::Pixbuf> inputPixbuf;
    Glib::RefPtr<Gdk::Pixbuf> outputPixbuf;

    void on_method_changed();
    void on_implementation_changed();
    void on_gtkMenuItem_open_activate();
    void on_gtkMenuItem_save_activate();
    void on_gtkMenuItem_Start_activate();
    void on_gtkMenuItem_Clear_activate();
    void on_gtkMenuItem_About_activate();
    Gtk::Main main;
    Gtk::Window *window;
public:
    ApplicationGUI();
    ~ApplicationGUI();
    void run() { main.run(*window); }
};
</code>

===== Vícejádrové zpracování dat =====
Zpracování obrazu pomocí procesoru je časově náročné, z důvodu obrovského množství dat, je výhodné využít všechna dostupná jádra procesoru pro rychlejší zpracování. Pro snadnou paralelizaci cyklů existuje knihovna OpenMP, která umožňuje zparalelizovat cykly pouhým přidáním direktivy preprocesoru před cyklus který chcme provést paralelně. Pokud je více cyklů vnořených, paralelizován bude pouze ten, který má před svým začátkem direktivu preprocesoru. Ve výchozím nastavení ovšem tento výpočet bude provádět na dynamicky voleném počtu vláken, proto pokud chceme pevně nastavit kolik vláken může aplikace pro průběh cyklu využít, musíme vypnout dynamickou volbu počtu jader a následně nastavit kolik vláken se může použít. Použití funkcí a direktivy OpenMP je v následující ukázce kódu, která má za úkol projít všechny pixely v obraze, zatímco všechny pixely v jednom řádku zpracovává jedno vlákno:
<code cpp>
#include <omp.h>

omp_set_dynamic(0);
omp_set_num_threads(threads);

#pragma omp parallel for
for(int h = 0; h < image.rows; h++)
{
    for(int w = 0; w < image.cols; w++)
    {
        /* Code */
    }
}        
</code>
Za zmínku stojí také to, že v takto paralelizovaných cyklech není možné využívat proměnné definované jen pro jedno vlákno, jelikož by začalo docházek k souběhu (anglicky Race Condition) a aplikace by nepodávala správné výsledky.
Knihovna OpenMP obsahuje mnohem více funkcí a direktiv, určených pro paralelizaci, pro danou aplikaci ovšem nebyly potřeba.

===== Prahování =====
Funkce prahování patří mezi nejsnazší operace které lze s obrazem provést. Na její vstup je přiveden obraz v odstínech šedi a pokud jas pixelu přesáhne zvolený práh je nastaven na maximální hodnotu jasu a naopak, pokud je jas pixelu pod prahem, je nastaven na nulu. Z ukázky kódu je vidět mimo samotné prahování, i nastavení paralelního zpracování pomocí OpenMP. 
<code cpp>
cv::Mat threshold(cv::Mat image, unsigned char thresh, unsigned char max, int threads)
{
    omp_set_dynamic(0);
    omp_set_num_threads(threads);

     unsigned char *data = image.data;

#pragma omp parallel for
    for(int h = 0; h < image.rows; h++)
    {
        for(int w = 0; w < image.cols; w++)
        {
            if(data[h * image.cols + w] <= thresh)
            {
                data[h * image.cols + w] = 0;
            }
            else
            {
                data[h * image.cols + w] = max;
            }
        }
     }
     
     return image;
}
</code>
Za zmínku stojí využití dvourozměrného indexování v jednorozměrném poli. Kdy se indexem řádku vynásobí počet sloupců, což posune index vždy na začátek daného řádku. Index sloupce se poté jen normálně přičte.

Výstupem metody prahování může být například:

/* ToDo */

===== Detekce hran =====

==== Filter Sobel ====

==== Detektor hran - Canny ====

===== K-Means Clustering =====
K-Means clustering (česky shlukování do k středních hodnot, nebo pro obrazy barevná kvantizace), jedná se o algoritmus určený pro shlukování podobných dat. Na rozdíl od Prahování a detekce hran, které potřebují k získání výsledného stavu jen jeden průchod, K-Means clustering je iterační metoda, která skončí teprve poté co se od sebe výstup dvou po sobě jdoucích iterací neliší, nebo nedojde k zastavení po nastaveném množství iterací.

Pro snadné pochopení jak K-Means funguje v případě obrazů, si lze představit troj rozměrné pole se všemi stranami o délce 256 prvků (každá z os představuje jednu z barevných složek RGB). Pro začátek se náhodně zvolí K bodů (clusterů) z tohoto pole, načež se pro každý pixel vstupního obrazu vypočítá euklidovská vzdálenost ke každému z těchto bodů. Následně se zprůměrují hodnoty barevných složek které jsou nejblíže k jednomu z bodů a tento průměr se nastaví jako nový bod do další iterace. Toto se provede pro všech K bodů, a poté stále dokonal v dalších iteracích dokud se body budou v daném trojrozměrném poli posouvat.

Výstupem metody K-Means Clustering může být například:

/* ToDo */

====== Video ukázka ======

====== Zdrojový kód ======
Kompletní zdrojový kód aplikace je dostupný na GitLabu:

https://gitlab.com/tbravenec/image_processing_on_rpi

====== Reference ======
  * https://www.gtkmm.org/en/documentation.html
  * https://docs.opencv.org/2.4/doc/tutorials/imgproc/imgtrans/sobel_derivatives/sobel_derivatives.html
  * https://docs.opencv.org/2.4/doc/tutorials/imgproc/imgtrans/canny_detector/canny_detector.html
  * https://docs.opencv.org/2.4/modules/core/doc/clustering.html
  * https://www.datascience.com/blog/k-means-clustering
Individální projekty MPOA

Uživatelské nástroje

Nástroje pro tento web

Nástroje pro stránku
