pixelRGB.h

Go to the documentation of this file.

#ifndef _DLRCOMPUTERVISION_PIXELRGB_H_
#define _DLRCOMPUTERVISION_PIXELRGB_H_

#include <dlrCommon/types.h>

namespace dlr {

  namespace computerVision {
    
    template<class Type>
    struct PixelRGB
    {
      PixelRGB()
        : red(), green(), blue() {}

    
      PixelRGB(const Type& red, const Type& green, const Type& blue)
        : red(red), green(green), blue(blue) {}


      ~PixelRGB() {}


      template<class Iter>
      inline Iter&
      copyFromIterator(Iter& iter);


      template<class Iter>
      inline Iter&
      copyToIterator(Iter& iter);


      /* ====== Public data members ====== */

      Type red;
      Type green;
      Type blue;


      /* ====== Public arithmetic operators ====== */

      template <class OtherType>
      inline PixelRGB<Type>&
      operator+=(const PixelRGB<OtherType>& other);


      template <class OtherType>
      inline PixelRGB<Type>&
      operator-=(const PixelRGB<OtherType>& other);


      template <class Scalar>
      inline PixelRGB<Type>&
      operator/=(const Scalar& scalar);


      /* ====== Static member functions ====== */

      static inline bool
      isContiguous();

    };


    typedef PixelRGB<UnsignedInt8> PixelRGB8;
    typedef PixelRGB<UnsignedInt16> PixelRGB16;
    typedef PixelRGB<Int16> PixelRGBSigned16;
    typedef PixelRGB<Int32> PixelRGBSigned32;
    typedef PixelRGB<Float32> PixelRGBFloat32;
    typedef PixelRGB<Float64> PixelRGBFloat64;


    template<class Type>
    inline PixelRGB<Type>
    operator-(const PixelRGB<Type>& pixel0, const PixelRGB<Type>& pixel1);

  
    template<class Type>
    inline bool
    operator==(const PixelRGB<Type>& pixel0, const PixelRGB<Type>& pixel1);

  } // namespace computerVision    

} // namespace dlr
  
/* ============ Definitions of inline & template functions ============ */


namespace dlr {

  namespace computerVision {
    
    // This member function copies the pixel component values, in
    // order, from consecutive iterator targets, incrementing the
    // iterator after each copy.
    template<class Type>
    template<class Iter>
    inline Iter&
    PixelRGB<Type>::
    copyFromIterator(Iter& iter)
    {
      red = *(iter++);
      green = *(iter++);
      blue = *(iter++);
      return iter;
    }


    // This member function assigns the pixel component values, in
    // order, to consecutive iterator targets, incrementing the
    // iterator after each assignment.
    template<class Type>
    template<class Iter>
    inline Iter&
    PixelRGB<Type>::
    copyToIterator(Iter& iter)
    {
      *(iter++) = red;
      *(iter++) = green;
      *(iter++) = blue;
      return iter;
    }



    // This operator adds the color component values of its argument to the 
    // corresponding values of its *this.
    template<class Type>
    template <class OtherType>
    inline PixelRGB<Type>&
    PixelRGB<Type>::
    operator+=(const PixelRGB<OtherType>& other)
    {
      red += other.red;
      green += other.green;
      blue += other.blue;
      return *this;
    }

    
    // This operator adds the color component values of its argument to the 
    // corresponding values of its *this.
    template<class Type>
    template <class OtherType>
    inline PixelRGB<Type>&
    PixelRGB<Type>::
    operator-=(const PixelRGB<OtherType>& other)
    {
      red -= other.red;
      green -= other.green;
      blue -= other.blue;
      return *this;
    }

    
    // This operator divides each color component of *this by the
    // the value of its argument.
    template<class Type>
    template <class Scalar>
    inline PixelRGB<Type>&
    PixelRGB<Type>::
    operator/=(const Scalar& scalar)
    {
      red /= scalar;
      green /= scalar;
      blue /= scalar;
      return *this;
    }

    
    // This static member function indicates whether or not a pixel
    // instance is memory identical to a contiguous array of Component
    // type.
    template<class Type>
    inline bool
    PixelRGB<Type>::
    isContiguous()
    {
      Type dummy;
      Type* typePtr = &dummy;
      PixelRGB<Type>* pixelPtr = reinterpret_cast<PixelRGB<Type>*>(typePtr);
      PixelRGB<Type>* pixelPtr2 = pixelPtr + 1;
      return
        ((reinterpret_cast<Type*>(&(pixelPtr2->red)) == &(typePtr[3]))
         && (reinterpret_cast<Type*>(&(pixelPtr2->green)) == &(typePtr[4]))
         && (reinterpret_cast<Type*>(&(pixelPtr2->blue)) == &(typePtr[5])));
    }


    // This operator subtracts the values of the individual color
    // components of its arguments.
    template<class Type>
    inline PixelRGB<Type>
    operator-(const PixelRGB<Type>& pixel0, const PixelRGB<Type>& pixel1)
    {
      return PixelRGB<Type>(
        pixel0.red - pixel1.red,
        pixel0.green - pixel1.green,
        pixel0.blue - pixel1.blue);
    }


    // This operator returns true if the contents of the two argments
    // are identical, false otherwise.
    template<class Type>
    inline bool
    operator==(const PixelRGB<Type>& pixel0, const PixelRGB<Type>& pixel1)
    {
      return (pixel0.red == pixel1.red
              && pixel0.green == pixel1.green
              && pixel0.blue == pixel1.blue);
    }

  } // namespace computerVision
  
} // namespace dlr

#endif /* #ifndef _DLRCOMPUTERVISION_PIXELRGB_H_ */

---