main.cpp

#include <SFML\Graphics.hpp>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <thread>
#include <mutex>

void populateVector(std::vector<float>& vector, const int size);
void renderVectorItem(sf::RenderWindow& window, std::vector<float>& vector, const int index, const int offset, bool highlight, const float y);
void visualSelectionSort(sf::RenderWindow& window, std::vector<float>& vector, std::vector<float>& sorted);
void visualBubbleSort(sf::RenderWindow& window, std::vector<float>& vector);
bool isSorted(std::vector<float>& vector);
void render(sf::RenderWindow& window);
void initText(sf::RenderWindow& window);

std::vector<float> dataBubble, dataSelection, sortedSelection;
std::mutex render_mutex;
sf::Font arial;
sf::Text sel, bub;

int main(int arg, char* argv[]) {
    sf::RenderWindow window(sf::VideoMode(600, 400), "Sorting Visualisation");
    window.setFramerateLimit(60);
    window.setVerticalSyncEnabled(true);

    populateVector(dataBubble, 200);
    populateVector(dataSelection, 200);

    window.setActive(false);
    initText(window);

    std::thread t1(visualSelectionSort, std::ref(window), std::ref(dataSelection), std::ref(sortedSelection));
    std::thread t2(visualBubbleSort, std::ref(window), std::ref(dataBubble));

    while (window.isOpen()) {
        sf::Event event;
        while (window.pollEvent(event)) {
            if (event.type == sf::Event::Closed)
                window.close();
        }

    }

    t1.join();
    t2.join();

    return 0;
}

void initText(sf::RenderWindow& window) {
    arial.loadFromFile("../arial.ttf");
    sel.setFont(arial);
    bub.setFont(arial);
    sel.setScale(0.5f, 0.5f);
    bub.setScale(0.5f, 0.5f);
    sel.setString("Selection Sort");
    bub.setString("Bubble Sort");
    sel.setColor(sf::Color::Red);
    bub.setColor(sf::Color::Red);
    sel.setPosition(5, 5);
    bub.setPosition(5, 5 + window.getSize().y / 2);
}

void render(sf::RenderWindow& window) {
    render_mutex.lock();
    window.setActive(true);
    window.clear(sf::Color::Black);

    for (int j = 0; j < dataBubble.size(); j++) {
        renderVectorItem(window, dataBubble, j, 0, false, (float)window.getSize().y / 2);
    }
    for (int i = 0; i < dataSelection.size(); i++) {
        renderVectorItem(window, dataSelection, i, 0, false, 0);
    }
    for (int i = 0; i < sortedSelection.size(); i++) {
        renderVectorItem(window, sortedSelection, i, dataSelection.size(), false, 0);
    }
    window.draw(sel);
    window.draw(bub);

    window.display();
    window.setActive(false);
    render_mutex.unlock();
}

void visualBubbleSort(sf::RenderWindow& window, std::vector<float>& vector) {
    while (!isSorted(vector)) {
        for (int i = 0; i < vector.size(); i++) {
            if (i >= vector.size() - 1)
                break;
            if (vector[i] > vector[i + 1]) {
                float tmp = vector[i + 1];
                vector[i + 1] = vector[i];
                vector[i] = tmp;
            }
        }

        render(window);
    }
}

bool isSorted(std::vector<float>& vector) {
    for (int i = 0; i < vector.size(); i++) {
        if (i >= vector.size() - 1)
            return true;
        if (vector[i] > vector[i + 1])
            return false;
    }

    return true;
}

void visualSelectionSort(sf::RenderWindow& window, std::vector<float>& vector, std::vector<float>& sorted) {
    float smallest = 2;
    int smallestIndex = 0;

    while (vector.size() > 0) {
        smallest = vector[0];
        smallestIndex = 0;
        for (int i = 0; i < vector.size(); i++) {
            if (vector[i] < smallest) {
                smallest = vector[i];
                smallestIndex = i;
            }
        }
        sorted.push_back(smallest);
        vector.erase(vector.begin() + smallestIndex);

        render(window);
    }
}

void populateVector(std::vector<float>& vector, const int size) {
    std::vector<float> tmp;
    for (int i = 0; i <= size; i++) {
        tmp.push_back((float)i / size);
    }

    std::srand(std::time(0));
    while (tmp.size() > 0) {
        int rnd = std::rand() & (tmp.size() - 1);
        vector.push_back(tmp[rnd]);
        tmp.erase(tmp.begin() + rnd);
    }
}

void renderVectorItem(sf::RenderWindow& window, std::vector<float>& vector, const int index, const int offset, bool highlight, const float y) {
    float width = window.getSize().x / (float)vector.size();
    float height = window.getSize().y / 2;
    int color = (int)(vector[index] * 255);

    sf::RectangleShape shape(sf::Vector2f(width, height));
    shape.setPosition((index + offset) * width, y);
    shape.setFillColor(highlight ? sf::Color::Red : sf::Color(color, color, color, 255));

    window.draw(shape);
}