PointCloud.cpp

Go to the documentation of this file.

 /*
 * PointCloud.cpp
 *
 *  Created on: 20.08.2011
 *      Author: Thomas Wiemann
 */

#include "lvr2/display/PointCloud.hpp"
#include "lvr2/display/ColorMap.hpp"

#include <string.h>

namespace lvr2
{

PointCloud::PointCloud()
{
    m_numNormals = 0;
    m_boundingBox = new BoundingBox<Vec>;
    m_renderMode = RenderPoints;
}

PointCloud::PointCloud( PointBufferPtr buffer, string name) : Renderable(name)
{
        m_model = ModelPtr(new Model(buffer));
        init(buffer);
}

PointCloud::PointCloud( ModelPtr model, string name) : Renderable(name)
{

    m_model = model;
    init(m_model->m_pointCloud);
}

void PointCloud::updateBuffer(PointBufferPtr buffer)
{
        init(buffer);

}

void PointCloud::init(PointBufferPtr buffer)
{
        int maxColors = 255;
        m_numNormals = 0;

        m_boundingBox = new BoundingBox<Vec>;
        m_renderMode = RenderPoints;

        if(buffer)
        {
                size_t n_points = buffer->numPoints();
                floatArr points = buffer->getPointArray();
        m_numNormals = 0;
                m_normals    = buffer->getNormalArray();

        if (m_normals)
            m_numNormals = n_points;

        size_t w_color, dummy;
                ucharArr colors      = buffer->getColorArray(w_color);
                floatArr intensities = buffer->getFloatArray("intensities", n_points, dummy);

                ColorMap c_map(maxColors);

                for(size_t i = 0; i < n_points; i++)
                {
                        float x = points[i*3 + 0];
                        float y = points[i*3 + 1];
                        float z = points[i*3 + 2];

                        m_boundingBox->expand(Vec(x,y,z));

                        unsigned char r, g, b;

                        if(colors)
                        {
                                r = colors[i*w_color + 0];
                                g = colors[i*w_color + 1];
                                b = colors[i*w_color + 2];
                        }
                        else if (intensities)
                        {
                                // Get intensity
                                float color[3];
                                c_map.getColor(color, (size_t)intensities[i], SHSV);

                                r = (unsigned char)(color[0] * 255);
                                g = (unsigned char)(color[1] * 255);
                                b = (unsigned char)(color[2] * 255);

                        }
                        else
                        {
                                r = 0;
                                g = 0;
                                b = 0;
                        }


                        m_points.push_back(uColorVertex(x, y, z, r, g, b));
                }
        }
        updateDisplayLists();
}

void PointCloud::updateDisplayLists(){

    // Check for existing display list for normal rendering
    if(m_listIndex != -1) {
        cout<<"PointCloud::initDisplayList() delete display list"<<endl;
        glDeleteLists(m_listIndex,1);
    }

    // Create new display list and render points
    m_listIndex = glGenLists(1);
    glNewList(m_listIndex, GL_COMPILE);
    glBegin(GL_POINTS);

    for(size_t i = 0; i < m_points.size(); i++)
    {
        float r = m_points[i].r / 255.0f;
        float g = m_points[i].g / 255.0f;
        float b = m_points[i].b / 255.0f;

        glColor3f(r, g, b);
        glVertex3f(m_points[i].x,
                   m_points[i].y,
                   m_points[i].z);
    }
    glEnd();
    glEndList();

    // Check for existing list index for rendering a selected point
    // cloud
    if(m_activeListIndex != -1)
    {
        glDeleteLists(m_activeListIndex,1);
    }

    m_activeListIndex = glGenLists(1);
    glNewList(m_activeListIndex, GL_COMPILE);
    glBegin(GL_POINTS);

    glColor3f(1.0, 1.0, 0.0);
    for(size_t i = 0; i < m_points.size(); i++)
    {

        glVertex3f(m_points[i].x,
                   m_points[i].y,
                   m_points[i].z);
    }
    glEnd();
    glEndList();

    float length = 0.01f * m_boundingBox->getRadius();

    // Create a new display list for normals
    if(m_numNormals)
    {
        m_normalListIndex = glGenLists(1);
        glNewList(m_normalListIndex, GL_COMPILE);
        glColor3f(1.0, 0.0, 1.0);
        for(int i = 0; i < m_numNormals; i++)
        {
            Vec start(m_points[i].x, m_points[i].y, m_points[i].z);
            Normal<float> normal(m_normals[i*3 + 0], m_normals[i*3 + 1], m_normals[i*3 + 2]);
            Vec end = start + normal * length;
            glBegin(GL_LINES);
            glVertex3f(start[0], start[1], start[2]);
            glVertex3f(end[0], end[1], end[2]);
            glEnd();
        }
        glEndList();
    }

}

PointCloud::~PointCloud() {
    // TODO Auto-generated destructor stub
}

} // namespace lvr2