SO3ColourGradient.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#include "SO3Utils/SO3ColourGradient.h"
 
namespace SO3
{
 
  SColourGradient::SColourGradient(const bool& fillBoundsWithDefault) : fillBounds(fillBoundsWithDefault),
                                                                        minBoundDefaultColour(Ogre::ColourValue::Black),
                                                                        maxBoundDefaultColour(Ogre::ColourValue::White)
        {
  }
 
  SColourGradient::SColourGradient(const Ogre::ColourValue& overridedMinDefaultColour, const Ogre::ColourValue& overridedMaxDefaultColour) : fillBounds(true),
                                                                                                                                             minBoundDefaultColour(overridedMinDefaultColour),
                                                                                                                                             maxBoundDefaultColour(overridedMaxDefaultColour)
  {
  }
 
        SColourGradient::~SColourGradient()
        {
        }
 
  const Ogre::ColourValue SColourGradient::GetColour(const float& gradientPos) const
        {
    // Check parameter
    float gradientPosition = gradientPos;
    if(gradientPos < 0.0f)
      gradientPosition = 0.0f;
    if(gradientPos > 1.0f)
      gradientPosition = 1.0f;
 
    // No colours in the gradient!
                if (colourFrames.empty())
    {
      if(!fillBounds)
        return Ogre::ColourValue::Black;
      else
        return Interpolate(ColourFrame(0.0f, minBoundDefaultColour), ColourFrame(1.0f, maxBoundDefaultColour), gradientPosition);
    }
 
    // If the requested colour is exactly on a colour frame position
    ColourFrames::const_iterator iSearchedColourFrame = colourFrames.find(gradientPosition);
    if(iSearchedColourFrame != colourFrames.end())
      return iSearchedColourFrame->second;
 
    // Only one colour
                if (colourFrames.size() == 1)
    {
      if(!fillBounds)
      {
        // No bound filling, return the unique colour.
                          return colourFrames.begin()->second;
      }
      else
      {
        if(gradientPosition < colourFrames.begin()->first)
        {
          // Interpolate between default colour frame (0.0, Ogre::ColourValue::Black) and unique colour that is in the gradient.
          return Interpolate(ColourFrame(0.0f, minBoundDefaultColour), *colourFrames.begin(), gradientPosition);
        }
        else
        {
          // Interpolate between the unique colour that is in the gradient and default colour frame (1.0, Ogre::ColourValue::White).
          return Interpolate(*colourFrames.begin(), ColourFrame(1.0f, maxBoundDefaultColour), gradientPosition);
        }
      }
    }
 
    // Min colour value
    ColourFrames::const_iterator iMinBound = colourFrames.lower_bound(gradientPosition);
    if(iMinBound != colourFrames.begin())
      iMinBound--;
 
    // Max value
    ColourFrames::const_iterator iMaxBound = colourFrames.upper_bound(gradientPosition);
 
    // Handle the case where the requested value is below the smaller value in the gradient
    if(gradientPosition < iMinBound->first)
    {
      if(!fillBounds)
      {
        // No bound filling, return the colour which is just above the searched value.
                          return iMinBound->second;
      }
      else
      {
        // Interpolate between default colour frame (0.0, Ogre::ColourValue::Black) and the colour just above the searched value.
        return Interpolate(ColourFrame(0.0f, minBoundDefaultColour), *iMinBound, gradientPosition);
      }
    }
 
    // Handle the case where the requested value is above the greater value in the gradient
    if(iMaxBound == colourFrames.end())
    {
      iMaxBound--;
      if(!fillBounds)
      {
        // No bound filling, return the colour which is just below the searched value.
                          return iMaxBound->second;
      }
      else
      {
        // Interpolate between the colour just below the searched value and the default colour frame (1.0, Ogre::ColourValue::White).
        return Interpolate(*iMaxBound, ColourFrame(1.0f, maxBoundDefaultColour), gradientPosition);
      }
    }
 
    // Normal case
    return Interpolate(*iMinBound, *iMaxBound, gradientPosition);
        }
 
  Ogre::ColourValue SColourGradient::Interpolate(const ColourFrame& minColourFrame, const ColourFrame& maxColourFrame, const float& mediumRangeValue) const
  {
    float range = maxColourFrame.first - minColourFrame.first;
    float rangePoint = (mediumRangeValue - minColourFrame.first) / range;
    return ((minColourFrame.second * (1.0f - rangePoint)) + (maxColourFrame.second * rangePoint));
  }
 
}