Visualisation.cpp

Go to the documentation of this file.

#include "Visualisation.h"

Visualisation::Visualisation(int w, int h, myList* order,std::vector<unsigned int> eList, int n, int maxId)
{
    //set up the variables of the visualisation 
    lindenmeyer = new L_System(w, h,"hilbert");
    edgeList = eList;
    visuorder = 1;
    maximum = maxId;
    vertexCount = n;
    graphOrder = order;

    width = w; height = h;
    initPoints(order, n, maxId); //initialize the points

    //initialize the buffers for drawing
    glGenBuffers(1, &positionBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, positionBuffer);
    glBufferData(GL_ARRAY_BUFFER, positioncount * sizeof(float), &points[0], GL_STATIC_DRAW); 
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    glGenBuffers(1, &indexBuffer);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, edgeList.size() * sizeof(unsigned int), &edgeList[0], GL_STATIC_DRAW);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);

    glBindBuffer(GL_ARRAY_BUFFER, positionBuffer);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);

    glBindVertexArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

    calcPoints(visuorder);
}


Visualisation::~Visualisation(void)
{
    glDeleteBuffers(1, &positionBuffer);
    glDeleteBuffers(1, &indexBuffer);
    glDeleteVertexArrays(1, &vao);
    delete lindenmeyer; lindenmeyer = nullptr;
}
void Visualisation::initPoints(myList* order, int n, int max)
{
    //initialize the pointlist with zeros
    for(int i = 0; i<max; i++)
    {
        glm::vec3 tmp = glm::vec3(0.0,0.0,0.0);
        points.push_back(tmp);
    }

    //set up the startinpositions
    int start_x = 0;
    int start_y = -1*height;
    //order the vertices equidistant along a line 
    myList* tmp = order;
    for(int i = 0; i<n; i++) 
    {
        double x = start_x + i*(1.0/(n-1)); 
        points[tmp->index-2] = glm::vec3(x, start_y, 0.0);
        tmp = tmp->next;
    }
    positioncount = maximum*3; 
}
void Visualisation::decreaseOrder()
{
    if(visuorder > 1) 
    {
        visuorder--;                    //decrease the order of the visualisation
        calcPoints(visuorder);          //calculate the mapping along the curve with this order
        lindenmeyer->setDrawingIteration(visuorder); //set the drawing order of the curve of the order of the visualisation
    }
}
void Visualisation::increaseOrder()
{
    visuorder++;                //increase the order of the visualisation
    calcPoints(visuorder);      //calculate the mapping along the curve with this order
    lindenmeyer->setDrawingIteration(visuorder);//set the drawing order of the curve of the order of the visualisation
}

void Visualisation::changeType(std::string type)
{
    //change the type of the curve for the visualisation
    if(strcmp(lindenmeyer->getType().c_str(),"hilbert")==0)
    {
        delete lindenmeyer;                             //delete current lindenmeyer system
        lindenmeyer = new L_System(height,width,type);  //make it new with the given type

        calcPoints(visuorder);              //calculate the points along the new curvetype
    }
    if(strcmp(lindenmeyer->getType().c_str(),"gosper")==0)
    {
        delete lindenmeyer;
        lindenmeyer = new L_System(height,width,type);

        calcPoints(visuorder);
    }
}

void Visualisation::calcPoints(int iteration)
{
    visupoints.clear(); //delete the current points

    for(int i = 0; i<maximum;i++)   //for each Vertex, calculate the new position
    {
        visupoints.push_back(mapping(points[i].x, iteration));
    }
    //set up the buffers to the new positions
    glGenBuffers(1, &positionBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, positionBuffer);
    glBufferData(GL_ARRAY_BUFFER, positioncount* sizeof(float), &visupoints[0], GL_STATIC_DRAW); 
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    glGenBuffers(1, &indexBuffer);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, edgeList.size()* sizeof(unsigned int), &edgeList[0], GL_STATIC_DRAW);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);

    glBindBuffer(GL_ARRAY_BUFFER, positionBuffer);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);

    glBindVertexArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

}

/*algo from the paper
SFCMap (value, order) -> (x, y) : {
segment = floor(value * num_segments)
if(order == 0){
select the segment of the basis curve
calculate (x, y) along this segment
} else {
subvalue = value * num_segments - segment
(x’, y’) = SFCMap(subvalue, order - 1)
transform (x’, y’) to (x, y) in right segment
}
return (x,y)
}
*/
glm::vec3 Visualisation::mapping(double value, int order)
{
    //calculate the segmentcount of the curve
    int maxSegmentcount = 0;
    if(strcmp(lindenmeyer->getType().c_str(),"hilbert")==0)
    {
        maxSegmentcount = (int)pow(4,(order))-1;
    }
    if(strcmp(lindenmeyer->getType().c_str(),"gosper")==0)
    {
        maxSegmentcount = (int)pow(7,(order));
    }
    
    //on which segment should the point be
    int segment = (int)glm::floor(value * maxSegmentcount);
    if(order == 0) 
    {
        return glm::vec3(value,value,0);
    }else {
        double subvalue = value * maxSegmentcount - segment;    //calculate the value on the curve with order = oredr -1
        glm::vec3 pos_prime = mapping(subvalue, order-1);       //recursion
        std::vector<glm::vec3> current = lindenmeyer->getPoints(order); //get points from lindenmeyer for the interpolation
        if(segment == maxSegmentcount)
        {
            return current[segment];
        }

        glm::vec3 tmp;
        if(order == 1)
        {
            tmp.x = pos_prime.x * current[segment + 1].x + (1-pos_prime.x) * current[segment].x;
            tmp.y = pos_prime.y * current[segment + 1].y + (1-pos_prime.y) * current[segment].y;
            //tmp.x = subvalue * current[segment + 1].x + (1-subvalue) * current[segment].x;
            //tmp.y = subvalue * current[segment + 1].y + (1-subvalue) * current[segment].y;
            tmp.z = 0.0;

            return tmp;
        }
        //float weight_x = (pos_prime.x + 0.9f)/(1.8f * 1.0f);//normalize [-0.9,0.9] to [0,1]
        //float weight_y = (pos_prime.y + 0.9f)/(1.8f * 1.0f);
        float weight_x = subvalue;
        float weight_y = subvalue;
        
        tmp.x = weight_x * current[segment + 1].x + (1-weight_x) * current[segment].x;
        tmp.y = weight_y * current[segment + 1].y + (1-weight_y) * current[segment].y;
        tmp.z = 0.0;

        return tmp;
    }
}

void Visualisation::draw(GLuint shader, bool drawPoints, bool drawCurve)
{   
    auto baseColor_location = glGetUniformLocation(shader, "color");
    if(positioncount < 1000)
    {
        glUniform4f(baseColor_location, 0.5f, 0.0f, 0.0f, 0.3f);
    }else{
        glUniform4f(baseColor_location, 0.5f, 0.0f, 0.0f, 0.1f);
    }

    glBindVertexArray(vao);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
    glDrawElements(GL_LINES, edgeList.size(), GL_UNSIGNED_INT, 0);
    glDisable(GL_BLEND);
    if(drawPoints)
    {
        glUniform4f(baseColor_location, 0.0f, 0.0f, 0.5f, 1.0f);
        glPointSize(3.0);
        glDrawElements(GL_POINTS, edgeList.size(), GL_UNSIGNED_INT, 0);
        glPointSize(1.0);
    }
    glBindVertexArray(0);
    if(drawCurve)
    {
        lindenmeyer->draw(shader);
    }
}