main.cpp

Go to the documentation of this file.

#include "windows.h"
#include <glew.h>
#include <glfw3.h>

#include <iostream>
#include <fstream>

#include "L_System.h"
#include "ShaderLoader.h"
//#include "AdjazenzMatrix.h"
#include "FastCommunity.h"
#include "Visualisation.h"

void init(std::string path);                                    
void initVisualisation(std::string path);
void update();                                                  
void draw();                                                    
void cleanup();                                                 
void addSelfLoops(std::string path);                            

GLFWwindow* window;         
//AdjazenzMatrix* M;        //!< Repraesentiert die Adjyzenzmatrix des Graphen (Wurde fuer ersten Clusteringversuch und zum Monitoring der Testdaten benutzt).
FastCommunity* clusterer;   
Visualisation* visu;        

GLuint shader;      

int height;
int width;

int changeCurve;    
int changeData;     
bool drawCurve;     
bool drawPoints;    
bool selfloops;     

static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
{
    if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS) //close Window by pressing esc
    {
        glfwSetWindowShouldClose(window, GL_TRUE);
    }
    if(key == GLFW_KEY_LEFT && action == GLFW_PRESS)    //decrease visualisationorder with left arrow
    {
        visu->decreaseOrder();
    }
    if(key == GLFW_KEY_RIGHT && action == GLFW_PRESS)   //increase visualisationorder with rigth arrow
    {
        visu->increaseOrder();
    }
    if(key == GLFW_KEY_C && action == GLFW_PRESS)       //draw Curve by pressing C 
    {
        if(drawCurve)
        {
            drawCurve = false;
        }else{
            drawCurve = true;
        }
    }
    if(key == GLFW_KEY_P && action == GLFW_PRESS)       //draw Datapoints by pressing P
    {
        if(drawPoints)
        {
            drawPoints = false;
        }else{
            drawPoints = true;
        }
    }
    if(key == GLFW_KEY_1 && action == GLFW_PRESS)       //draw the viualisation with the hilbert curve by pressing 1
    {
        changeCurve = 1;
    }
    if(key == GLFW_KEY_2 && action == GLFW_PRESS)       //draw the visualisation with the gosper curve by pressing 2
    {
        changeCurve = 2;
    }
    if(key == GLFW_KEY_F1 && action == GLFW_PRESS)      //draw TestData1
    {
        changeData = 1; 
    }
    if(key == GLFW_KEY_F2 && action == GLFW_PRESS)      //draw TestData2
    {
        changeData = 2; 
    }
    if(key == GLFW_KEY_F3 && action == GLFW_PRESS)      //draw TestData2
    {
        changeData = 3; 
    }
    if(key == GLFW_KEY_F4 && action == GLFW_PRESS)      //draw TestData2
    {
        changeData = 4; 
    }
}

void main()     
{
    std::string path = "../TestData/testitest3.txt";
    init(path);

    while (!glfwWindowShouldClose(window))
    {
        glfwPollEvents();

        glViewport(0,0,width,height);
        glClear(GL_COLOR_BUFFER_BIT);
        glUseProgram(shader);

        visu->draw(shader,drawPoints,drawCurve);
        update();
        glUseProgram(0);

        glfwSwapBuffers(window);
    }

    cleanup();

    //Remove the tmp File
    if (selfloops)
    {   
        if( remove( "../tmp/tmp.txt" ) != 0 )
        {
            perror( "Can't delete the tmp files" );
        }
    }
}

void init(std::string path)
{
    if (!glfwInit())    //init glfw
    {
        system("PAUSE");
        exit(EXIT_FAILURE);
    }
    int refresh_rate = 60;
    glfwWindowHint(GLFW_REFRESH_RATE, refresh_rate);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    width = 800;
    height = 800;
    GLFWmonitor* monitor = nullptr;

    window = glfwCreateWindow(width, height, "Space Filling Curve Visualisierung", monitor, NULL);
    glfwMakeContextCurrent(window);

    glfwSetKeyCallback(window, key_callback);
    glViewport(0, 0, width, height);
    glClearColor(1.0f,1.0f,1.0f,0.0f);
    
    glewExperimental = true;    //init glew
    GLenum err = glewInit();        
    if (err != GLEW_OK)
    {
        //Error
        std::cout << glewGetErrorString(err);
    }
    
    //load shaders
    ShaderLoader* loader = new ShaderLoader();
    shader = loader->LoadShaders("../Shader/vertexshader.vert", "../Shader/fragmentshader.frag", "../Shader/geometryshader.geo");
    delete loader; loader = nullptr;

    //M = new AdjazenzMatrix("../TestData/testitest.txt");

    //no user inpud at the beginning
    drawCurve = false;
    drawPoints = false;
    changeCurve = 0;
    changeData = 0; 

    initVisualisation(path);
}
void initVisualisation(std::string path)
{
    //Cluster the Graph
    clusterer = new FastCommunity();
    myList* ordering;

    bool selfloops = false; //self loops are not supportet by the current visualisationversion
    if(selfloops)
    {
        addSelfLoops(path);
        ordering = clusterer->clusterAndOrder("../tmp/tmp.txt");
    }else{
        ordering = clusterer->clusterAndOrder(path); 
    }

    //set die visualisation
    visu = new Visualisation(width,height,ordering,clusterer->edgeList,clusterer->gparm.n,clusterer->gparm.maxid);
}

void update()
{
    if(changeCurve == 1)
    {
        visu->changeType("hilbert");
        changeCurve = 0;
    }
    if(changeCurve == 2)
    {
        visu->changeType("gosper");
        changeCurve = 0;
    }
    
    if(changeData == 1)
    {
        delete clusterer; delete visu;
        std::string path = "../TestData/testitest.txt";
        initVisualisation(path);
        changeData = 0;
    }
    if(changeData == 2)
    {
        delete clusterer; delete visu;
        std::string path = "../TestData/testitest2.txt";
        initVisualisation(path);
        changeData = 0;
    }
    if(changeData == 3)
    {
        delete clusterer; delete visu;
        std::string path = "../TestData/testitest3.txt";
        initVisualisation(path);
        changeData = 0;
    }
    if(changeData == 4)
    {
        delete clusterer; delete visu;
        std::string path = "../TestData/peeroregon.txt";
        initVisualisation(path);
        changeData = 0;
    }
}

void cleanup()
{
    //delete M; M = nullptr;
    delete clusterer; clusterer = nullptr;
    delete visu; visu = nullptr;

    glDeleteProgram(shader);
    glfwDestroyWindow(window);

    glfwTerminate();
}

void addSelfLoops(std::string path) //not supportet in the current visualisationversion
{
    int maxIndex = -1;

    //-.-.-.-.-.-.-.-.-.-get largest nodevalue-.-.-.-.-.-.-.-.-.-.-.-.-
    int s,f,t;
    std::ifstream fscan(path.c_str(), std::ios::in);
    std::ofstream fout("../tmp/tmp.txt", std::ios::out);
    while (fscan >> s >> f) {   
        fout << s << " " << f << "\n";
        if (f < s) { t = s; s = f; f = t; }     // guarantee s < f
        if (f > maxIndex) { maxIndex = f; }     // track largest node index     
    }
    fscan.close();
    //-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-
    
    //-.-.-.-.-.-.-.-.-.-.-.-.-add selfloops-.-.-.-.-.-.-.-.-.-.-.-.-.-
    for(int i = 1; i<=maxIndex; i++)
    {
        fout << i << " " << i << "\n";
    }
    fout.close();
    //-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-
    
}