itkRGBPixel.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkRGBPixel.h,v $
  Language:  C++
  Date:      $Date: 2009-03-12 01:11:16 $
  Version:   $Revision: 1.43 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkRGBPixel_h
#define __itkRGBPixel_h

// Undefine an eventual RGBPixel macro
#ifdef RGBPixel
#undef RGBPixel
#endif

#include <itkIndent.h>
#include <itkFixedArray.h>
#include "vnl/vnl_math.h"

namespace itk
{

template < typename TComponent = unsigned short >
class RGBPixel: public FixedArray<TComponent,3>
{
public:
  typedef RGBPixel                  Self;
  typedef FixedArray<TComponent, 3> Superclass;

  typedef FixedArray<TComponent, 3> BaseArray;

#if defined(__BORLANDC__)
  enum {Dimension = 3};
#else
  itkStaticConstMacro(Dimension, unsigned int, 3);
#endif


#if defined(__BORLANDC__)
  enum {Length = 3};
#else
  itkStaticConstMacro(Length, unsigned int, 3);
#endif


  typedef TComponent                     ComponentType;
  typedef typename Superclass::ValueType ValueType;

  RGBPixel() {};

  RGBPixel (const ComponentType& r) { this->Fill(r); }

  template< class TRGBPixelValueType >
  RGBPixel(const RGBPixel< TRGBPixelValueType >& r): BaseArray(r) {}
  RGBPixel(const ComponentType  r[3]): BaseArray(r) {}  

  template< class TRGBPixelValueType >
  Self& operator= (const RGBPixel< TRGBPixelValueType > & r)
    {
    BaseArray::operator=(r);
    return *this;
    }

  Self& operator= (const ComponentType r[3]);

  Self operator+(const Self &vec) const;
  Self operator-(const Self &vec) const;
  const Self & operator+=(const Self &vec);
  const Self & operator-=(const Self &vec);
  Self operator*(const ComponentType &f) const;

  bool operator<(const Self &vec) const;
  bool operator==(const Self &vec) const;
 
  static unsigned int GetNumberOfComponents(){ return 3;}

  ComponentType GetNthComponent(int c) const
    { return this->operator[](c); }

  ComponentType GetScalarValue() const
    {
    return static_cast<ComponentType> (vcl_sqrt(
                                         static_cast<double>(this->operator[](0)) * static_cast<double>(this->operator[](0)) +
                                         static_cast<double>(this->operator[](1)) * static_cast<double>(this->operator[](1)) +
                                         static_cast<double>(this->operator[](2)) * static_cast<double>(this->operator[](2)))); 
    }

  void SetNthComponent(int c, const ComponentType& v)  
    {  this->operator[](c) = v; }

  void SetRed( ComponentType red ) { this->operator[](0) = red;}

  void SetGreen( ComponentType green ) {this->operator[](1) = green;}

  void SetBlue( ComponentType blue ) {this->operator[](2) = blue;}

  void Set( ComponentType red, ComponentType green, ComponentType blue )
    { this->operator[](0) = red; this->operator[](1) = green; this->operator[](2) = blue;}

  const ComponentType & GetRed( void ) const { return this->operator[](0);}

  const ComponentType & GetGreen( void ) const { return this->operator[](1);}

  const ComponentType & GetBlue( void ) const { return this->operator[](2);}

  ComponentType GetLuminance( void ) const;
};


template< typename TComponent  >  
ITK_EXPORT std::ostream& operator<<(std::ostream& os, 
                                    const RGBPixel<TComponent> & c); 
template< typename TComponent  >  
ITK_EXPORT std::istream& operator>>(std::istream& is, 
                                          RGBPixel<TComponent> & c); 

} // end namespace itk

// Define instantiation macro for this template.
#define ITK_TEMPLATE_RGBPixel(_, EXPORT, x, y) namespace itk { \
  _(1(class EXPORT RGBPixel< ITK_TEMPLATE_1 x >)) \
  namespace Templates { typedef RGBPixel< ITK_TEMPLATE_1 x > RGBPixel##y; } \
  }

#if ITK_TEMPLATE_EXPLICIT
# include "Templates/itkRGBPixel+-.h"
#endif

//
// Numeric traits must be included after (optionally) including the explicit
// instantiations control of this class, in case the implicit instantiation
// needs to be disabled. 
//
// NumericTraits must be included before (optionally) including the .txx file,
// in case the .txx requires to use NumericTraits.
//
#include "itkNumericTraitsRGBPixel.h"

#if ITK_TEMPLATE_TXX
# include "itkRGBPixel.txx"
#endif

#endif