CColorBar.cpp

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, 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/CColorBar.h>
#include <mrpt/serialization/CArchive.h>
#include <mrpt/opengl/gl_utils.h>
 
#include "opengl_internals.h"
 
using namespace mrpt;
using namespace mrpt::opengl;
 
using namespace mrpt::math;
using namespace std;
 
IMPLEMENTS_SERIALIZABLE(CColorBar, CRenderizableDisplayList, mrpt::opengl)
 
CColorBar::CColorBar(
    /** The colormap to represent. */
    const mrpt::img::TColormap colormap,
    /** size of the color bar */
    double width, double height,
    /** limits for [0,1] colormap indices */
    double min_col, double max_col,
    /** limits for values associated to extreme colors */
    double min_value, double max_value,
    /** sprintf-like format string for values */
    const std::string& label_format,
    /** Label text font size */
    double label_font_size)
    : m_colormap(colormap),
      m_width(width),
      m_height(height),
      m_label_format(label_format),
      m_min_col(min_col),
      m_max_col(max_col),
      m_min_value(min_value),
      m_max_value(max_value),
      m_label_font_size(label_font_size),
      m_disable_depth_test(true)
{
}
 
CColorBar::Ptr CColorBar::Create(
    /** The colormap to represent. */
    const mrpt::img::TColormap colormap,
    /** size of the color bar */
    double width, double height,
    /** limits for [0,1] colormap indices */
    double min_col, double max_col,
    /** limits for values associated to extreme colors */
    double min_value, double max_value,
    /** sprintf-like format string for values */
    const std::string& label_format,
    /** Label text font size */
    double label_font_size)
{
    return CColorBar::Ptr(
        new CColorBar(
            colormap, width, height, min_col, max_col, min_value, max_value,
            label_format, label_font_size));
}
 
void CColorBar::setColormap(const mrpt::img::TColormap colormap)
{
    m_colormap = colormap;
    CRenderizableDisplayList::notifyChange();
}
 
void CColorBar::setColorAndValueLimits(
    double col_min, double col_max, double value_min, double value_max)
{
    m_min_col = col_min;
    m_max_col = col_max;
    m_min_value = value_min;
    m_max_value = value_max;
    CRenderizableDisplayList::notifyChange();
}
 
void mrpt::opengl::CColorBar::enableDepthTest(bool enable)
{
    m_disable_depth_test = enable;
    CRenderizableDisplayList::notifyChange();
}
 
/*---------------------------------------------------------------
                            render
  ---------------------------------------------------------------*/
void CColorBar::render_dl() const
{
#if MRPT_HAS_OPENGL_GLUT
    if (m_disable_depth_test)
        glDisable(GL_DEPTH_TEST);  // colobars are typically displayed on-top of
    // the rest of objects!
    glDisable(GL_LIGHTING);
 
    // solid:
    glShadeModel(GL_SMOOTH);
 
    unsigned int num_divisions = 64;
    unsigned int num_labels = 4;
    unsigned int one_label_each_nth = floor((num_divisions) / num_labels);
 
    const double x0 = .0, x1 = m_width, x2 = m_width * 1.3;
    const double Ay = m_height / (num_divisions - 1);
 
    std::vector<mrpt::img::TColorf> cols(num_divisions);
    for (unsigned int i = 0; i < num_divisions; i++)
    {
        const double col_idx =
            m_min_col + i * (m_max_col - m_min_col) / (num_divisions - 1);
        mrpt::img::colormap(
            m_colormap, col_idx, cols[i].R, cols[i].G, cols[i].B);
    }
 
    for (unsigned int i = 0; i < num_divisions - 1; i++)
    {
        const double y0 = Ay * i, y1 = Ay * (i + 1);
        const TPoint3D pt00(x0, y0, 0), pt10(x1, y0, 0);
        const TPoint3D pt01(x0, y1, 0), pt11(x1, y1, 0);
 
        // Color quad:
 
        glBegin(GL_TRIANGLES);
        glColor3f(cols[i].R, cols[i].G, cols[i].B);
        glVertex3f(pt00.x, pt00.y, pt00.z);
        glVertex3f(pt10.x, pt10.y, pt10.z);
        glColor3f(cols[i + 1].R, cols[i + 1].G, cols[i + 1].B);
        glVertex3f(pt11.x, pt11.y, pt11.z);
        //
        glColor3f(cols[i].R, cols[i].G, cols[i].B);
        glVertex3f(pt00.x, pt00.y, pt00.z);
        glColor3f(cols[i + 1].R, cols[i + 1].G, cols[i + 1].B);
        glVertex3f(pt11.x, pt11.y, pt11.z);
        glVertex3f(pt01.x, pt01.y, pt01.z);
        glEnd();
    }
 
    mrpt::opengl::gl_utils::glSetFont("mono");
 
    for (unsigned int i = 0; i < num_divisions; i++)
    {
        const double val =
            m_min_value + i * (m_max_value - m_min_value) / (num_divisions - 1);
        const double y0 = Ay * i;  //, y1 = Ay*(i + 1);
 
        // Text label:
        bool draw_label =
            (i % one_label_each_nth) == 0 || i == (num_divisions - 1);
 
        if (draw_label)
        {
            // Line:
            glLineWidth(1.0);
            glBegin(GL_LINES);
            glColor3b(0, 0, 0);
            glVertex2d(x0, y0);
            glVertex2d(x2, y0);
            glEnd();
 
            // Text:
            glPushMatrix();
 
            glTranslatef(x2, y0, 0.0);
            glColor3ub(0xff, 0xff, 0xff);
            mrpt::opengl::gl_utils::glDrawText(
                mrpt::format(m_label_format.c_str(), val), m_label_font_size);
 
            glPopMatrix();
        }
    }
 
    glEnable(GL_LIGHTING);
 
#endif
}
 
uint8_t CColorBar::serializeGetVersion() const { return 0; }
void CColorBar::serializeTo(mrpt::serialization::CArchive& out) const
{
    writeToStreamRender(out);
    // version 0
    out << uint32_t(m_colormap) << m_min_col << m_max_col << m_min_value
        << m_max_value << m_label_format << m_label_font_size
        << m_disable_depth_test;
}
void CColorBar::serializeFrom(
    mrpt::serialization::CArchive& in, uint8_t version)
{
    switch (version)
    {
        case 0:
            readFromStreamRender(in);
 
            in.ReadAsAndCastTo<uint32_t, mrpt::img::TColormap>(m_colormap);
            in >> m_min_col >> m_max_col >> m_min_value >> m_max_value >>
                m_label_format >> m_label_font_size >> m_disable_depth_test;
            break;
        default:
            MRPT_THROW_UNKNOWN_SERIALIZATION_VERSION(version)
    };
    CRenderizableDisplayList::notifyChange();
}
 
void CColorBar::getBoundingBox(
    mrpt::math::TPoint3D& bb_min, mrpt::math::TPoint3D& bb_max) const
{
    bb_min.x = 0;
    bb_min.y = 0;
    bb_min.z = 0;
 
    bb_max.x = m_width;
    bb_max.y = m_height;
    bb_max.z = 0;
 
    // Convert to coordinates of my parent:
    m_pose.composePoint(bb_min, bb_min);
    m_pose.composePoint(bb_max, bb_max);
}