colorspaceConverter.h

Go to the documentation of this file.

#ifndef _DLRCOMPUTERVISION_COLORSPACECONVERTER_H_
#define _DLRCOMPUTERVISION_COLORSPACECONVERTER_H_

#include <functional>
#include <dlrComputerVision/imageFormat.h>
#include <dlrComputerVision/image.h>

namespace dlr {

  namespace computerVision {

    template<ImageFormat FORMAT0, ImageFormat FORMAT1>
    class ColorspaceConverter
      : public std::unary_function<typename Image<FORMAT0>::PixelType,
                                   typename Image<FORMAT1>::PixelType>
    {
    public:
    
      ColorspaceConverter()
        : std::unary_function<typename Image<FORMAT0>::PixelType,
                              typename Image<FORMAT1>::PixelType>()
        {}


      virtual ~ColorspaceConverter()
        {}


      inline
      typename Image<FORMAT1>::PixelType
      operator()(const typename Image<FORMAT0>::PixelType& inputPixel) {
        typename Image<FORMAT1>::PixelType outputPixel;
        this->operator()(inputPixel, outputPixel);
        return outputPixel;
      }
    

      inline
      void
      operator()(const typename Image<FORMAT0>::PixelType& inputPixel,
                 typename Image<FORMAT1>::PixelType& outputPixel) {
        // Default rule should work for many format combinations.  We'll
        // specialize for the rest below.  If you try to convert between
        // formats where this static_cast isn't appropriate, and for
        // which we haven't written a specialization, then you'll either
        // get a compile error or an unexpected conversion result.
        outputPixel =
          static_cast<typename Image<FORMAT1>::PixelType>(inputPixel);
      }
    
    };

  } // namespace computerVision
  
} // namespace dlr


/* ============ Definitions of inline & template functions ============ */


#include <cmath>

namespace dlr {

  namespace computerVision {
    
    template<>
    inline
    void
    ColorspaceConverter<GRAY1, GRAY8>::
    operator()(const Image<GRAY1>::PixelType& inputPixel,
               Image<GRAY8>::PixelType& outputPixel)
    {
      if(inputPixel) {
        outputPixel = Image<GRAY8>::PixelType(255);
      } else {
        outputPixel = Image<GRAY8>::PixelType(0);
      }
    }


    template<>
    inline
    void
    ColorspaceConverter<GRAY1, RGB8>::
    operator()(const Image<GRAY1>::PixelType& inputPixel,
               Image<RGB8>::PixelType& outputPixel)
    {
      if(inputPixel) {
        outputPixel.red = ImageFormatTraits<RGB8>::ComponentType(255);
        outputPixel.green = ImageFormatTraits<RGB8>::ComponentType(255);
        outputPixel.blue = ImageFormatTraits<RGB8>::ComponentType(255);
      } else {
        outputPixel.red = ImageFormatTraits<RGB8>::ComponentType(0);
        outputPixel.green = ImageFormatTraits<RGB8>::ComponentType(0);
        outputPixel.blue = ImageFormatTraits<RGB8>::ComponentType(0);
      }
    }


    template<>
    inline
    void
    ColorspaceConverter<GRAY8, RGB8>::
    operator()(const Image<GRAY8>::PixelType& inputPixel,
               Image<RGB8>::PixelType& outputPixel)
    {
      outputPixel.red = inputPixel;
      outputPixel.green = inputPixel;
      outputPixel.blue = inputPixel;
    }


    template<>
    inline
    void
    ColorspaceConverter<RGB8, GRAY8>::
    operator()(const Image<RGB8>::PixelType& inputPixel,
               Image<GRAY8>::PixelType& outputPixel)
    {
      double accumulator = (inputPixel.red * inputPixel.red
                            + inputPixel.green * inputPixel.green
                            + inputPixel.blue * inputPixel.blue) / 3.0;
      outputPixel =
        static_cast<Image<GRAY8>::PixelType>(std::sqrt(accumulator) + 0.5);
    }


    template<>
    inline
    void
    ColorspaceConverter<RGB8, RGB_FLOAT32>::
    operator()(const Image<RGB8>::PixelType& inputPixel,
               Image<RGB_FLOAT32>::PixelType& outputPixel)
    {
      outputPixel.red = static_cast<Float32>(inputPixel.red);
      outputPixel.green = static_cast<Float32>(inputPixel.green);
      outputPixel.blue = static_cast<Float32>(inputPixel.blue);
    }


    template<>
    inline
    void
    ColorspaceConverter<RGB8, RGB_FLOAT64>::
    operator()(const Image<RGB8>::PixelType& inputPixel,
               Image<RGB_FLOAT64>::PixelType& outputPixel)
    {
      outputPixel.red = static_cast<Float64>(inputPixel.red);
      outputPixel.green = static_cast<Float64>(inputPixel.green);
      outputPixel.blue = static_cast<Float64>(inputPixel.blue);
    }


    template<>
    inline
    void
    ColorspaceConverter<RGB8, HSV_FLOAT64>::
    operator()(const Image<RGB8>::PixelType& inputPixel,
               Image<HSV_FLOAT64>::PixelType& outputPixel)
    {
      // "value" is the simplest to compute... it's just the max RGB value.
      Float64 maxVal = static_cast<Float64>(
        std::max(inputPixel.red, std::max(inputPixel.green, inputPixel.blue)));
      outputPixel.value = maxVal;
    
      // Handle first special case up-front.
      if(maxVal == 0.0) {
        outputPixel.hue = Float64(0.0);
        outputPixel.saturation = Float64(0.0);
        return;
      }

      // Now we can compute "saturation".
      Float64 minVal = static_cast<Float64>(
        std::min(inputPixel.red, std::min(inputPixel.green, inputPixel.blue)));
      Float64 delta = maxVal - minVal;
      outputPixel.saturation = delta / maxVal;
    
      // Handle second special case up-front.
      if(delta == 0.0) {
        outputPixel.hue = Float64(0.0);
        return;
      }

      // Warning(xxx): our definition of hue goes from 0.0 to 1.0, not
      // 0.0 to 360.0, as is traditional.
      if(inputPixel.red == maxVal) {
        outputPixel.hue =
          Float64(1.0 / 6.0)
          + (static_cast<Float64>(inputPixel.green)
             - static_cast<Float64>(inputPixel.blue)) / (6.0 * delta);
      } else if(inputPixel.green == maxVal) {
        outputPixel.hue =
          Float64(0.5)
          + (static_cast<Float64>(inputPixel.blue)
             - static_cast<Float64>(inputPixel.red)) / (6.0 * delta);
      } else {
        outputPixel.hue =
          Float64(5.0 / 6.0)
          + (static_cast<Float64>(inputPixel.red)
             - static_cast<Float64>(inputPixel.green)) / (6.0 * delta);
      }      
    }    


    template<>
    inline
    void
    ColorspaceConverter<RGB8, BGRA8>::
    operator()(const Image<RGB8>::PixelType& inputPixel,
               Image<BGRA8>::PixelType& outputPixel)
    {
      outputPixel.red = inputPixel.red;
      outputPixel.green = inputPixel.green;
      outputPixel.blue = inputPixel.blue;
      outputPixel.alpha = UnsignedInt8(255);
    }


    template<>
    inline
    void
    ColorspaceConverter<RGB8, RGBA8>::
    operator()(const Image<RGB8>::PixelType& inputPixel,
               Image<RGBA8>::PixelType& outputPixel)
    {
      outputPixel.red = inputPixel.red;
      outputPixel.green = inputPixel.green;
      outputPixel.blue = inputPixel.blue;
      outputPixel.alpha = UnsignedInt8(255);
    }


    template<>
    inline
    void
    ColorspaceConverter<RGB_FLOAT32, GRAY8>::
    operator()(const Image<RGB_FLOAT32>::PixelType& inputPixel,
               Image<GRAY8>::PixelType& outputPixel)
    {
      double accumulator = (inputPixel.red * inputPixel.red
                            + inputPixel.green * inputPixel.green
                            + inputPixel.blue * inputPixel.blue) / 3.0;
      outputPixel =
        static_cast<Image<GRAY8>::PixelType>(std::sqrt(accumulator) + 0.5);
    }



    template<>
    inline
    void
    ColorspaceConverter<RGB_FLOAT64, HSV_FLOAT64>::
    operator()(const Image<RGB_FLOAT64>::PixelType& inputPixel,
               Image<HSV_FLOAT64>::PixelType& outputPixel)
    {
      // "value" is the simplest to compute... it's just the max RGB value.
      Float64 maxVal = static_cast<Float64>(
        std::max(inputPixel.red, std::max(inputPixel.green, inputPixel.blue)));
      outputPixel.value = maxVal;
    
      // Handle first special case up-front.
      if(maxVal == 0.0) {
        outputPixel.hue = Float64(0.0);
        outputPixel.saturation = Float64(0.0);
        return;
      }

      // Now we can compute "saturation".
      Float64 minVal = static_cast<Float64>(
        std::min(inputPixel.red, std::min(inputPixel.green, inputPixel.blue)));
      Float64 delta = maxVal - minVal;
      outputPixel.saturation = delta / maxVal;
    
      // Handle second special case up-front.
      if(delta == 0.0) {
        outputPixel.hue = Float64(0.0);
        return;
      }

      // Warning(xxx): our definition of hue goes from 0.0 to 1.0, not
      // 0.0 to 360.0, as is traditional.
      if(inputPixel.red == maxVal) {
        outputPixel.hue =
          Float64(1.0 / 6.0)
          + (static_cast<Float64>(inputPixel.green)
             - static_cast<Float64>(inputPixel.blue)) / (6.0 * delta);
      } else if(inputPixel.green == maxVal) {
        outputPixel.hue =
          Float64(0.5)
          + (static_cast<Float64>(inputPixel.blue)
             - static_cast<Float64>(inputPixel.red)) / (6.0 * delta);
      } else {
        outputPixel.hue =
          Float64(5.0 / 6.0)
          + (static_cast<Float64>(inputPixel.red)
             - static_cast<Float64>(inputPixel.green)) / (6.0 * delta);
      }      
    }    


    template<>
    inline
    void
    ColorspaceConverter<BGRA8, RGB8>::
    operator()(const Image<BGRA8>::PixelType& inputPixel,
               Image<RGB8>::PixelType& outputPixel)
    {
      outputPixel.red = inputPixel.red;
      outputPixel.green = inputPixel.green;
      outputPixel.blue = inputPixel.blue;
    }
  

    template<>
    inline
    void
    ColorspaceConverter<RGBA8, RGB8>::
    operator()(const Image<RGBA8>::PixelType& inputPixel,
               Image<RGB8>::PixelType& outputPixel)
    {
      outputPixel.red = inputPixel.red;
      outputPixel.green = inputPixel.green;
      outputPixel.blue = inputPixel.blue;
    }

  } // namespace computerVision
    
} // namespace dlr

#endif /* #ifndef _DLRCOMPUTERVISION_COLORSPACECONVERTER_H_ */

---