From 798bd4f5d404fafa06e8129c6b6cdb7a566472a4 Mon Sep 17 00:00:00 2001 From: Dawid Pietrykowski Date: Fri, 14 Apr 2023 22:07:59 +0200 Subject: [PATCH] Added finished flood-fill --- QT/flood-fill/flood-fill.pro | 20 ++ QT/flood-fill/main.cpp | 33 ++++ QT/flood-fill/mywindow.cpp | 357 +++++++++++++++++++++++++++++++++++ QT/flood-fill/mywindow.h | 119 ++++++++++++ QT/flood-fill/mywindow.ui | 126 +++++++++++++ 5 files changed, 655 insertions(+) create mode 100644 QT/flood-fill/flood-fill.pro create mode 100644 QT/flood-fill/main.cpp create mode 100644 QT/flood-fill/mywindow.cpp create mode 100644 QT/flood-fill/mywindow.h create mode 100644 QT/flood-fill/mywindow.ui diff --git a/QT/flood-fill/flood-fill.pro b/QT/flood-fill/flood-fill.pro new file mode 100644 index 0000000..14f073f --- /dev/null +++ b/QT/flood-fill/flood-fill.pro @@ -0,0 +1,20 @@ +#------------------------------------------------- +# +# Project created by QtCreator 2015-03-03T00:14:51 +# +#------------------------------------------------- + +QT += core gui + +greaterThan(QT_MAJOR_VERSION, 4): QT += widgets + +TARGET = flood-fill +TEMPLATE = app + +OUTPUT += Console +SOURCES += main.cpp\ + mywindow.cpp + +HEADERS += mywindow.h + +FORMS += mywindow.ui diff --git a/QT/flood-fill/main.cpp b/QT/flood-fill/main.cpp new file mode 100644 index 0000000..2a67e1f --- /dev/null +++ b/QT/flood-fill/main.cpp @@ -0,0 +1,33 @@ +// Glowny plik aplikacji, utworzony automatycznie przez QtCreator +// W wiekszosci przypadkow nie musimy tu nic zmieniac + +// Dolaczamy plik naglowkowy klasy QApplication +#include + +// Dolaczamy plik naglowkowy klasy glownego widgetu (okna) aplikacji +#include "mywindow.h" + +int main(int argc, char *argv[]) +{ + + // Tworzymy objekt QApplication. Zarzadza on zasobami calej aplikacji + // i jest niezbedny do stworzenia jakiejkolwiek aplikacji Qt posiadajacej GUI. + // Przekazujemy mu dwa argumenty argc i argv, poniewaz Qt moze rowniez + // przyjmowac argumenty z linii komend. + QApplication a(argc, argv); + + // Tworzymy obiekt klasy MyWindow - glownego okna naszej aplikacji. + // Jest to klasa zdefiniowana przez nas. + // Jej definicja znajduje sie w plikach mainwindow.h i mainwindow.cpp + MyWindow w; + +// w.setMouseTracking(true); + // Pokazujemy glowne okno aplikacji na ekranie. Domyslnie jest ono niewidoczne. + // Wszystkie widgety (elementy GUI) zawarte w glownym oknie beda rowniez widoczne. + w.show(); + + // Przekazujemy kontrole nad aplikacja do Qt. Program wchodzi w petle zdarzen + // tzn. zaczyna oczekiwac na akcje uzytkownika - klikniecia przycisku myszy, + // lub klawisza klawiatury itp. + return a.exec(); +} diff --git a/QT/flood-fill/mywindow.cpp b/QT/flood-fill/mywindow.cpp new file mode 100644 index 0000000..8ad2060 --- /dev/null +++ b/QT/flood-fill/mywindow.cpp @@ -0,0 +1,357 @@ +// Dolaczamy plik naglowkowy naszej klasy MyWindow +#include "mywindow.h" + +// Dolaczamy plik naglowkowy zawierajacy definicje GUI +// Plik ten jest generowany automatycznie +// z pliku XML "mywindow.ui" +#include "ui_mywindow.h" + +#include +#include +#include +#include +#include +#include // for float,double macros +#include +#include + +#define PI 3.1415 + + + +// Definicja konstruktora, wywolujemy najpierw +// konstruktor klasy nadrzednej, nastepnie tworzymy +// obiekt klasy Ui_MyWindow reprezentujacy GUI +MyWindow::MyWindow(QWidget *parent) : + QMainWindow(parent), + ui(new Ui::MyWindow) +{ + // Wywolujemy funkcje tworzaca elementy GUI + // Jej definicja znajduje sie w pliku "ui_mywindow.h" + ui->setupUi(this); + + // Pobieramy wymiary i wspolrzedne lewego gornego naroznika ramki + // i ustawiamy wartosci odpowiednich pol + // Uwaga: ramke "rysujFrame" wykorzystujemy tylko do + // wygodnego ustaiwenia tych wymiarow. Rysunek bedziemy wyswietlac + // bezposrednio w glownym oknie aplikacji. + szer = ui->rysujFrame->width(); + wys = ui->rysujFrame->height(); + poczX = ui->rysujFrame->x(); + poczY = ui->rysujFrame->y(); + + // Tworzymy obiekt klasy QImage, o odpowiedniej szerokosci + // i wysokosci. Ustawiamy format bitmapy na 32 bitowe RGB + // (0xffRRGGBB). + img = new QImage(szer,wys,QImage::Format_RGB32); + img_tmp = new QImage(szer,wys,QImage::Format_RGB32); + active_img = img; + + czysc(); +} + +// Definicja destruktora +MyWindow::~MyWindow() +{ + delete ui; +} + +// Funkcja (slot) wywolywana po nacisnieciu przycisku "Wyjscie" (exitButton) +// Uwaga: polaczenie tej funkcji z sygnalem "clicked" +// emitowanym przez przycisk jest realizowane +// za pomoca funkcji QMetaObject::connectSlotsByName(MyWindow) +// znajdujacej sie w automatycznie generowanym pliku "ui_mywindow.h" +// Nie musimy wiec sami wywolywac funkcji "connect" +void MyWindow::on_exitButton_clicked() +{ + // qApp to globalny wskaznik do obiektu reprezentujacego aplikacje + // quit() to funkcja (slot) powodujaca zakonczenie aplikacji z kodem 0 (brak bledu) + qApp->quit(); +} + +// Funkcja "odmalowujaca" komponent +void MyWindow::paintEvent(QPaintEvent*) +{ + // Obiekt klasy QPainter pozwala nam rysowac na komponentach + QPainter p(this); + + // Rysuje obrazek "img" w punkcie (poczX,poczY) + // (tu bedzie lewy gorny naroznik) + p.drawImage(poczX,poczY,*active_img); +} + + +// Funkcja (slot) wywolywana po nacisnieciu przycisku "Czysc" (cleanButton) +void MyWindow::on_cleanButton_clicked() +{ + // Funkcja czysci (zamalowuje na bialo) obszar rysowania + // definicja znajduje sie ponizej + czysc(); + + // Funkcja "update()" powoduje ponowne "namalowanie" calego komponentu + // Wywoluje funkcje "paintEvent" + update(); +} + + +// Funkcja powoduje wyczyszczenie (zamalowanie na bialo) +// obszaru rysowania +void MyWindow::czysc() +{ +// shapes.clear(); +// shapes.push_back(Shape()); +// DrawShapes(); + ClearImage(img); +} + +void MyWindow::ApplyTempImage(){ + memcpy(img->bits(), img_tmp->bits(), szer * wys * 4); +} + +void MyWindow::UpdateTempImage(){ + memcpy(img_tmp->bits(), img->bits(), szer * wys * 4); +} + +QColor GetRandomColor(){ + QColor res; + res.setRed(rand() % 256); + res.setGreen(rand() % 256); + res.setBlue(rand() % 256); + res.setAlpha(255); + return res; +} +// Funkcja (slot) wywolywana po nacisnieciu przycisku myszy (w glownym oknie) +void MyWindow::mousePressEvent(QMouseEvent *event) +{ + UpdateTempImage(); + + // Pobieramy wspolrzedne punktu klikniecia + int x = event->x(); + int y = event->y(); + + // Sa to wspolrzedne wzgledem glownego okna, + // Musimy odjac od nich wpolrzedne lewego gornego naroznika rysunku + + x -= poczX; + y -= poczY; + + startX = x; + startY = y; + + active_img = img_tmp; + + draw_finished = false; + + mode = event->button() == Qt::LeftButton ? Circle : event->button() == Qt::RightButton ? Line : Fill; + + if(mode == Fill){ + FloodFill(img, x, y, QColor(0,0,0), GetRandomColor()); + + active_img = img; + + draw_finished = true; + + update(); + } + + update(); +} + + +void MyWindow::mouseMoveEvent(QMouseEvent *event) +{ + // Pobieramy wspolrzedne punktu klikniecia + int x = event->x(); + int y = event->y(); + + // Sa to wspolrzedne wzgledem glownego okna, + // Musimy odjac od nich wpolrzedne lewego gornego naroznika rysunku + + x -= poczX; + y -= poczY; + + if(x >= szer || y >= wys || x < 0 || y < 0 || draw_finished){ + ApplyTempImage(); + + active_img = img; + + draw_finished = true; + + update(); + + return; + } + + if(mode == Circle){ + DrawCircle(startX, startY, x, y); + }else if(mode == Line){ + DrawLine(startX, startY, x, y); + } + + // Odswiezamy komponent + update(); +} + +void MyWindow::mouseReleaseEvent(QMouseEvent *event){ + if(draw_finished) + return; + + ApplyTempImage(); + + active_img = img; + + draw_finished = true; + + update(); +} +//bool MyWindow::FindPoint(int x, int y, int& pt_id, int& shape_id, float radius){ +// for(int i = 0; i < (int)shapes.size(); i++){ +// int id; +// if((id = shapes[i].FindPoint(x, y, radius)) != -1){ +// shape_id = i; +// pt_id = id; +// return true; +// } +// } +// return false; +//} + +void MyWindow::DrawPixel(QImage* img, int x, int y, QColor color){ + if(x >= szer || y >= wys || x < 0 || y < 0) + return; + + unsigned char* ptr = img->bits(); + + ptr[szer*4*y + 4*x] = color.blue(); + ptr[szer*4*y + 4*x + 1] = color.green(); + ptr[szer*4*y + 4*x + 2] = color.red(); + ptr[szer*4*y + 4*x + 3] = color.alpha(); +} + +QColor MyWindow::GetPixel(QImage* img, int x, int y){ + QColor res; + if(x >= szer || y >= wys || x < 0 || y < 0) + return res; + + unsigned char* ptr = img->bits(); + + res.setBlue(ptr[szer*4*y + 4*x]); + res.setGreen(ptr[szer*4*y + 4*x + 1]); + res.setRed(ptr[szer*4*y + 4*x + 2]); + res.setAlpha(ptr[szer*4*y + 4*x + 3]); + + return res; +} + +void MyWindow::DrawLine(int x1, int y1, int x2, int y2, bool update_temp){ + if(update_temp) + UpdateTempImage(); + + unsigned char* ptr = img_tmp->bits(); + if(x1 > x2){ + std::swap(x1, x2); + std::swap(y1, y2); + } + float diff = x2 - x1; + float a = diff != 0 ? (y2 - y1) / diff : FLT_MAX; + + QColor color(255, 255, 255, 255); + + if(abs(a) < 1.0f){ + for(int x = x1; x <= x2; x++){ + int x_form = x - x1; + int y = a * x_form + y1; + + DrawPixel(img_tmp, x, y, color); + } + } + else{ + if(y1 > y2){ + std::swap(x1, x2); + std::swap(y1, y2); + } + float diff = x2 - x1; + float a = diff != 0 ? (y2 - y1) / diff : FLT_MAX; + for(int y = y1; y <= y2; y++){ + int y_form = y - y1; + int x = ((float)(y_form) / a) + x1; + + DrawPixel(img_tmp, x, y, color); + } + } +} + + +void MyWindow::DrawCircle(int x1, int y1, int x2, int y2){ + if(x2 >= szer || y2 >= wys || x2 < 0 || y2 < 0) + return; + + UpdateTempImage(); + + unsigned char *ptr; + ptr = img_tmp->bits(); + + float R = sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2)); + int q_last_x = R / sqrt(2) + 1; + + QColor color(255, 255, 255, 255); + + for(int x = 0; x <= q_last_x; x++){ + float y = sqrt(pow(R, 2) - pow(x, 2)); + + for(int k = 0; k < 2; k++){ + for(int i = 0; i < 2; i++){ + for(int j = 0; j < 2; j++){ + DrawPixel(img_tmp, x1 + x, y1 - y, color); + y *= -1; + } + x *= -1; + } + int tmp = x; + x = y; + y = tmp; + } + } +} + + +void MyWindow::FloodFill(QImage* img, int x0, int y0, QColor zamieniany_color, QColor nowy_kolor) { + std::stack> stack; + zamieniany_color = GetPixel(img, x0,y0); + stack.push(std::pair(x0, y0)); + while (!stack.empty()) { + int x = stack.top().first; + int y = stack.top().second; + stack.pop(); + + if (GetPixel(img, x, y) == zamieniany_color) { + int w = x; + int e = x; + while (GetPixel(img, w, y) == zamieniany_color) w--; + while (GetPixel(img, e, y) == zamieniany_color) e++; + for (int i = w+1; i< e; i++) + DrawPixel(img, i, y, nowy_kolor); + for (int i = w+1; i< e; i++) { + if (GetPixel(img,i,y+1) == zamieniany_color) + stack.push(std::pair(i, y+1)); + if (GetPixel(img,i,y-1) == zamieniany_color) + stack.push(std::pair(i, y-1)); + } + } + } + return; +} + +void MyWindow::ClearImage(QImage *img){ + unsigned char* empty_val = (unsigned char*)malloc(4); + empty_val[0] = 0; + empty_val[1] = 0; + empty_val[2] = 0; + empty_val[3] = 255; + unsigned char* ptr = img->bits(); + for(int i = 0; i < img->width(); i++){ + for(int j = 0; j < img->height(); j++){ + memcpy(ptr + 4 * (i + j * img->width()), empty_val, 4); + } + } +} diff --git a/QT/flood-fill/mywindow.h b/QT/flood-fill/mywindow.h new file mode 100644 index 0000000..47006a6 --- /dev/null +++ b/QT/flood-fill/mywindow.h @@ -0,0 +1,119 @@ +// Plik naglowkowy klasy MyWindow +// Obiekt tej klasy to glowne okno naszej aplikacji +// Szkielet tego pliku jest tworzony przez QtCreator +// Mozemy do niego dodac deklaracje wlasnych pol i metod + +#ifndef MYWINDOW_H +#define MYWINDOW_H + +// Dolaczamy plik naglowkowy klasy QMainWindow, +// Klasa QMainWindow posiada swoj wlasny layout. +// latwo mozna do niej dodac pasek menu, widzety dokujace, +// pasek narzedzi i pasek statusu. Na srodku okna +// wyswietlanego przez QMainWindow znajduje sie obszar, +// ktory mozna wypelnic roznymi widgetami. +#include + +// QPainter to klasa umozliwiajaca niskopoziomowe rysowanie +// na elementach GUI +#include + +// QImage to klasa pozwalajaca na niezalezna od sprzetu reprezentacje obrazu. +// Pozwala na bezposredni dostep do poszczegolnych pikseli, +// Bedziemy jej uzywali do tworzenia i przechowywania +// naszych rysunkow +#include + +// QMouseEvent to klasa obslugujaca zdarzenia zwiazane z myszka +// klikniecia, ruch myszka itp. +#include + +#include +#include // for float,double macros + +enum Mode {Line, Circle, Fill}; + +namespace Ui { + class MyWindow; +} + + +// MyWindow jest podklasa klasy QMainWindow. +class MyWindow : public QMainWindow +{ + // Q_OBJECT jest to makro, ktore musi sie znajdowac + // we wszystkich klasach definiujacych wlasne sygnaly i sloty + // W naszej klasie nie jest ono potrzebne, + // ale QtCreator dodaje je automatycznie do kazdej klasy. + Q_OBJECT + +public: + // Typowa deklaracja konstruktora w Qt. + // Parametr "parent" okresla rodzica komponenetu. + // W przypadku naszej klasy parametr ten wskazuje na null + // co oznacza, ze komponenet nie ma rodzica, jest to + // komponenet najwyzszego poziomu + explicit MyWindow(QWidget *parent = 0); + + // Deklaracja destruktora + ~MyWindow(); + +private: + // QtCreator pozwala na tworzenie GUI za pomoca graficznego kreatora. + // Skladniki interfejsu i ich wlasciwosci zapisane sa wowczas + // w pliku XML "nazwa_klasy.ui" + // Do poszczegolnych elementow GUI odwolujemy sie za pomoca zmiennej "ui" + Ui::MyWindow *ui; + + Mode mode; + + // Pole przechowujace obrazek + QImage *img; + // Pole przechowujace obrazek + QImage *img_tmp; + + QImage *active_img; + + // Pola przechowujace szerokosc i wysokosc rysunku + // oraz wspolrzedne jego lewego gornego naroznika + int szer; + int wys; + int poczX; + int poczY; + int startX, startY; + bool draw_finished; + int segment_count; + + int tmp_point_id = 0; + int tmp_shape_id = 0; + + // Deklaracje funkcji + void czysc(); + void rysuj1(); + void rysuj2(); + + + void DrawLine(int x1, int y1, int x2, int y2, bool update_temp = true); + void DrawCircle(int x1, int y1, int x2, int y2); + void UpdateTempImage(); + void ApplyTempImage(); + + void ClearImage(QImage *img); + void DrawPixel(QImage *img, int x, int y, QColor color = QColor(255, 255, 255)); + void FloodFill(QImage* img, int x0, int y0, QColor zamieniany_color, QColor nowy_kolor); + QColor GetPixel(QImage* img, int x, int y); + + // Deklaracje slotow, czyli funkcji wywolywanych + // po wystapieniu zdarzen zwiazanych z GUI + // np. klikniecie na przycisk, ruch myszka +private slots: + void on_cleanButton_clicked(); + void on_exitButton_clicked(); + void mousePressEvent(QMouseEvent *event); + void mouseMoveEvent(QMouseEvent *event); + void mouseReleaseEvent(QMouseEvent *event); + void paintEvent(QPaintEvent*); + +}; + +#endif // MYWINDOW_H diff --git a/QT/flood-fill/mywindow.ui b/QT/flood-fill/mywindow.ui new file mode 100644 index 0000000..a11ed86 --- /dev/null +++ b/QT/flood-fill/mywindow.ui @@ -0,0 +1,126 @@ + + + MyWindow + + + + 0 + 0 + 883 + 682 + + + + true + + + MyWindow + + + + + + 10 + 10 + 600 + 600 + + + + true + + + QFrame::NoFrame + + + QFrame::Raised + + + + + + 630 + 10 + 241 + 211 + + + + Opcje + + + + + 80 + 40 + 75 + 23 + + + + Czyść + + + + + + 80 + 70 + 75 + 23 + + + + Wyjście + + + + + + 10 + 100 + 221 + 101 + + + + Naciśnij lewy przycisk myszy okrąg. +Naciśnij prawy przycisk myszy linię. +Naciśnij środkowy przycisk myszy by wypełnić kształt losowym kolorem. + + + Qt::PlainText + + + false + + + true + + + + + + + + 0 + 0 + 883 + 22 + + + + + + TopToolBarArea + + + false + + + + + + + +