RasterTransform.cpp

Go to the documentation of this file.

/*  Copyright (C) 2008 National Institute For Space Research (INPE) - Brazil.

    This file is part of the TerraLib - a Framework for building GIS enabled applications.

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

    TerraLib 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 TerraLib. See COPYING. If not, write to
    TerraLib Team at <terralib-team@terralib.org>.
 */

/*!
  \file RasterTransform.h

  \brief A Raster Transform is a class that defines functions to transform a styled raster.
*/

// TerraLib
#include "RasterTransform.h"

#include "../raster/RasterProperty.h"
#include "../se/RasterSymbolizer.h"
#include "Exception.h"

// Boost
#include <boost/math/special_functions/fpclassify.hpp>

// STL
#include <limits>
#include <algorithm>

te::map::RasterTransform::RasterTransform(te::rst::Raster* input, te::rst::Raster* output) :
  m_rasterIn(input),
  m_rasterOut(output),
  m_currentContrastType( LINEAR_CONTRAST ),
  m_contrastTransfFuncPtr( &RasterTransform::applyLinearContrast ),
  m_transp(TE_OPAQUE),
  m_monoBand(0),
  m_monoBandOut(0),
  m_transfFuncPtr(&RasterTransform::setExtractRGB),
  m_RGBAFuncPtr(&RasterTransform::getExtractRGB)
{
  m_rstMinValue.resize(std::max( static_cast<size_t>(4), input->getNumberOfBands() ), -std::numeric_limits<double>::max());
  m_rstMaxValue.resize(std::max( static_cast<size_t>(4), input->getNumberOfBands() ), std::numeric_limits<double>::max());

  m_gamma.resize( std::max( static_cast<size_t>(4), input->getNumberOfBands() ), 1.0 );
  m_contrastGains.resize( std::max( static_cast<size_t>(4), input->getNumberOfBands() ), 1.0 );
  m_contrastOffsets1.resize( std::max( static_cast<size_t>(4), input->getNumberOfBands() ), 0.0 );
  m_contrastOffsets2.resize( std::max( static_cast<size_t>(4), input->getNumberOfBands() ), 0.0 );
}

te::map::RasterTransform::~RasterTransform()
{
  m_categorizeMap.clear();
  m_interpolateMap.clear();
  m_recodeMap.clear();
  m_rgbMap.clear();
}

void te::map::RasterTransform::setGain(double value)
{
  std::fill( m_contrastGains.begin(), m_contrastGains.end(), value );
}

double te::map::RasterTransform::getGain() const
{
  assert( !m_contrastGains.empty() );
  return m_contrastGains[ 0 ];
}

void te::map::RasterTransform::setOffset(double value)
{
  std::fill( m_contrastOffsets1.begin(), m_contrastOffsets1.end(), value );
  std::fill( m_contrastOffsets2.begin(), m_contrastOffsets2.end(), value );
}

void te::map::RasterTransform::setContrastType( const ContrastType& newType )
{
  m_currentContrastType = newType;
  setContrastFuncPtr( m_currentContrastType );
}

double te::map::RasterTransform::getOffset()
{
  assert( !m_contrastOffsets1.empty() );
  return m_contrastOffsets1[ 0 ];
}

void te::map::RasterTransform::setGammaR(double value)
{
  assert( m_gamma.size() > RED_CHANNEL );
  m_gamma[ RED_CHANNEL ] = value;
}

double te::map::RasterTransform::getGammaR()
{
  assert( m_gamma.size() > RED_CHANNEL );
  return m_gamma[ RED_CHANNEL ];
}

void te::map::RasterTransform::setGammaG(double value)
{
  assert( m_gamma.size() > GREEN_CHANNEL );
  m_gamma[ GREEN_CHANNEL ] = value;
}

double te::map::RasterTransform::getGammaG()
{
  assert( m_gamma.size() > GREEN_CHANNEL );
  return m_gamma[ GREEN_CHANNEL ];
}

void te::map::RasterTransform::setGammaB(double value)
{
  assert( m_gamma.size() > BLUE_CHANNEL );
  m_gamma[ BLUE_CHANNEL ] = value;
}

double te::map::RasterTransform::getGammaB()
{
  assert( m_gamma.size() > BLUE_CHANNEL );
  return m_gamma[ BLUE_CHANNEL ];
}

void te::map::RasterTransform::setGammaM(double value)
{
  assert( m_gamma.size() > static_cast<std::size_t>(m_monoBand) );
  m_gamma[ static_cast<size_t>(m_monoBand) ] = value;
}

double te::map::RasterTransform::getGammaM()
{
  assert( m_gamma.size() > static_cast<std::size_t>(m_monoBand) );
  return m_gamma[ static_cast<size_t>(m_monoBand) ];
}

void te::map::RasterTransform::setRGBMap(std::map<RGBChannels, short>& /*rgbMap*/)
{
  m_rgbMap.clear();
  m_rgbMap[RED_CHANNEL] = -1;
  m_rgbMap[GREEN_CHANNEL] = -1;
  m_rgbMap[BLUE_CHANNEL] = -1;
  m_rgbMap[ALPHA_CHANNEL] = -1;

  std::map<RGBChannels,short>::iterator it = m_rgbMap.begin();
  while (it != m_rgbMap.end())
  {
    if (it->first == RED_CHANNEL)
    m_rgbMap[RED_CHANNEL] = it->second;

    else if (it->first == GREEN_CHANNEL)
    m_rgbMap[GREEN_CHANNEL] = it->second;

    else if (it->first == BLUE_CHANNEL)
    m_rgbMap[BLUE_CHANNEL] = it->second;

    else if (it->first == ALPHA_CHANNEL)
    m_rgbMap[ALPHA_CHANNEL] = it->second;

    ++it;
  }
}

void te::map::RasterTransform::setLinearTransfParameters(double vmin, double vmax, double rmin, double rmax)
{
  std::fill(m_rstMinValue.begin(), m_rstMinValue.end(), rmin);
  std::fill(m_rstMaxValue.begin(), m_rstMaxValue.end(), rmax);

  double gain = 1.0;
  double offset = 0.0;

  if(vmax == vmin)
  {
    gain = 1.0;
    offset = 0.0;
  }
  else
  {
    gain = static_cast<double>(rmax-rmin)/(vmax-vmin);

    if(boost::math::isnan(gain) || boost::math::isinf(gain))
    {
      gain = 1.0;
      offset = 0.0;
    }
    else
    {
      offset = -1*gain*vmin+rmin;
    }
  }

  std::fill( m_contrastGains.begin(), m_contrastGains.end(), gain );
  std::fill( m_contrastOffsets1.begin(), m_contrastOffsets1.end(), offset );
  std::fill( m_contrastOffsets2.begin(), m_contrastOffsets2.end(), offset );
}

void te::map::RasterTransform::setLinearTransfParameters(double vmin, double vmax, double rmin, double rmax, int band)
{
  m_rstMinValue[static_cast<size_t>(band)] = rmin;
  m_rstMaxValue[static_cast<size_t>(band)] = rmax;

  double gain = 1.0;
  double offset = 0.0;

  if (vmax == vmin)
  {
    gain = 1.0;
    offset = 0.0;
  }
  else
  {
    gain = static_cast<double>(rmax - rmin) / (vmax - vmin);

    if (boost::math::isnan(gain) || boost::math::isinf(gain))
    {
      gain = 1.0;
      offset = 0.0;
    }
    else
    {
      offset = -1 * gain*vmin + rmin;
    }
  }

  m_contrastGains[static_cast<size_t>(band)] = gain;
  m_contrastOffsets1[static_cast<size_t>(band)] = offset;
  m_contrastOffsets2[static_cast<size_t>(band)] = offset;
}

te::map::RasterTransform::RasterTransfFunctions te::map::RasterTransform::getTransfFunction()
{
  if (m_transfFuncPtr == nullptr || m_RGBAFuncPtr)
  {
    return NO_TRANSF;
  }
  else  if (m_transfFuncPtr == &RasterTransform::setMono2ThreeBand &&
            m_RGBAFuncPtr == &RasterTransform::getMono2ThreeBand)
  {
    return MONO2THREE_TRANSF;
  }
  else if (m_transfFuncPtr == &RasterTransform::setExtractRGB &&
           m_RGBAFuncPtr == &RasterTransform::getExtractRGB)
  {
    return EXTRACT2RGB_TRANSF;
  }
  else  if (m_transfFuncPtr == &RasterTransform::setRed2ThreeBand &&
            m_RGBAFuncPtr == &RasterTransform::getRed2ThreeBand)
  {
    return RED2THREE_TRANSF;
  }
  else  if (m_transfFuncPtr == &RasterTransform::setGreen2ThreeBand &&
            m_RGBAFuncPtr == &RasterTransform::getGreen2ThreeBand)
  {
    return GREEN2THREE_TRANSF;
  }
  else  if (m_transfFuncPtr == &RasterTransform::setBlue2ThreeBand &&
            m_RGBAFuncPtr == &RasterTransform::getBlue2ThreeBand)
  {
    return BLUE2THREE_TRANSF;
  }
  else  if (m_transfFuncPtr == &RasterTransform::setCategorize &&
            m_RGBAFuncPtr == &RasterTransform::getCategorize)
  {
    return CATEGORIZE_TRANSF;
  }
  else  if (m_transfFuncPtr == &RasterTransform::setInterpolate &&
            m_RGBAFuncPtr == &RasterTransform::getInterpolate)
  {
    return INTERPOLATE_TRANSF;
  }
  else  if (m_transfFuncPtr == &RasterTransform::setRecode &&
    m_RGBAFuncPtr == &RasterTransform::getRecode)
  {
    return RECODE_TRANSF;
  }
  else  if (m_transfFuncPtr == &RasterTransform::setBand2Band)
  {
    return BAND2BAND_TRANSF;
  }
  else
  {
    return NO_TRANSF;
  }
}

void te::map::RasterTransform::setTransfFunction(RasterTransfFunctions func)
{
  if (func == MONO2THREE_TRANSF)
  {
    m_transfFuncPtr = &RasterTransform::setMono2ThreeBand;
    m_RGBAFuncPtr = &RasterTransform::getMono2ThreeBand;
  }
  else if (func == EXTRACT2RGB_TRANSF)
  {
    m_transfFuncPtr = &RasterTransform::setExtractRGB;
    m_RGBAFuncPtr = &RasterTransform::getExtractRGB;
  }
  else if (func == RED2THREE_TRANSF)
  {
    m_transfFuncPtr = &RasterTransform::setRed2ThreeBand;
    m_RGBAFuncPtr = &RasterTransform::getRed2ThreeBand;
  }
  else if (func == GREEN2THREE_TRANSF)
  {
    m_transfFuncPtr = &RasterTransform::setGreen2ThreeBand;
    m_RGBAFuncPtr = &RasterTransform::getGreen2ThreeBand;
  }
  else if (func == BLUE2THREE_TRANSF)
  {
    m_transfFuncPtr = &RasterTransform::setBlue2ThreeBand;
    m_RGBAFuncPtr = &RasterTransform::getBlue2ThreeBand;
  }
  else if (func == CATEGORIZE_TRANSF)
  {
    m_transfFuncPtr = &RasterTransform::setCategorize;
    m_RGBAFuncPtr = &RasterTransform::getCategorize;
  }
  else if (func == INTERPOLATE_TRANSF)
  {
    m_transfFuncPtr = &RasterTransform::setInterpolate;
    m_RGBAFuncPtr = &RasterTransform::getInterpolate;
  }
  else if (func == RECODE_TRANSF)
  {
    m_transfFuncPtr = &RasterTransform::setRecode;
    m_RGBAFuncPtr = &RasterTransform::getRecode;
  }
  else if (func == BAND2BAND_TRANSF)
  {
    m_transfFuncPtr = &RasterTransform::setBand2Band;
    m_RGBAFuncPtr = nullptr;
  }
  else if (func == EXTRACT2RGBA_TRANSF)
  {
    m_transfFuncPtr = &RasterTransform::setExtractRGBA;
    m_RGBAFuncPtr = &RasterTransform::getExtractRGBA;
  }
  else
  {
    m_transfFuncPtr = nullptr;
    m_RGBAFuncPtr = nullptr;
  }
}

void te::map::RasterTransform::setContrastGainsAndOffsets(
  const std::vector< double >& contrastGains,
  const std::vector< double >& contrastOffsets1,
  const std::vector< double >& contrastOffsets2 )
{
  if(
      ( contrastGains.size() != m_rasterIn->getNumberOfBands() )
      ||
      ( contrastOffsets1.size() != m_rasterIn->getNumberOfBands() )
      ||
      ( contrastOffsets2.size() != m_rasterIn->getNumberOfBands() )
    )
  {
    throw Exception(TE_TR("Invalid vector size"));
  }

  m_contrastGains = contrastGains;
  m_contrastOffsets1 = contrastOffsets1;
  m_contrastOffsets2 = contrastOffsets2;
}

void te::map::RasterTransform::setContrastFuncPtr(
  const RasterTransform::ContrastType contrastType )
{
  switch( contrastType )
  {
    case LINEAR_CONTRAST :
    {
      m_contrastTransfFuncPtr = &RasterTransform::applyLinearContrast;
      break;
    }
    case SQUARE_CONTRAST :
    {
      m_contrastTransfFuncPtr = &RasterTransform::applySquareContrast;
      break;
    }
    case SQUARE_ROOT_CONTRAST :
    {
      m_contrastTransfFuncPtr = &RasterTransform::applySquareRootContrast;
      break;
    }
    case LOG_CONTRAST :
    {
      m_contrastTransfFuncPtr = &RasterTransform::applyLogContrast;
      break;
    }
  }
}

void te::map::RasterTransform::setMono2ThreeBand(double icol, double ilin, double ocol, double olin)
{
  double val;

  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), val, static_cast<size_t>(m_monoBand));

  if(checkNoValue(val, m_monoBand) == false)
  {
    (this->*(m_contrastTransfFuncPtr))( static_cast<unsigned int>(m_monoBand), val, val );

    val *= m_gamma[ static_cast<size_t>(m_monoBand) ];

    fixValue(val, m_monoBand);

    std::vector<double> vecValues;
    vecValues.resize(3, val);

    m_rasterOut->setValues(static_cast<unsigned int>(ocol), static_cast<unsigned int>(olin), vecValues);
  }
}

te::color::RGBAColor te::map::RasterTransform::getMono2ThreeBand(double icol, double ilin)
{
  double val;

  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), val,static_cast<unsigned int>( m_monoBand));

  if(checkNoValue(val, m_monoBand) == false)
  {
    (this->*(m_contrastTransfFuncPtr))( static_cast<unsigned int>(m_monoBand), val, val );

    val *= m_gamma[ static_cast<size_t>(m_monoBand) ];

    fixValue(val, m_monoBand);

    if(std::isnan(val))
    {
      return te::color::RGBAColor();
    }

    double transp = checkAlphaValue(icol, ilin);

    te::color::RGBAColor c(static_cast<int>(val), static_cast<int>(val), static_cast<int>(val), static_cast<int>(transp));

    return c;
  }

  return te::color::RGBAColor();
}

void te::map::RasterTransform::setExtractRGB(double icol, double ilin, double ocol, double olin)
{
  double valR, valG, valB;

  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), valR, static_cast<size_t>(m_rgbMap[RED_CHANNEL]));
  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), valG, static_cast<size_t>(m_rgbMap[GREEN_CHANNEL]));
  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), valB, static_cast<size_t>(m_rgbMap[BLUE_CHANNEL]));

  if(checkNoValue(valR, m_rgbMap[RED_CHANNEL]) == false ||
     checkNoValue(valG, m_rgbMap[GREEN_CHANNEL]) == false ||
     checkNoValue(valB, m_rgbMap[BLUE_CHANNEL]) == false)
  {
    std::vector<double> vecValues;

    (this->*(m_contrastTransfFuncPtr))(static_cast<unsigned int>(m_rgbMap[RED_CHANNEL]), valR, valR);
    valR *= m_gamma[ RED_CHANNEL ];
    fixValue(valR, m_rgbMap[RED_CHANNEL]);
    vecValues.push_back(valR);

    (this->*(m_contrastTransfFuncPtr))(static_cast<unsigned int>(m_rgbMap[GREEN_CHANNEL]), valG, valG);
    valG *= m_gamma[ GREEN_CHANNEL ];
    fixValue(valG, m_rgbMap[GREEN_CHANNEL]);
    vecValues.push_back(valG);

    (this->*(m_contrastTransfFuncPtr))(static_cast<unsigned int>(m_rgbMap[BLUE_CHANNEL]), valB, valB);
    valB *= m_gamma[ BLUE_CHANNEL ];
    fixValue(valB, m_rgbMap[BLUE_CHANNEL]);
    vecValues.push_back(valB);

    m_rasterOut->setValues(static_cast<unsigned int>(ocol), static_cast<unsigned int>(olin), vecValues);
  }
}

te::color::RGBAColor te::map::RasterTransform::getExtractRGB(double icol, double ilin)
{
  double valR, valG, valB;

  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), valR, static_cast<size_t>(m_rgbMap[RED_CHANNEL]));
  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), valG, static_cast<size_t>(m_rgbMap[GREEN_CHANNEL]));
  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), valB, static_cast<size_t>(m_rgbMap[BLUE_CHANNEL]));

  if(checkNoValue(valR, m_rgbMap[RED_CHANNEL]) == false ||
     checkNoValue(valG, m_rgbMap[GREEN_CHANNEL]) == false ||
     checkNoValue(valB, m_rgbMap[BLUE_CHANNEL]) == false)
  {
    (this->*(m_contrastTransfFuncPtr))(static_cast<unsigned int>(m_rgbMap[RED_CHANNEL]), valR, valR);
    valR *= m_gamma[ RED_CHANNEL ];
    fixValue(valR, m_rgbMap[RED_CHANNEL]);

    (this->*(m_contrastTransfFuncPtr))(static_cast<unsigned int>(m_rgbMap[GREEN_CHANNEL]), valG, valG);
    valG *= m_gamma[ GREEN_CHANNEL ];
    fixValue(valG, m_rgbMap[GREEN_CHANNEL]);

    (this->*(m_contrastTransfFuncPtr))(static_cast<unsigned int>(m_rgbMap[BLUE_CHANNEL]), valB, valB);
    valB *= m_gamma[ BLUE_CHANNEL ];
    fixValue(valB, m_rgbMap[BLUE_CHANNEL]);

    double transp = checkAlphaValue(icol, ilin);

    te::color::RGBAColor c(static_cast<int>(valR), static_cast<int>(valG), static_cast<int>(valB), static_cast<int>(transp));

    return c;
  }

  return te::color::RGBAColor();
}

void te::map::RasterTransform::setExtractRGBA(double icol, double ilin, double ocol, double olin)
{
  double valR, valG, valB, valA;

  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), valR, static_cast<size_t>(m_rgbMap[RED_CHANNEL]));
  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), valG, static_cast<size_t>(m_rgbMap[GREEN_CHANNEL]));
  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), valB, static_cast<size_t>(m_rgbMap[BLUE_CHANNEL]));
  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), valA, static_cast<size_t>(m_rgbMap[ALPHA_CHANNEL]));

  if(checkNoValue(valR, m_rgbMap[RED_CHANNEL]) == false ||
     checkNoValue(valG, m_rgbMap[GREEN_CHANNEL]) == false ||
     checkNoValue(valB, m_rgbMap[BLUE_CHANNEL]) == false ||
     checkNoValue(valA, m_rgbMap[ALPHA_CHANNEL]) == false)
  {
    std::vector<double> vecValues;

    (this->*(m_contrastTransfFuncPtr))(static_cast<unsigned int>(m_rgbMap[RED_CHANNEL]), valR, valR);
    valR *= m_gamma[ RED_CHANNEL ];
    fixValue(valR, m_rgbMap[RED_CHANNEL]);
    vecValues.push_back(valR);

    (this->*(m_contrastTransfFuncPtr))(static_cast<unsigned int>(m_rgbMap[GREEN_CHANNEL]), valG, valG);
    valG *= m_gamma[ GREEN_CHANNEL ];
    fixValue(valG, m_rgbMap[GREEN_CHANNEL]);
    vecValues.push_back(valG);

    (this->*(m_contrastTransfFuncPtr))(static_cast<unsigned int>(m_rgbMap[BLUE_CHANNEL]), valB, valB);
    valB *= m_gamma[ BLUE_CHANNEL ];
    fixValue(valB, m_rgbMap[BLUE_CHANNEL]);
    vecValues.push_back(valB);

    fixValue(valA, m_rgbMap[ALPHA_CHANNEL]);
    vecValues.push_back(valB);

    m_rasterOut->setValues(static_cast<unsigned int>(ocol), static_cast<unsigned int>(olin), vecValues);
  }
}

te::color::RGBAColor te::map::RasterTransform::getExtractRGBA(double icol, double ilin)
{
  double valR, valG, valB, valA;

  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), valR, static_cast<size_t>(m_rgbMap[RED_CHANNEL]));
  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), valG, static_cast<size_t>(m_rgbMap[GREEN_CHANNEL]));
  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), valB, static_cast<size_t>(m_rgbMap[BLUE_CHANNEL]));
  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), valA, static_cast<size_t>(m_rgbMap[ALPHA_CHANNEL]));

  if(checkNoValue(valR, m_rgbMap[RED_CHANNEL]) == false ||
     checkNoValue(valG, m_rgbMap[GREEN_CHANNEL]) == false ||
     checkNoValue(valB, m_rgbMap[BLUE_CHANNEL]) == false ||
     checkNoValue(valA, m_rgbMap[ALPHA_CHANNEL]) == false)
  {
    (this->*(m_contrastTransfFuncPtr))(static_cast<unsigned int>(m_rgbMap[RED_CHANNEL]), valR, valR);
    valR *= m_gamma[ RED_CHANNEL ];
    fixValue(valR, m_rgbMap[RED_CHANNEL]);

    (this->*(m_contrastTransfFuncPtr))(static_cast<unsigned int>(m_rgbMap[GREEN_CHANNEL]), valG, valG);
    valG *= m_gamma[ GREEN_CHANNEL ];
    fixValue(valG, m_rgbMap[GREEN_CHANNEL]);

    (this->*(m_contrastTransfFuncPtr))(static_cast<unsigned int>(m_rgbMap[BLUE_CHANNEL]), valB, valB);
    valB *= m_gamma[ BLUE_CHANNEL ];
    fixValue(valB, m_rgbMap[BLUE_CHANNEL]);

    fixValue(valA, m_rgbMap[ALPHA_CHANNEL]);

    if(valA < m_transp)
      return te::color::RGBAColor(static_cast<int>(valR), static_cast<int>(valG), static_cast<int>(valB), static_cast<int>(valA));
    else
      return te::color::RGBAColor(static_cast<int>(valR), static_cast<int>(valG), static_cast<int>(valB), static_cast<int>(m_transp));
  }

  return te::color::RGBAColor();
}

void te::map::RasterTransform::setRed2ThreeBand(double icol, double ilin, double ocol, double olin)
{
  double val;

  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), val, static_cast<size_t>(m_rgbMap[RED_CHANNEL]));

  if(checkNoValue(val, m_rgbMap[RED_CHANNEL]) == false)
  {
    (this->*(m_contrastTransfFuncPtr))(static_cast<unsigned int>(m_rgbMap[RED_CHANNEL]), val, val);
    val *= m_gamma[ RED_CHANNEL ];
    fixValue(val, m_rgbMap[RED_CHANNEL]);

    std::vector<double> vecValues;
    vecValues.push_back(val);
    vecValues.push_back(0.);
    vecValues.push_back(0.);

    m_rasterOut->setValues(static_cast<unsigned int>(ocol), static_cast<unsigned int>(olin), vecValues);
  }
}

te::color::RGBAColor te::map::RasterTransform::getRed2ThreeBand(double icol, double ilin)
{
  double val;

  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), val, static_cast<size_t>(m_rgbMap[RED_CHANNEL]));

  if(checkNoValue(val, m_rgbMap[RED_CHANNEL]) == false)
  {
    (this->*(m_contrastTransfFuncPtr))(static_cast<unsigned int>(m_rgbMap[RED_CHANNEL]), val, val);
    val *= m_gamma[ RED_CHANNEL ];
    fixValue(val, m_rgbMap[RED_CHANNEL]);

    double transp = checkAlphaValue(icol, ilin);

    te::color::RGBAColor c(static_cast<int>(val), static_cast<int>(0.), static_cast<int>(0.), static_cast<int>(transp));

    return c;

  }

  return te::color::RGBAColor();
}

void te::map::RasterTransform::setGreen2ThreeBand(double icol, double ilin, double ocol, double olin)
{
  double val;

  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), val, static_cast<size_t>(m_rgbMap[GREEN_CHANNEL]));

  if(checkNoValue(val, m_rgbMap[GREEN_CHANNEL]) == false)
  {
    (this->*(m_contrastTransfFuncPtr))(static_cast<unsigned int>(m_rgbMap[GREEN_CHANNEL]), val, val);
    val *= m_gamma[ GREEN_CHANNEL ];
    fixValue(val, m_rgbMap[GREEN_CHANNEL]);

    std::vector<double> vecValues;
    vecValues.push_back(0.);
    vecValues.push_back(val);
    vecValues.push_back(0.);

    m_rasterOut->setValues(static_cast<unsigned int>(ocol), static_cast<unsigned int>(olin), vecValues);
  }
}

te::color::RGBAColor te::map::RasterTransform::getGreen2ThreeBand(double icol, double ilin)
{
  double val;

  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), val, static_cast<size_t>(m_rgbMap[GREEN_CHANNEL]));

  if(checkNoValue(val, m_rgbMap[GREEN_CHANNEL]) == false)
  {
    (this->*(m_contrastTransfFuncPtr))(static_cast<unsigned int>(m_rgbMap[GREEN_CHANNEL]), val, val);
    val *= m_gamma[ GREEN_CHANNEL ];
    fixValue(val, m_rgbMap[GREEN_CHANNEL]);

    double transp = checkAlphaValue(icol, ilin);

    te::color::RGBAColor c(static_cast<int>(0.), static_cast<int>(val), static_cast<int>(0.), static_cast<int>(transp));

    return c;

  }

  return te::color::RGBAColor();
}

void te::map::RasterTransform::setBlue2ThreeBand(double icol, double ilin, double ocol, double olin)
{
  double val;

  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), val, static_cast<size_t>(m_rgbMap[BLUE_CHANNEL]));

  if(checkNoValue(val, m_rgbMap[BLUE_CHANNEL]) == false)
  {
    (this->*(m_contrastTransfFuncPtr))(static_cast<unsigned int>(m_rgbMap[BLUE_CHANNEL]), val, val);
    val *= m_gamma[ BLUE_CHANNEL ];
    fixValue(val, m_rgbMap[BLUE_CHANNEL]);

    std::vector<double> vecValues;
    vecValues.push_back(0.);
    vecValues.push_back(0.);
    vecValues.push_back(val);

    m_rasterOut->setValues(static_cast<unsigned int>(ocol), static_cast<unsigned int>(olin), vecValues);
  }
}

te::color::RGBAColor te::map::RasterTransform::getBlue2ThreeBand(double icol, double ilin)
{
  double val;

  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), val, static_cast<size_t>(m_rgbMap[BLUE_CHANNEL]));

  if(checkNoValue(val, m_rgbMap[BLUE_CHANNEL]) == false)
  {
    (this->*(m_contrastTransfFuncPtr))(static_cast<unsigned int>(m_rgbMap[BLUE_CHANNEL]), val, val);
    val *= m_gamma[ BLUE_CHANNEL ];
    fixValue(val, m_rgbMap[BLUE_CHANNEL]);

    double transp = checkAlphaValue(icol, ilin);

    te::color::RGBAColor c(static_cast<int>(0.), static_cast<int>(0.), static_cast<int>(val), static_cast<int>(transp));

    return c;

  }

  return te::color::RGBAColor();
}

void te::map::RasterTransform::setCategorize(double icol, double ilin, double ocol, double olin)
{
   double val;

  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), val, static_cast<size_t>(m_monoBand));

  te::color::RGBAColor c=  getCategorizedColor(val);

  std::vector<double> vecValues;
  vecValues.push_back(c.getRed());
  vecValues.push_back(c.getGreen());
  vecValues.push_back(c.getBlue());

  m_rasterOut->setValues(static_cast<unsigned int>(ocol), static_cast<unsigned int>(olin), vecValues);
}

te::color::RGBAColor te::map::RasterTransform::getCategorize(double icol, double ilin)
{
  double val;

  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), val, static_cast<size_t>(m_monoBand));

  if(checkNoValue(val, m_monoBand) == false)
    return getCategorizedColor(val);

  return te::color::RGBAColor();
}

void te::map::RasterTransform::setInterpolate(double icol, double ilin, double ocol, double olin)
{
   double val;

  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), val, static_cast<size_t>(m_monoBand));

  te::color::RGBAColor c=  getInterpolatedColor(val);

  std::vector<double> vecValues;
  vecValues.push_back(c.getRed());
  vecValues.push_back(c.getGreen());
  vecValues.push_back(c.getBlue());

  m_rasterOut->setValues(static_cast<unsigned int>(ocol), static_cast<unsigned int>(olin), vecValues);
}

te::color::RGBAColor te::map::RasterTransform::getInterpolate(double icol, double ilin)
{
  double val;

  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), val, static_cast<size_t>(m_monoBand));

  if(checkNoValue(val, m_monoBand) == false)
    return getInterpolatedColor(val);

  return te::color::RGBAColor();
}

void te::map::RasterTransform::setRecode(double icol, double ilin, double ocol, double olin)
{
  double val;

  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), val, static_cast<size_t>(m_monoBand));

  te::color::RGBAColor c = getRecodedColor(val);

  std::vector<double> vecValues;
  vecValues.push_back(c.getRed());
  vecValues.push_back(c.getGreen());
  vecValues.push_back(c.getBlue());

  m_rasterOut->setValues(static_cast<unsigned int>(ocol), static_cast<unsigned int>(olin), vecValues);
}

te::color::RGBAColor te::map::RasterTransform::getRecode(double icol, double ilin)
{
  double val;

  m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), val, static_cast<size_t>(m_monoBand));

  if (checkNoValue(val, m_monoBand) == false)
    return getRecodedColor(val);

  return te::color::RGBAColor();
}

void te::map::RasterTransform::setBand2Band(double icol, double ilin, double ocol, double olin)
{
 double val;

  for(std::size_t t = 0; t < m_rasterIn->getNumberOfBands(); ++t)
  {
    m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), val, t);

    if(checkNoValue(val, static_cast<int>(t) == false))
    {
      (this->*(m_contrastTransfFuncPtr))( static_cast<unsigned int>(t), val, val );
      val *= m_gamma[ t ];

      short band = static_cast<short>(t);
      fixValue(val, band);

      m_rasterOut->setValue(static_cast<unsigned int>(ocol), static_cast<unsigned int>(olin), val, t);
    }
  }
}

double te::map::RasterTransform::checkAlphaValue(double icol, double ilin)
{
  std::map<RGBChannels, short>::iterator it = m_rgbMap.find(ALPHA_CHANNEL);

  if (it != m_rgbMap.end() && it->second != -1)
  {
    double transp = 0.;
    m_rasterIn->getValue(static_cast<unsigned int>(icol), static_cast<unsigned int>(ilin), transp, static_cast<size_t>(m_rgbMap[ALPHA_CHANNEL]));

    if (transp < m_transp)
      return transp;
    else
      return m_transp;
  }

  return m_transp;
}

te::color::RGBAColor te::map::RasterTransform::getInterpolatedColor(double value)
{
  InterpolatedMap::iterator it = m_interpolateMap.begin();

  while(it != m_interpolateMap.end())
  {
    RasterThreshold rt = it->first;

    if(rt.first<= value && rt.second > value)
    {
      int distance = int(value - it->first.first);

      if(distance < 0)
      {
        distance = 0;
      }
      else if(distance >= static_cast<int>(it->second.getColorBar().size()))
      {
        distance = static_cast<int>(it->second.getColorBar().size() - 1);
      }

      return it->second.getColorBar()[static_cast<size_t>(distance)];
    }

    ++it;
  }

  return te::color::RGBAColor();
}

te::color::RGBAColor te::map::RasterTransform::getCategorizedColor(double value)
{
  CategorizedMap::iterator it = m_categorizeMap.begin();

  while(it != m_categorizeMap.end())
  {
    RasterThreshold rt = it->first;

    if(rt.first<= value && rt.second > value)
    {
      return it->second;
    }

    ++it;
  }

  return te::color::RGBAColor();
}

te::color::RGBAColor te::map::RasterTransform::getRecodedColor(double value)
{
  return m_recodeMap[static_cast<int>(value)];
}