ColourGradient.cpp

/*
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
  Multimediale Systeme der Informationsverarbeitung
  Institut fuer Informatik
  Christian-Albrechts-Universitaet Kiel


BIAS 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.1 of the License, or
(at your option) any later version.

BIAS 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 BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include <Utils/ColourGradient.hh>

using namespace std;
using namespace BIAS;


template <class StorageType>
BIAS::ColourGradient<StorageType>::
ColourGradient()
{
  // define colours
  std::vector<StorageType> black(3, 0);
  std::vector<StorageType> white(3, 1);

  // init members
  numChannels_ = 3;

  GradientStep<StorageType> left;
  left.pos = 0.0f;
  left.colour = black;
  gradientSteps_.push_front(left);

  GradientStep<StorageType> right;
  right.pos = 1.0f;
  right.colour = white;
  gradientSteps_.push_back(right);
}


template <class StorageType>
ColourGradient<StorageType>::
ColourGradient(typename ColourGradient<StorageType>::ColourGradientType mapType,
               const StorageType max)
{
  numChannels_ = 3;

  switch (mapType)
  {
    case Gray:
      AddRGBColour(0.0f,   0,   0,   0);
      AddRGBColour(1.0f, max, max, max);
      break;
    case Cool:
      AddRGBColour(0.0f,   0, max, max);
      AddRGBColour(1.0f, max,   0, max);
      break;
    case Hot:
      AddRGBColour(0.00f, (StorageType)(41.0/255.0 * max), 0, 0);
      AddRGBColour(0.33f, max,   0,   0);
      AddRGBColour(0.73f, max, max,   0);
      AddRGBColour(1.00f, max, max, max);
      break;
    case Bone:
      AddRGBColour(0.00f, 0, 0, (StorageType)(5.0/255.0 * max));
      AddRGBColour(0.33f, (StorageType)(74.0/255.0 * max),
                          (StorageType)(74.0/255.0 * max),
                          (StorageType)(106.0/255.0 * max));
      AddRGBColour(0.73f, (StorageType)(164.0/255.0 * max),
                          (StorageType)(196.0/255.0 * max),
                          (StorageType)(196.0/255.0 * max));
      AddRGBColour(1.00f, max, max, max);
      break;
    case Jet:
      AddRGBColour(0.00f,   0,   0, (StorageType)(189.0/255.0 * max));
      AddRGBColour(0.33f,   0, max, max);
      AddRGBColour(0.60f, max, max,   0);
      AddRGBColour(0.87f, max,   0,   0);
      AddRGBColour(1.00f, (StorageType)(132.0/255.0 * max), 0, 0);
      break;
    default:
      cerr << "unknown colour gradient type! using gray scale..." << endl;
      AddRGBColour(0.0f,   0,   0,   0);
      AddRGBColour(1.0f, max, max, max);
      break;
  }
}


template <class StorageType>
BIAS::ColourGradient<StorageType>::
ColourGradient(std::vector<StorageType> colourLeft,
               std::vector<StorageType> colourRight)
{
  BIASASSERT(colourLeft.size() ==  colourRight.size())
  BIASASSERT(colourLeft.size() > 0)

  numChannels_ = colourLeft.size();

  GradientStep<StorageType> left;
  left.pos = 0.0f;
  left.colour = colourLeft;
  gradientSteps_.push_front(left);

  GradientStep<StorageType> right;
  right.pos = 1.0f;
  right.colour = colourRight;
  gradientSteps_.push_back(right);
}


template <class StorageType>
void ColourGradient<StorageType>::
AddColour(float pos,
          const std::vector<StorageType> &colour)
{
  BIASASSERT(pos >= 0.0 && pos <= 1.0);
  BIASASSERT(colour.size() == numChannels_);

  if (gradientSteps_.size() == 0)
  {
    GradientStep<StorageType> step;
    step.pos    = pos;
    step.colour = colour;
    gradientSteps_.push_back(step);
    return;
  }

 typename list<GradientStep<StorageType> >::iterator it = gradientSteps_.begin();

  bool itLargerEqual = false; // set to true if it points to value with pos larger or equal the new input's pos

  while (it != gradientSteps_.end() && !itLargerEqual)
  {
    if (it->pos < pos)
    {
      it++;
    }
    else
    {
      itLargerEqual = true;
    }
  }

  if (it->pos == pos)
  {
    it->colour = colour;
  }
  else // it->pos is bigger than pos or is at the end so insert a new element
  {
    GradientStep<StorageType> step;
    step.pos = pos;
    step.colour = colour;
    gradientSteps_.insert(it, step);
  }
}


template <class StorageType>
void BIAS::ColourGradient<StorageType>::
GetColour(float pos,
          std::vector<StorageType> &colour)
{
  BIASASSERT(pos >= 0.0f && pos <= 1.0f)

  colour.clear();
  colour.resize(numChannels_);

  typename std::list<GradientStep<StorageType> >::iterator left
    = gradientSteps_.begin();
  typename std::list<GradientStep<StorageType> >::iterator right
    = ++(gradientSteps_.begin());

  do
  {
    if (pos >= left->pos && pos <= right->pos)
    {
      const float delta  = right->pos - left->pos;
      const float weight = (pos - left->pos) / delta;

      for (unsigned int c = 0; c < numChannels_; c++)
      {
        colour[c] = (StorageType)(((1.0f - weight) * left->colour[c]) +
                                  (weight * right->colour[c]));
      }

      return;
    }

    // prepare next iteration
    ++left;
    ++right;
  }
  while (right != gradientSteps_.end());
}


template <class StorageType>
void BIAS::ColourGradient<StorageType>::
AddRGBColour(float pos,
             const StorageType r, const StorageType g, const StorageType b)
{
  vector<StorageType> colour(3);
  colour[0] = r;
  colour[1] = g;
  colour[2] = b;
  AddColour(pos, colour);
}


//
// solve explicit instantiation
//


#define INSTANCE_ColourGradient(type)\
template class BIASUtils_EXPORT ColourGradient<type>;

namespace BIAS{
INSTANCE_ColourGradient(unsigned char)
INSTANCE_ColourGradient(float)
#ifdef BUILD_IMAGE_INT
  INSTANCE_ColourGradient(int)
#endif
#ifdef BUILD_IMAGE_CHAR
  INSTANCE_ColourGradient(char)
#endif
#ifdef BUILD_IMAGE_SHORT
  INSTANCE_ColourGradient(short)
#endif
#if defined(BUILD_IMAGE_USHORT)
  INSTANCE_ColourGradient(unsigned short)
#endif
#ifdef BUILD_IMAGE_DOUBLE
  INSTANCE_ColourGradient(double)
#endif
#ifdef BUILD_IMAGE_UINT
  INSTANCE_ColourGradient(unsigned int)
#endif
}