COctoMapVoxels.cpp

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2017, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
 
#include "opengl-precomp.h"  // Precompiled header
 
#include <mrpt/opengl/COctoMapVoxels.h>
#include <mrpt/utils/CStream.h>
#include <mrpt/utils/stl_serialization.h>
#include "opengl_internals.h"
 
using namespace mrpt;
using namespace mrpt::opengl;
using namespace mrpt::utils;
using namespace mrpt::math;
using namespace std;
 
IMPLEMENTS_SERIALIZABLE(COctoMapVoxels, CRenderizableDisplayList, mrpt::opengl)
 
/** Ctor */
COctoMapVoxels::COctoMapVoxels()
        : m_enable_lighting(false),
          m_enable_cube_transparency(true),
          m_showVoxelsAsPoints(false),
          m_showVoxelsAsPointsSize(3.0f),
          m_show_grids(false),
          m_grid_width(1.0f),
          m_grid_color(0xE0, 0xE0, 0xE0, 0x90),
          m_visual_mode(COctoMapVoxels::COLOR_FROM_OCCUPANCY)
{
}
 
/** Clears everything */
void COctoMapVoxels::clear()
{
        m_voxel_sets.clear();
        m_grid_cubes.clear();
 
        CRenderizableDisplayList::notifyChange();
}
 
void COctoMapVoxels::setBoundingBox(
        const mrpt::math::TPoint3D& bb_min, const mrpt::math::TPoint3D& bb_max)
{
        m_bb_min = bb_min;
        m_bb_max = bb_max;
}
 
#if MRPT_HAS_OPENGL_GLUT
 
// See: http://www.songho.ca/opengl/gl_vertexarray.html
 
// cube ///////////////////////////////////////////////////////////////////////
//        v6----- v5
// +Z    /|      /|
// A    v1------v0|
// |    | |     | |
// |    | |v7---|-|v4   / -X
// |    |/      |/     /
// |    v2------v3    L +X
// ----------------------> +Y
//
 
const GLubyte grid_line_indices[] = {0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6,
                                                                         6, 7, 7, 4, 0, 5, 1, 6, 2, 7, 3, 4};
 
const GLubyte cube_indices[36] = {0, 1, 2, 2, 3, 0, 0, 3, 4, 4, 5, 0,
                                                                  0, 5, 6, 6, 1, 0, 1, 6, 7, 7, 2, 1,
                                                                  7, 4, 3, 3, 2, 7, 4, 7, 6, 6, 5, 4};
 
// normal array
const GLfloat normals_cube[3 * 6 * 4] = {
        1,  0,  0,  1,  0,  0,  1,  0,  0,  0,  0,  0,  // v0,v1,v2,v3 (front)
        0,  1,  0,  0,  1,  0,  0,  1,  0,  0,  1,  0,  // v0,v3,v4,v5 (right)
        0,  0,  1,  0,  0,  1,  0,  0,  1,  0,  0,  1,  // v0,v5,v6,v1 (top)
        0,  -1, 0,  0,  -1, 0,  0,  -1, 0,  0,  -1, 0,  // v1,v6,v7,v2 (left)
        0,  0,  -1, 0,  0,  -1, 0,  0,  -1, 0,  0,  -1,  // v7,v4,v3,v2 (bottom)
        -1, 0,  0,  -1, 0,  0,  -1, 0,  0,  -1, 0,  0};  // v4,v7,v6,v5 (back)
 
#endif
 
/*---------------------------------------------------------------
                                                        render
  ---------------------------------------------------------------*/
void COctoMapVoxels::render_dl() const
{
#if MRPT_HAS_OPENGL_GLUT
 
        glEnableClientState(GL_VERTEX_ARRAY);
 
        // Draw grids ====================================
        if (m_show_grids)
        {
                glLineWidth(m_grid_width);
                checkOpenGLError();
 
                glDisable(GL_LIGHTING);  // Disable lights when drawing lines
 
                // Antialiasing:
                glPushAttrib(GL_COLOR_BUFFER_BIT | GL_LINE_BIT);
                glEnable(GL_LINE_SMOOTH);
                if (m_grid_color.A != 255)
                {
                        glEnable(GL_BLEND);
                        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                }
 
                glColor4ub(
                        m_grid_color.R, m_grid_color.G, m_grid_color.B, m_grid_color.A);
 
                const size_t nGrids = m_grid_cubes.size();
                for (size_t i = 0; i < nGrids; i++)
                {
                        const TGridCube& c = m_grid_cubes[i];
 
                        const GLdouble vertices[8 * 3] = {
                                c.max.x, c.max.y, c.max.z, c.max.x, c.min.y, c.max.z,
                                c.max.x, c.min.y, c.min.z, c.max.x, c.max.y, c.min.z,
                                c.min.x, c.max.y, c.min.z, c.min.x, c.max.y, c.max.z,
                                c.min.x, c.min.y, c.max.z, c.min.x, c.min.y, c.min.z};
                        glVertexPointer(3, GL_DOUBLE, 0, vertices);
                        glDrawElements(
                                GL_LINES,
                                sizeof(grid_line_indices) / sizeof(grid_line_indices[0]),
                                GL_UNSIGNED_BYTE, grid_line_indices);
                }
 
                glEnable(GL_LIGHTING);  // Disable lights when drawing lines
                // End of antialiasing:
                glPopAttrib();
        }
 
        // Draw cubes ====================================
        if (!m_enable_lighting) glDisable(GL_LIGHTING);
 
        glEnableClientState(GL_NORMAL_ARRAY);
 
        glNormalPointer(GL_FLOAT, 0, normals_cube);
 
        if (m_enable_cube_transparency)
        {
                glEnable(GL_BLEND);
                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        }
 
        if (m_showVoxelsAsPoints)
        {
                glPointSize(m_showVoxelsAsPointsSize);
                glBegin(GL_POINTS);
        }
 
        for (size_t i = 0; i < m_voxel_sets.size(); i++)
        {
                if (!m_voxel_sets[i].visible) continue;
 
                const std::vector<TVoxel>& voxels = m_voxel_sets[i].voxels;
                const size_t N = voxels.size();
                for (size_t j = 0; j < N; j++)
                {
                        const mrpt::utils::TColor& vx_j_col = voxels[j].color;
                        glColor4ub(vx_j_col.R, vx_j_col.G, vx_j_col.B, vx_j_col.A);
 
                        const mrpt::math::TPoint3D& c = voxels[j].coords;
                        const double L = voxels[j].side_length * 0.5;
 
                        if (!m_showVoxelsAsPoints)
                        {
                                // Render as cubes:
                                const GLdouble vertices[8 * 3] = {
                                        c.x + L, c.y + L, c.z + L, c.x + L, c.y - L, c.z + L,
                                        c.x + L, c.y - L, c.z - L, c.x + L, c.y + L, c.z - L,
                                        c.x - L, c.y + L, c.z - L, c.x - L, c.y + L, c.z + L,
                                        c.x - L, c.y - L, c.z + L, c.x - L, c.y - L, c.z - L};
                                glVertexPointer(3, GL_DOUBLE, 0, vertices);
                                glDrawElements(
                                        GL_TRIANGLES,
                                        sizeof(cube_indices) / sizeof(cube_indices[0]),
                                        GL_UNSIGNED_BYTE, cube_indices);
                        }
                        else
                        {
                                // Render as simple points:
                                glVertex3f(c.x, c.y, c.z);
                        }
                }
        }
 
        if (m_showVoxelsAsPoints)
        {
                glEnd();  // of  GL_POINTS
        }
 
        if (m_enable_cube_transparency) glDisable(GL_BLEND);
 
        glDisableClientState(GL_NORMAL_ARRAY);
 
        if (!m_enable_lighting) glEnable(GL_LIGHTING);
 
        glDisableClientState(GL_VERTEX_ARRAY);
        checkOpenGLError();
 
#endif
}
 
DECLARE_CUSTOM_TTYPENAME(COctoMapVoxels::TInfoPerVoxelSet)
DECLARE_CUSTOM_TTYPENAME(COctoMapVoxels::TGridCube)
DECLARE_CUSTOM_TTYPENAME(COctoMapVoxels::TVoxel)
 
namespace mrpt
{
namespace utils
{
CStream& operator<<(
        mrpt::utils::CStream& out, const COctoMapVoxels::TInfoPerVoxelSet& a)
{
        out << a.visible << a.voxels;
        return out;
}
CStream& operator>>(
        mrpt::utils::CStream& in, COctoMapVoxels::TInfoPerVoxelSet& a)
{
        in >> a.visible >> a.voxels;
        return in;
}
 
CStream& operator<<(
        mrpt::utils::CStream& out, const COctoMapVoxels::TGridCube& a)
{
        out << a.min << a.max;
        return out;
}
CStream& operator>>(mrpt::utils::CStream& in, COctoMapVoxels::TGridCube& a)
{
        in >> a.min >> a.max;
        return in;
}
 
CStream& operator<<(mrpt::utils::CStream& out, const COctoMapVoxels::TVoxel& a)
{
        out << a.coords << a.side_length << a.color;
        return out;
}
CStream& operator>>(mrpt::utils::CStream& in, COctoMapVoxels::TVoxel& a)
{
        in >> a.coords >> a.side_length >> a.color;
        return in;
}
}
}
 
/*---------------------------------------------------------------
   Implements the writing to a CStream capability of
         CSerializable objects
  ---------------------------------------------------------------*/
void COctoMapVoxels::writeToStream(
        mrpt::utils::CStream& out, int* version) const
{
        if (version)
                *version = 2;
        else
        {
                writeToStreamRender(out);
 
                out << m_voxel_sets << m_grid_cubes << m_bb_min << m_bb_max
                        << m_enable_lighting << m_showVoxelsAsPoints
                        << m_showVoxelsAsPointsSize << m_show_grids << m_grid_width
                        << m_grid_color << m_enable_cube_transparency  // added in v1
                        << uint32_t(m_visual_mode);  // added in v2
        }
}
 
/*---------------------------------------------------------------
        Implements the reading from a CStream capability of
                CSerializable objects
  ---------------------------------------------------------------*/
void COctoMapVoxels::readFromStream(mrpt::utils::CStream& in, int version)
{
        switch (version)
        {
                case 0:
                case 1:
                case 2:
                {
                        readFromStreamRender(in);
 
                        in >> m_voxel_sets >> m_grid_cubes >> m_bb_min >> m_bb_max >>
                                m_enable_lighting >> m_showVoxelsAsPoints >>
                                m_showVoxelsAsPointsSize >> m_show_grids >> m_grid_width >>
                                m_grid_color;
 
                        if (version >= 1)
                                in >> m_enable_cube_transparency;
                        else
                                m_enable_cube_transparency = false;
 
                        if (version >= 2)
                        {
                                uint32_t i;
                                in >> i;
                                m_visual_mode =
                                        static_cast<COctoMapVoxels::visualization_mode_t>(i);
                        }
                        else
                                m_visual_mode = COctoMapVoxels::COLOR_FROM_OCCUPANCY;
                }
                break;
                default:
                        MRPT_THROW_UNKNOWN_SERIALIZATION_VERSION(version)
        };
 
        CRenderizableDisplayList::notifyChange();
}
 
void COctoMapVoxels::getBoundingBox(
        mrpt::math::TPoint3D& bb_min, mrpt::math::TPoint3D& bb_max) const
{
        bb_min = m_bb_min;
        bb_max = m_bb_max;
 
        // Convert to coordinates of my parent:
        m_pose.composePoint(bb_min, bb_min);
        m_pose.composePoint(bb_max, bb_max);
}
 
bool sort_voxels_z(
        const COctoMapVoxels::TVoxel& a, const COctoMapVoxels::TVoxel& b)
{
        return a.coords.z < b.coords.z;
}
 
void COctoMapVoxels::sort_voxels_by_z()
{
        for (size_t i = 0; i < m_voxel_sets.size(); i++)
        {
                std::sort(
                        m_voxel_sets[i].voxels.begin(), m_voxel_sets[i].voxels.end(),
                        &sort_voxels_z);
        }
}