TColorManager.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 "base-precomp.h"  // Precompiled headers
#include <mrpt/utils/TColorManager.h>
 
using namespace mrpt::utils;
using namespace std;
 
TColorManager::TColorManager(
                bool use_standard_colors_first/* = true */):
        color_thresh(255) {
 
        this->reset();
        this->use_standard_colors_first = use_standard_colors_first;
} // end of TColorManager (ctor)
 
TColorManager::~TColorManager() { }
 
TColor TColorManager::getNextTColor() {
 
        if (have_exceeded_colors) {
                // pick and return a random color triad
                return TColor(
                                rand() % (color_thresh + 1),
                                rand() % (color_thresh + 1),
                                rand() % (color_thresh + 1));
        }
 
        // start updating by the step if we don't use (or have already used) the
        // standard colors
        if (!use_standard_colors_first || have_used_standard_colors) {
                this->advanceRGBCounters();
        }
        else {
                bool used_red = used_colors.find(TColor::red) != used_colors.end();
                bool used_green = used_colors.find(TColor::green) != used_colors.end();
                bool used_blue = used_colors.find(TColor::blue) != used_colors.end();
 
                // fixed order of usage
                // red -> green -> blue
                if (!used_red) {
                        curr_color = TColor::red;
                }
                else if (!used_green) {
                        curr_color = TColor::green;
                }
                else if (!used_blue) {
                        curr_color = TColor::blue;
                        have_used_standard_colors = true;
                }
        }
 
        this->markColorAsUsed(curr_color);
        return curr_color;
} // end of getNextTColor
 
TColorf TColorManager::getNextTColorf() {
        return TColorf(this->getNextTColor());
} // end of getNextTColor
 
void TColorManager::advanceRGBCounters() {
        // method is used only when we either don't use or have already used the
        // standard colors.
        ASSERT_(
                        !use_standard_colors_first ||
                        have_used_standard_colors);
 
        THROW_EXCEPTION("Not yet implemented.");
        // if standard colors have already been used then at first color is TColor::blue
        if (curr_color == TColor::blue) {
                curr_color = TColor();
 
                color_step_triad.B = color_step;
        }
 
        // first advance blue until we reach the limit 255
        // then advance green until we reach the limit 255
        // finally advance red until we reach the limit 255
 
        // TODO - how do i do this?
        curr_color += color_step_triad;
 
 
        // if the standard colors are to be used first make sure that the color we
        // end up on is not a standard one.
        if (use_standard_colors_first &&
                        (curr_color == TColor::red ||
                         curr_color == TColor::green ||
                         curr_color == TColor::blue)) {
                this->advanceRGBCounters();
        }
 
} // end of advanceRGBCounters
 
void TColorManager::markColorAsUsed(TColor color) {
 
        using namespace std;
        pair<set<TColor>::const_iterator, bool> ret =
                used_colors.insert(color);
 
        // Should always return True as element shouldn't exist prior to this call
        ASSERT_(ret.second);
}
 
void TColorManager::reset() {
        used_colors.clear();
 
        curr_color = TColor();
        color_step_triad = TColor(0, 0, 50);
 
        have_exceeded_colors = false;
        use_standard_colors_first = true;
        have_used_standard_colors = false;
}
 
bool TColorManager::checkStdColorsUsed() {
        bool ret =
                used_colors.find(TColor::red) != used_colors.end() &&
                used_colors.find(TColor::green) != used_colors.end() &&
                used_colors.find(TColor::blue) != used_colors.end();
 
        return ret;
}