TColorManager.cpp

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          https://www.mrpt.org/                         |
   |                                                                        |
   | Copyright (c) 2005-2019, Individual contributors, see AUTHORS file     |
   | See: https://www.mrpt.org/Authors - All rights reserved.               |
   | Released under BSD License. See: https://www.mrpt.org/License          |
   +------------------------------------------------------------------------+ */

#include "img-precomp.h"  // Precompiled headers

#include <mrpt/img/TColorManager.h>

using namespace mrpt::img;
using namespace std;

TColorManager::TColorManager(bool use_standard_colors_first_in /* = true */)

{
    this->reset();
    this->use_standard_colors_first = use_standard_colors_first_in;
}  // end of TColorManager (ctor)

TColorManager::~TColorManager() = default;
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;
}