From 056efe3c08e16030ffd687f7e54c4d24197cb0dd Mon Sep 17 00:00:00 2001 From: Dawid Pietrykowski Date: Tue, 13 Jun 2023 18:38:58 +0200 Subject: [PATCH] Added 3d-cube project --- QT/3d-cube/3d-cube.pro | 20 +++ QT/3d-cube/main.cpp | 33 ++++ QT/3d-cube/mywindow.cpp | 304 +++++++++++++++++++++++++++++++++++ QT/3d-cube/mywindow.h | 136 ++++++++++++++++ QT/3d-cube/mywindow.ui | 345 ++++++++++++++++++++++++++++++++++++++++ 5 files changed, 838 insertions(+) create mode 100644 QT/3d-cube/3d-cube.pro create mode 100644 QT/3d-cube/main.cpp create mode 100644 QT/3d-cube/mywindow.cpp create mode 100644 QT/3d-cube/mywindow.h create mode 100644 QT/3d-cube/mywindow.ui diff --git a/QT/3d-cube/3d-cube.pro b/QT/3d-cube/3d-cube.pro new file mode 100644 index 0000000..818fbc1 --- /dev/null +++ b/QT/3d-cube/3d-cube.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 = 3d-cube +TEMPLATE = app + +OUTPUT += Console +SOURCES += main.cpp\ + mywindow.cpp + +HEADERS += mywindow.h + +FORMS += mywindow.ui diff --git a/QT/3d-cube/main.cpp b/QT/3d-cube/main.cpp new file mode 100644 index 0000000..2a67e1f --- /dev/null +++ b/QT/3d-cube/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/3d-cube/mywindow.cpp b/QT/3d-cube/mywindow.cpp new file mode 100644 index 0000000..4b2ad0b --- /dev/null +++ b/QT/3d-cube/mywindow.cpp @@ -0,0 +1,304 @@ +// 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 +#include + +#define PI 3.1415 + +std::vector matrixMul(std::vector p, std::vector m) +{ + std::vector res(3); + for(int i = 0; i < 3; i++) + { + res.push_back(0); + for(int j = 0; j < 3; j++) + { + res[i] += m[i * 3 + j] * p[j]; + } + } + return res; +} + +std::vector matrixMul3x3(std::vector m1, std::vector m2) +{ + std::vector res(9, 0); + for(int i = 0; i < 3; i++) + { + for(int j = 0; j < 3; j++) + { + for(int k = 0; k < 3; k++) + { + res[i * 3 + j] += m1[i * 3 + k] * m2[k * 3 + j]; + } + } + } + return res; +} + +// 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); + + loaded_img = new QImage("/Users/dawidpietrykowski/Desktop/projects/umk/GK/QT/2d-transformations/p.png"); + + rotation_angle = 0; + + translation_vec.push_back(0); + translation_vec.push_back(0); + + scale_vec.push_back(1.0f); + scale_vec.push_back(1.0f); + + sh_vec.push_back(0.0f); + sh_vec.push_back(0.0f); + + UpdateImage(); +} + +// 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(); +} + +void MyWindow::on_slider_tx_valueChanged(int val){ + translation_vec[0] = val / 100.0f - 1.0f; +} + +void MyWindow::on_slider_ty_valueChanged(int val){ + translation_vec[1] = val / 100.0f - 1.0f; +} + +void MyWindow::on_slider_a_valueChanged(int val){ + rotation_angle = val; +} + +void MyWindow::on_slider_sx_valueChanged(int val){ + scale_vec[0] = 1.0f / ( val / 100.0f ); +} + +void MyWindow::on_slider_sy_valueChanged(int val){ + scale_vec[1] = 1.0f / ( val / 100.0f ); +} + +void MyWindow::on_slider_shx_valueChanged(int val){ + sh_vec[0] = val / 100.0f - 1.0f; +} + +void MyWindow::on_slider_shy_valueChanged(int val){ + sh_vec[1] = val / 100.0f - 1.0f; +} + +void MyWindow::UpdateImage(){ + float sina = sin(rotation_angle * 0.01745329252f); + float cosa = cos(rotation_angle * 0.01745329252f); + + std::vector translate_mat = { + 1, 0, translation_vec[0], + 0, 1, translation_vec[1], + 0, 0, 1, + }; + + std::vector scale_mat = { + scale_vec[0], 0, 0, + 0, scale_vec[1], 0, + 0, 0, 1, + }; + + std::vector rotation_mat = { + cosa, -sina, 0, + sina, cosa, 0, + 0, 0, 1, + }; + + std::vector shx_mat = { + 1, sh_vec[0], 0, + 0, 1, 0, + 0, 0, 1, + }; + + + std::vector shy_mat = { + 1, 0, 0, + sh_vec[1], 1, 0, + 0, 0, 1, + }; + + std::vector tansform_mat = matrixMul3x3(matrixMul3x3(matrixMul3x3(matrixMul3x3( + scale_mat, + rotation_mat), + shx_mat), + shy_mat), + translate_mat); + + for(int x = 0; x < szer; x++) + for(int y = 0; y < wys; y++){ + float xw = (float) x / (float)szer; + float yh = (float) y / (float) wys; + xw -= 0.5f; + yh -= 0.5f; + std::vector P1 = {xw, yh, 1}; + std::vector P2 = matrixMul(P1, tansform_mat); + P2[0] += 0.5f; + P2[1] += 0.5f; + DrawPixel(img, x, y, GetInterpolatedColor(P2[0], P2[1])); + } + + update(); +} + +QColor MyWindow::GetPixel(QImage* img, int x, int y){ + QColor res; + int width = img->width(); + int height = img->height(); + if(x >= width || y >= height || x < 0 || y < 0) + return res; + + unsigned char* ptr = img->bits(); + + res.setBlue(ptr[width*4*y + 4*x]); + res.setGreen(ptr[width*4*y + 4*x + 1]); + res.setRed(ptr[width*4*y + 4*x + 2]); + res.setAlpha(ptr[width*4*y + 4*x + 3]); + + return res; +} + +QColor mul(float v, QColor c){ + int red = (int)(c.red() * v); + if(red > 255) red = 255; + int green = (int)(c.green() * v); + if(green > 255) green = 255; + int blue = (int)(c.blue() * v); + if(blue > 255) blue = 255; + return QColor(red, green, blue); +} + +QColor add(QColor c1, QColor c2){ + int red = (int)(c1.red() + c2.red()); + if(red > 255) red = 255; + int green = (int)(c1.green() + c2.green()); + if(green > 255) green = 255; + int blue = (int)(c1.blue() + c2.blue()); + if(blue > 255) blue = 255; + return QColor(red, green, blue); +} + +QColor MyWindow::GetInterpolatedColor(float x, float y){ + float width = loaded_img->width(); + float height = loaded_img->height(); + float xw = (x * width); + float yw = (y * height); + int x_f = (int) (x * width); + int y_f = (int) (y * height); + int x_c = ceil(x * width); + int y_c = ceil(y * height); + float a = (xw - (float) x_f); + float b = ((yw) - (float) y_f); + + QColor P1 = GetPixel(loaded_img, x_f, y_c); + QColor P2 = GetPixel(loaded_img, x_c, y_c); + QColor P3 = GetPixel(loaded_img, x_c, y_f); + QColor P4 = GetPixel(loaded_img, x_f, y_f); + + QColor v1 = mul(1.0f - a, P1); + QColor v2 = mul(a, P2); + QColor v3 = mul(a, P3); + QColor v4 = mul(1.0f - a, P4); + QColor top = add(v1, v2); + QColor bottom = add(v3, v4); + QColor btop = mul(b, top); + QColor bbottom = mul(1.0f - b, bottom); + QColor res = add(btop, bbottom); + + return res; +} + +// Funkcja "odmalowujaca" komponent +void MyWindow::paintEvent(QPaintEvent*) +{ + // Obiekt klasy QPainter pozwala nam rysowac na komponentach + QPainter p(this); + + + UpdateImage(); + // Rysuje obrazek "img" w punkcie (poczX,poczY) + // (tu bedzie lewy gorny naroznik) + p.drawImage(poczX,poczY,*img); +} + + +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(); +} + + +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/3d-cube/mywindow.h b/QT/3d-cube/mywindow.h new file mode 100644 index 0000000..09395af --- /dev/null +++ b/QT/3d-cube/mywindow.h @@ -0,0 +1,136 @@ +// 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; + + QImage *loaded_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; + + float rotation_angle; + Point[8] points; + std::vector scale_vec; + std::vector translation_vec; + std::vector sh_vec; + + int tmp_point_id = 0; + int tmp_shape_id = 0; + + // Deklaracje funkcji + void czysc(); + void rysuj1(); + void rysuj2(); + + + void UpdateTempImage(); + void ApplyTempImage(); + + void ClearImage(QImage *img); + void DrawB(int b); + void DrawR(int r); + void DrawG(int g); + void DrawH(float h); + void DrawS(float s); + void DrawV(float v); + + QColor GetPixel(QImage* img, int x, int y); + void DrawPixel(QImage* img, int x, int y, QColor color); + QColor GetInterpolatedColor(float x, float y); + void UpdateImage(); + + // Deklaracje slotow, czyli funkcji wywolywanych + // po wystapieniu zdarzen zwiazanych z GUI + // np. klikniecie na przycisk, ruch myszka +private slots: + void on_exitButton_clicked(); + void paintEvent(QPaintEvent*); + void on_slider_tx_valueChanged(int val); + void on_slider_ty_valueChanged(int val); + void on_slider_sx_valueChanged(int val); + void on_slider_sy_valueChanged(int val); + void on_slider_shx_valueChanged(int val); + void on_slider_shy_valueChanged(int val); + void on_slider_a_valueChanged(int val); +}; + +#endif // MYWINDOW_H diff --git a/QT/3d-cube/mywindow.ui b/QT/3d-cube/mywindow.ui new file mode 100644 index 0000000..5f5d511 --- /dev/null +++ b/QT/3d-cube/mywindow.ui @@ -0,0 +1,345 @@ + + + MyWindow + + + + 0 + 0 + 883 + 583 + + + + true + + + MyWindow + + + + + + 10 + 10 + 600 + 600 + + + + true + + + QFrame::NoFrame + + + QFrame::Raised + + + + + + 630 + 10 + 241 + 421 + + + + Opcje + + + + + 90 + 30 + 75 + 23 + + + + Wyjście + + + + + + 30 + 120 + 31 + 121 + + + + 200 + + + 100 + + + Qt::Vertical + + + + + + 110 + 120 + 31 + 121 + + + + 200 + + + 100 + + + Qt::Vertical + + + + + + 190 + 120 + 31 + 121 + + + + 200 + + + 100 + + + Qt::Vertical + + + + + + 30 + 290 + 31 + 121 + + + + 200 + + + 100 + + + Qt::Vertical + + + + + + 110 + 290 + 31 + 121 + + + + 200 + + + 100 + + + Qt::Vertical + + + + + + 190 + 290 + 31 + 121 + + + + 200 + + + 100 + + + Qt::Vertical + + + + + + 30 + 80 + 41 + 31 + + + + + 25 + + + + TX + + + Qt::AlignCenter + + + + + + 110 + 80 + 41 + 31 + + + + + 25 + + + + TY + + + Qt::AlignCenter + + + + + + 190 + 80 + 41 + 31 + + + + + 25 + + + + SHX + + + Qt::AlignCenter + + + + + + 30 + 250 + 41 + 31 + + + + + 25 + + + + SX + + + Qt::AlignCenter + + + + + + 110 + 250 + 41 + 31 + + + + + 25 + + + + SY + + + Qt::AlignCenter + + + + + + 190 + 250 + 41 + 31 + + + + + 25 + + + + SHY + + + Qt::AlignCenter + + + + + + + 660 + 450 + 191 + 31 + + + + 100 + + + Qt::Horizontal + + + + + + + 0 + 0 + 883 + 24 + + + + + + TopToolBarArea + + + false + + + + + + + +