channel.h

Go to the documentation of this file.

/* This software and supporting documentation are distributed by
 *     Institut Federatif de Recherche 49
 *     CEA/NeuroSpin, Batiment 145,
 *     91191 Gif-sur-Yvette cedex
 *     France
 *
 * This software is governed by the CeCILL-B license under
 * French law and abiding by the rules of distribution of free software.
 * You can  use, modify and/or redistribute the software under the
 * terms of the CeCILL-B license as circulated by CEA, CNRS
 * and INRIA at the following URL "http://www.cecill.info".
 *
 * As a counterpart to the access to the source code and  rights to copy,
 * modify and redistribute granted by the license, users are provided only
 * with a limited warranty  and the software's author,  the holder of the
 * economic rights,  and the successive licensors  have only  limited
 * liability.
 *
 * In this respect, the user's attention is drawn to the risks associated
 * with loading,  using,  modifying and/or developing or reproducing the
 * software by the user in light of its specific status of free software,
 * that may mean  that it is complicated to manipulate,  and  that  also
 * therefore means  that it is reserved for developers  and  experienced
 * professionals having in-depth computer knowledge. Users are therefore
 * encouraged to load and test the software's suitability as regards their
 * requirements in conditions enabling the security of their systems and/or
 * data to be ensured and,  more generally, to use and operate it in the
 * same conditions as regards security.
 *
 * The fact that you are presently reading this means that you have had
 * knowledge of the CeCILL-B license and that you accept its terms.
 */
 
#ifndef AIMS_UTILITY_CHANNEL_H
#define AIMS_UTILITY_CHANNEL_H
 
#include <iomanip>
#include <cartobase/type/types.h>
#include <cartobase/type/string_conversion.h>
#include <cartobase/type/datatypetraits.h>
#include <cartobase/type/datatypeinfo.h>
#include <aims/rgb/rgb.h>
#include <aims/hsv/hsv.h>
#include <cartodata/volume/volume.h>
#include <cartobase/type/converter.h>
 
enum AimsRGBAChannel
{
  RedChannel = 0,
  GreenChannel = 1,
  BlueChannel = 2,
  AlphaChannel = 3
};
 
enum AimsHSVChannel
{
  HueChannel = 0,
  SaturationChannel = 1,
  ValueChannel = 2
};
 
#define DECLARE_CHANNEL_SELECTOR_NAME() \
class ChannelSelector \
 
 
#define DECLARE_CHANNEL_SELECTOR_SPEC( T, U, C ) \
{ \
    public: \
      ChannelSelector() {} \
      virtual ~ChannelSelector() {} \
\
      U select( const T& input, const uint8_t channel ); \
      void set( T& input, const uint8_t channel, const U& value ); \
\
    private: \
      carto::ShallowConverter<U, C> channelconvset; \
      carto::ShallowConverter<C, U> channelconv; \
      carto::ShallowConverter<T, U> dataconv; \
}; \
 
 
#define DECLARE_CHANNEL_SELECTOR_CLASS() \
template <class T, class U, class C = byte > \
DECLARE_CHANNEL_SELECTOR_NAME() \
DECLARE_CHANNEL_SELECTOR_SPEC( T, U, C ) \
 
 
#define DECLARE_CHANNEL_SELECTOR_SPECIALIZED( T ) \
template <class U> \
DECLARE_CHANNEL_SELECTOR_NAME() < T, U > \
DECLARE_CHANNEL_SELECTOR_SPEC( T, U, byte ) \
 
 
DECLARE_CHANNEL_SELECTOR_CLASS()
DECLARE_CHANNEL_SELECTOR_SPECIALIZED( AimsRGB )
DECLARE_CHANNEL_SELECTOR_SPECIALIZED( AimsRGBA )
DECLARE_CHANNEL_SELECTOR_SPECIALIZED( AimsHSV )
 
 
// partial specialzation for VolumeRef
template <class T, class U>
class ChannelSelector < carto::VolumeRef<T>, carto::VolumeRef<U> >
{
    public:
      ChannelSelector() {}
      virtual ~ChannelSelector() {}
 
      carto::VolumeRef<U> select( const carto::VolumeRef<T>& input, const uint8_t channel );
      void set( carto::VolumeRef<T>& input, const uint8_t channel, const carto::VolumeRef<U>& value );
};
 
 
template <class T, class U, class C> inline
U ChannelSelector< T, U, C >::select( const T& input, const uint8_t )
{
  return (U)input;
}
 
template <class T, class U, class C> inline
void ChannelSelector< T, U, C >::set( T& input, const uint8_t, const U& value )
{
  input = value;
}
 
template <class U> inline
U ChannelSelector< AimsRGB, U >::select( const AimsRGB& input, const uint8_t channel )
{
  U output;
 
  switch(channel) {
    case RedChannel :
      channelconv.convert( input.red(), output );
      break;
    case GreenChannel :
      channelconv.convert( input.green(), output );
      break;
    case BlueChannel :
      channelconv.convert( input.blue(), output );
      break;
    default :
      dataconv.convert( input, output );
  }
  return output;
}
 
template <class U> inline
void ChannelSelector< AimsRGB, U >::set( AimsRGB& input, const uint8_t channel, const U& value )
{
  switch(channel) {
    case RedChannel :
      channelconvset.convert( value, input.red() );
      break;
    case GreenChannel :
      channelconvset.convert( value, input.green() );
      break;
    case BlueChannel :
      channelconvset.convert( value, input.blue() );
      break;
  }
}
 
template <class U> inline
U ChannelSelector< AimsRGBA, U >::select( const AimsRGBA& input, const uint8_t channel )
{
  U output;
 
  switch(channel) {
    case RedChannel :
      channelconv.convert( input.red(), output );
      break;
    case GreenChannel :
      channelconv.convert( input.green(), output );
      break;
    case BlueChannel :
      channelconv.convert( input.blue(), output );
      break;
    case AlphaChannel :
      channelconv.convert( input.alpha(), output );
      break;
    default :
      dataconv.convert( input, output );
  }
 
  return output;
}
 
template <class U> inline
void ChannelSelector< AimsRGBA, U >::set( AimsRGBA& input, const uint8_t channel, const U& value )
{
  switch(channel) {
    case RedChannel :
      channelconvset.convert( value, input.red() );
      break;
    case GreenChannel :
      channelconvset.convert( value, input.green() );
      break;
    case BlueChannel :
      channelconvset.convert( value, input.blue() );
      break;
    case AlphaChannel :
      channelconvset.convert( value, input.alpha() );
      break;
  }
}
 
template <class U> inline
U ChannelSelector< AimsHSV, U >::select( const AimsHSV& input, const uint8_t channel )
{
  U output;
 
  switch(channel) {
    case HueChannel :
      channelconv.convert( input.hue(), output );
      break;
    case SaturationChannel :
      channelconv.convert( input.saturation(), output );
      break;
    case ValueChannel :
      channelconv.convert( input.value(), output );
      break;
    default :
      dataconv.convert( input, output );
      break;
  }
 
  return output;
}
 
 
template <class U> inline
void ChannelSelector< AimsHSV, U >::set( AimsHSV& input, const uint8_t channel, const U& value )
{
  switch(channel) {
    case HueChannel :
      channelconvset.convert( value, input.hue() );
      break;
    case SaturationChannel :
      channelconvset.convert( value, input.saturation() );
      break;
    case ValueChannel :
      channelconvset.convert( value, input.value() );
      break;
  }
}
 
// AimsVector
 
template <typename T, int D, typename U>
class ChannelSelector<AimsVector<T, D>, U>
{
  public:
      ChannelSelector() {}
      virtual ~ChannelSelector() {}
 
      U select( const AimsVector<T, D>& input, const uint8_t channel );
      void set( AimsVector<T, D>& input, const uint8_t channel,
                const U& value );
 
    private:
      carto::ShallowConverter<U, T> channelconvset;
      carto::ShallowConverter<T, U> channelconv;
      // carto::ShallowConverter<AimsVector<T, D>, U> dataconv;
};
 
template <typename T, int D, typename U>
inline
U ChannelSelector<AimsVector<T, D>, U>::select( const AimsVector<T, D> & input,
                                                 const uint8_t channel )
{
  U output;
 
  channelconv.convert( input[channel], output );
  return output;
}
 
template <typename T, int D, typename U>
void ChannelSelector< AimsVector<T, D>, U>::set( AimsVector<T, D> & input,
                                                  const uint8_t channel,
                                                  const U& value )
{
  channelconvset.convert( value, input[channel] );
}
 
 
// VolumeRef
 
template<class T, class U> inline
carto::VolumeRef<U>
ChannelSelector< carto::VolumeRef<T>,
                 carto::VolumeRef<U> >::select( const carto::VolumeRef<T>& input,
                                                const uint8_t channel )
{
  ChannelSelector< T, U > selector;
  int x, y, z, t,
        dx = input.getSizeX(),
        dy = input.getSizeY(),
        dz = input.getSizeZ(),
        dt = input.getSizeT();
 
  std::vector<int> b = input.getBorders();
 
  carto::VolumeRef<U> output( dx, dy, dz, dt,
    typename carto::VolumeRef<U>::Position4Di( b[0], b[2], b[4], b[6] ) );
 
  output->copyHeaderFrom( input.header() );
  output.header().setProperty( "data_type", carto::DataTypeCode<U>::name() );
 
  for( t=-b[6]; t<dt+b[6]; ++t )
    {
      for( z=-b[4]; z<dz+b[4]; ++z )
        {
          for( y=-b[2]; y<dy+b[2]; ++y )
            {
              for( x=-b[0]; x<dx+b[0]; ++x )
                output( x, y, z, t ) = selector.select( input( x, y, z, t ), channel );
            }
        }
    }
 
  return output;
}
 
 
template<class T, class U> inline
void ChannelSelector< carto::VolumeRef<T>,
                      carto::VolumeRef<U> >::set( carto::VolumeRef<T>& input,
                                                  const uint8_t channel,
                                                  const carto::VolumeRef<U>& value )
{
  ChannelSelector<T, U> selector;
 
  int x, y, z, t,
        dx = input.getSizeX(),
        dy = input.getSizeY(),
        dz = input.getSizeZ(),
        dt = input.getSizeT();
 
  for( t=0; t<dt; ++t )
    {
      for( z=0; z<dz; ++z )
        {
          for( y=0; y<dy; ++y )
            {
              for( x=0; x<dx; ++x )
                 selector.set( input( x, y, z, t ),
                               channel,
                               value( x, y, z, t ) );
            }
        }
    }
}
 
 
#endif