Rqp1c9HFVopcG

Film nawiązujący do treści materiału: Konstrukcje fraktalne jako stosowanie rekurencji 2.

Film nawiązujący do treści materiału: Konstrukcje fraktalne jako stosowanie rekurencji 2.

Film dostępny pod adresem /preview/resource/Rqp1c9HFVopcG

Film nawiązujący do treści materiału: Konstrukcje fraktalne jako stosowanie rekurencji 2.

Kod programu zaprezentowanego w filmie:

Biblioteka graficzna Qt5 – konfiguracja środowiska

W zaprezentowanym filmie wygenerowaliśmy smoka Heighwaya w trybie tekstowym. W kolejnym kroku, aby dokonać wizualizacji wyników obliczeń naszego programu, posłużymy się biblioteką graficzną Qt5. Zaletą tego rozwiązania jest prostota konfiguracji.

W celu uruchomienia środowiska należy pobrać instalator z oficjalnej strony Qt. Znajdziemy ją, wpisując do dowolnej przeglądarki internetowej frazę „qt5” – jednym z pierwszych wyników, które się wyświetlą, będzie właśnie szukana strona internetowa.

Po uruchomieniu instalatora zostaniemy poproszeni o zalogowanie się. Jeśli nie mamy konta, możemy je utworzyć bezpośrednio z poziomu instalatora. W tym celu należy wybierać opcję Sign up (zarejestruj się), zarejestrować konto, a następnie potwierdzić je za pomocą adresu e‑mail. Po poprawnym utworzeniu konta wystarczy zalogować się w instalatorze i można kontynuować instalację.

W kolejnym etapie należy zaakceptować zobowiązania licencyjne, a także podać nazwę firmy/imię biznesowe lub wybrać opcję I am individual person not using Qt for any company, która zapewne będzie dotyczyć znacznej większości użytkowników. Kontynuujemy instalację, wybierając opcję Next.

Następnie możemy zdecydować, czy chcemy przesłać dodatkowe dane w celu ulepszenia przyszłych wersji Qt5. Zaznaczamy wybraną opcję i kontynuujemy instalację.

W kolejnym kroku podajemy lokalizację, w której umieszczone zostaną pliki programu. W przypadku początkujących użytkowników zaleca się wybranie domyślnej opcji Default desktop installation, aby wraz ze środowiskiem został zainstalowany kompilator oraz edytor graficzny. Następnie wybieramy opcję Next.

Teraz należy zapoznać się z postanowieniami licencyjnymi środowiska oraz produktów wraz z nim dołączonych i zaakceptować je, a następnie wybrać Next. W kolejnym etapie można ewentualnie zmienić nazwę grupy, która zostanie utworzona w menu Start, po czym ponownie wybrać Next.

W tym momencie uruchomi się proces instalacji. Po jego zakończeniu możemy uruchomić edytor graficzny Qt Creator. Domyślnie IDEIDEIDE wykryje język systemu operacyjnego. W przypadku, gdybyśmy chcieli zmienić język z angielskiego na polski, można to zrobić, wybierając:Tools/Options.../Environment/Interface/Language. Wówczas wybieramy z listy interesujący nas język i potwierdzamy wybór opcją OK, a następnie Restart now.

Pierwsza rzecz, jaką trzeba zrobić, aby zbudować przykładowy program, to utworzenie nowego projektu z menu Plik. Wybieramy opcję Nowy plik lub projekt, a dalej – szablon Application (Qt) oraz Qt Widgets Application.

Następnie należy wprowadzić nazwę projektu oraz wybrać katalog, w którym chcemy go zapisać. W następnych oknach zalecany jest wybór domyślnych opcji aż do momentu, w którym będziemy mogli wybrać Zakończ. Po utworzeniu projektu według powyższych zaleceń ukaże się nam następująca struktura plików programu:

Tak utworzony program możemy uruchomić, wybierając opcję Uruchom (zielony trójkąt w lewym dolnym rogu). Po poprawnym wykonaniu tej czynności na ekranie ukaże się następujący program:

Ponieważ tematem tego e‑materiału nie jest bezpośrednio obsługa biblioteki graficznej Qt5 ani związana z nią obiektowość, dalej będziemy korzystać z szablonu napisanego specjalnie na potrzeby rysowania punktów na ekranie. W szablonie zawarta jest metoda drawPoint(double x, double y) obiektu MainWindow, która pozwoli nam narysować w powyższym oknie punkt na określonej pozycji. Ponieważ piksele w programie numerowane są od zera oraz w stronę przeciwną na osi OY niż w układzie współrzędnych, szablon zawiera przekształcenia, które pozwolą nam traktować przestrzeń programu jak układ kartezjański o skali dobranej do tworzonego fraktala.

Smok Heighwaya

Przed przystąpieniem do omówienia procedury generowania konstrukcji smoka Heighwaya przygotujmy strukturę programu.

W pliku Nagłówki/mainwindow.h należy umieścić następujący kod:

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <list>

using namespace std;

QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; }
QT_END_NAMESPACE

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

    virtual void paintEvent(QPaintEvent *event) override;
    void drawPoint(double x, double y);

private:
    Ui::MainWindow *ui;
    list<QPoint> points;
};
#endif // MAINWINDOW_H

Plik Źródła/mainwindow.cpp powinien zawierać:

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "qpainter.h"

using namespace std;

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    this->setFixedSize(700, 480);
    this->setWindowTitle("Smok Heighwaya");
}

MainWindow::~MainWindow() {
    delete ui;
}

void MainWindow::drawPoint(double x, double y) {
    int new_x = x * 400.0 + 180;
    int new_y = 300 - y * 400.0;

    points.push_back(QPoint(new_x, new_y));
}

void MainWindow::paintEvent(QPaintEvent *event) {
    QPainter painter(this);

    for (auto& point : points) {
        painter.drawPoint(point);
    }
}

Oraz ostatni plik – Źródła/main.cpp:

#include "mainwindow.h"

#include <QApplication>
#include <cstdlib>

using namespace std;

int main(int argc, char *argv[]) {
    // Początek kodu - utworzenie okna do rysowania
    QApplication a(argc, argv);
    MainWindow w;

    /* początek właściwej części kodu */

    /* koniec właściwej części kodu */

    // Koniec programu - wyświetlenie wyniku
    w.show();
    return a.exec();
}

W tym momencie w pliku main.cpp możemy pisać właściwy kod aplikacji, odpowiedzialny za generowanie fraktali. Aby narysować punkt na określonej pozycji, możemy skorzystać z linijki:

w.drawPoint(x, y);

Na początku warto podjąć samodzielną próbę wygenerowania smoka Heighwaya, zgodnie z omówionym w poprzedniej lekcji algorytmem, którego pseudokod wygląda następująco:

// punkt startowy
x = 0.0
y = 0.0

// liczba generowanych punktów
n = 10000

wykonuj n razy:
	// kopia zmiennej x
	x0 = x
    
    g = losuj liczbę z [0, 1]
    
    jeżeli g == 0 wykonuj
        x = 0.5 * x - 0.5 * y
        y = 0.5 * x0 + 0.5 * y
    w przeciwnym wypadku
        x = - 0.5 * x - 0.5 * y + 1
        y = 0.5 * x0 - 0.5 * y
    
    rysuj punkt (x, y)

Najpierw utworzymy punkt początkowy, od którego rozpoczniemy przekształcenia przy użyciu funkcji IFSIFSIFS. Ponieważ punkt w układzie współrzędnych reprezentowany jest jako dwie liczby, utworzymy tylko dwie zmienne typu zmiennoprzecinkowego double o nazwach x oraz y, które będą stanowiły współrzędną x oraz y:

// punkt startowy
double x = 0.0, y = 0.0;

Kolejnym krokiem jest zdefiniowanie liczby punktów n, których użyjemy do utworzenia fraktala. Następnie utworzymy pętlę, która wykona się n razy. W tym celu możemy wykorzystać zarówno pętlę while, jak i for. W naszym przypadku skorzystamy z drugiej opcji:

// liczba generowanych punktów
int n = 10000;

for (int i = 0; i < n; ++i) {
	// tworzenie kolejnych punktów
}

Zastanówmy się, w jaki sposób możemy wygenerować losową liczbę całkowitą z przedziału $⟨0,1⟩$. We wcześniejszych lekcjach poznaliśmy już sposób obsługi funkcji rand() z biblioteki <cstdlib>. Wiemy też, że można ograniczyć jej zakres działania przez operację dzielenia modulo. Do wyboru losowej liczby możemy zatem wykorzystać poniższy zapis:

// losowa liczba całkowita z przedziału <0, 1>
int q = rand() % 2;

Teraz możemy już przejść do modelowania funkcji IFS. Przed przystąpieniem do tej czynności należy jednak zrobić kopię zmiennej x, aby podczas generacji nowej wartości y nie wykorzystać nowej wartości x.

// kopia zmiennej x
double x0 = x;

if (q < 1) {
    x = 0.5 * x - 0.5 * y;
    y = 0.5 * x0 + 0.5 * y;
}
else {
    x = - 0.5 * x - 0.5 * y + 1;
    y = 0.5 * x0 - 0.5 * y;
}

Ostatnim krokiem będzie dodanie w pętli linijki, która wyśle utworzony punkt do narysowania.

// Wysłanie punktu do narysowania
w.drawPoint(x, y);

Całość kodu prezentuje się zatem następująco:

#include "mainwindow.h"

#include <QApplication>
#include <cstdlib>

using namespace std;

int main(int argc, char *argv[]) {
    // Początek kodu - utworzenie okna do rysowania
    QApplication a(argc, argv);
    MainWindow w;

    /* początek właściwej części kodu */
    // punkt startowy
    double x = 0.0, y = 0.0;
    // liczba generowanych punktów
    int n = 10000;

    for (int i = 0; i < n; ++i) {
        // losowa liczba całkowita z przedziału <0, 1>
        int q = rand() % 2;

        // kopia zmiennej x
        double x0 = x;

        if (q < 1) {
            x = 0.5 * x - 0.5 * y;
            y = 0.5 * x0 + 0.5 * y;
        }
        else {
            x = - 0.5 * x - 0.5 * y + 1;
            y = 0.5 * x0 - 0.5 * y;
        }

        // Wysłanie punktu do narysowania
        w.drawPoint(x, y);
    }

    /* koniec właściwej części kodu */

    // Koniec programu - wyświetlenie wyniku
    w.show();
    return a.exec();
}

Uruchomienie tak napisanego programu spowoduje wyświetlenie następującego okna:

Jak widzimy, warto zwiększyć liczbę generowanych punktów. Oto jak będzie wyglądał wynik programu dla parametru n = 1000000:

Paproć Barnsleya

Ponieważ skala wielkości kształtów smoka Heighwaya oraz paproci Barnsleya, a także ich pozycja w układzie współrzędnych jest różna, szablon w przypadku paproci musi zostać zmodyfikowany. Jedyny plik, który zmienimy w tym celu, to mainwindow.cpp – należy umieścić w nim następujący kod:

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "qpainter.h"

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    this->setFixedSize(380, 580);
    this->setWindowTitle("Paproć Barnsleya");
}

MainWindow::~MainWindow() {
    delete ui;
}

void MainWindow::drawPoint(double x, double y) {
    int new_x = x * 50.0 + 175;
    int new_y = 525 - y * 50.0;

    points.push_back(QPoint(new_x, new_y));
}

void MainWindow::paintEvent(QPaintEvent *event) {
    QPainter painter(this);

    for (auto& point : points) {
        painter.drawPoint(point);
    }
}

Jeżeli udało ci się wygenerować poprzedni fraktal, na pewno poradzisz sobie także z utworzeniem paproci Barnsleya. Algorytm zapisany za pomocą pseudokodu, który wtedy opracowaliśmy, prezentuje się następująco:

// punkt startowy
x = 0.0
y = 0.0

// liczba generowanych punktów
n = 10000

wykonuj n razy:
	// kopia zmiennej x
	x0 = x
    
    g = losuj liczbę z [0, 1, ..., 99]
    
    jeżeli q < 1 wykonuj
    	x = 0;
    	y = 0.16 * y;
    w przeciwnym wypadku jeżeli q < 86 wykonuj
    	x = 0.85 * x + 0.04 * y;
    	y = -0.04 * x0 + 0.85 * y + 1.6;
    w przeciwnym wypadku jeżeli q < 93 wykonuj
    	x = 0.2 * x - 0.26 * y;
    	y = 0.23 * x0 + 0.22 * y + 1.6;
    w przeciwnym wypadku
    	x = -0.15 * x + 0.28 * y;
    	y = 0.26 * x + 0.24 * y + 0.44;
    
    rysuj punkt (x, y)

Różnica pomiędzy generacją paproci Barnsleya a generacją smoka Heighwaya polega tylko na zastosowaniu innych funkcji IFS w innych proporcjach. Linijka, która odpowiada za wygenerowanie losowej liczby, zostanie tu zmieniona w taki sposób, aby generować liczbę całkowitą z przedziału $⟨0,99⟩$:

// losowa liczba całkowita z przedziału <0, 99>
int q = rand() % 100;

Natomiast część warunkową, która odpowiada za funkcje IFS, zmodyfikujemy do następującej postaci:

// kopia zmiennej x
double x0 = x;

if (q < 1) {
    x = 0;
    y = 0.16 * y;
}
else if (q < 86) {
    x = 0.85 * x + 0.04 * y;
    y = -0.04 * x0 + 0.85 * y + 1.6;
}
else if (q < 93) {
    x = 0.2 * x - 0.26 * y;
    y = 0.23 * x0 + 0.22 * y + 1.6;
}
else {
    x = -0.15 * x + 0.28 * y;
    y = 0.26 * x0 + 0.24 * y + 0.44;
}

Ostateczny program będzie zatem wyglądał tak:

#include "mainwindow.h"

#include <QApplication>
#include <cstdlib>

using namespace std;

int main(int argc, char *argv[]) {
    // Początek kodu - utworzenie okna do rysowania
    QApplication a(argc, argv);
    MainWindow w;

    /* początek właściwej części kodu */
    // punkt startowy
    double x = 0.0, y = 0.0;
    // liczba generowanych punktów
    int n = 10000;

    for (int i = 0; i < n; ++i) {
        // losowa liczba całkowita z przedziału <0, 99>
        int q = rand() % 100;

        // kopia zmiennej x
        double x0 = x;

        if (q < 1) {
            x = 0;
            y = 0.16 * y;
        }
        else if (q < 86) {
            x = 0.85 * x + 0.04 * y;
            y = -0.04 * x0 + 0.85 * y + 1.6;
        }
        else if (q < 93) {
            x = 0.2 * x - 0.26 * y;
            y = 0.23 * x0 + 0.22 * y + 1.6;
        }
        else {
            x = -0.15 * x + 0.28 * y;
            y = 0.26 * x0 + 0.24 * y + 0.44;
        }

        // Wysłanie punktu do narysowania
        w.drawPoint(x, y);
    }

    /* koniec właściwej części kodu */

    // Koniec programu - wyświetlenie wyniku
    w.show();
    return a.exec();
}

A oto rezultat uruchomienia tego programu z parametrem n = 10000:

R1XPY8wU20PiX

Zrzut ekranu przedstawia okno: Paproć Barnsleya.
Znajduje się w nim niewyraźny kształt liścia paproci zbudowany z rzadko zagęszczonych punktów.

Warto znów dopasować liczbę wygenerowanych punktów. Oto wynik programu uruchomionego z parametrem n = 1000000:

RGkyIiLV2lIhU

Zrzut ekranu przedstawia okno: Paproć Barnsleya.
Znajduje się w nim kształt liścia paproci zbudowany z  zagęszczonych punktów.

Słownik