image_convert.h

Go to the documentation of this file.

/*                       
        This file is part of the CVD Library.

        Copyright (C) 2005 The Authors

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

        This library 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 this library; if not, write to the Free Software
        Foundation, Inc., 
    51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/
#ifndef CVD_IMAGE_CONVERT_H
#define CVD_IMAGE_CONVERT_H

#include <cvd/config.h>
#include <cvd/internal/convert_pixel_types.h>
#include <cvd/internal/rgb_components.h>
#include <cvd/image.h>

namespace CVD
{

  // The most general case: one row at a time

  template <class From, class To, class Conv=typename Pixel::DefaultConversion<From,To>::type, int both_pod=Internal::is_POD<From>::is_pod && Internal::is_POD<To>::is_pod> struct ConvertImage {
    static void convert(const SubImage<From>& from, SubImage<To>& to) {
      for (int r=0; r<from.size().y; r++)
        Pixel::ConvertPixels<From,To,Conv>::convert(from[r], to[r], from.size().x);
    };
  };

  // The blat case: memcpy all data at once 
  template <class T> struct ConvertImage<T,T,Pixel::GenericConversion<T,T>,1> {
    static void convert(const SubImage<T>& from, SubImage<T>& to) {
      memcpy(to.data(), from.data(), from.totalsize() * sizeof(T));
    };
  };

  template <> struct ConvertImage<Rgb<byte>, byte, Pixel::CIE<Rgb<byte>, byte>, 1> {
      static void convert(const SubImage<Rgb<byte> >& from, SubImage<byte>& to);
  };
  
  template<class Conv, class C, class D> void convert_image(const SubImage<C>& from, SubImage<D>& to)
  {
    if (from.size() != to.size())
      throw Exceptions::Image::IncompatibleImageSizes(__FUNCTION__);
    ConvertImage<C,D,Conv>::convert(from, to);
  }
  
  template<template <class From, class To> class Conv, class C, class D> void convert_image(const SubImage<C>& from, SubImage<D>& to)
  {
    if (from.size() != to.size())
      throw Exceptions::Image::IncompatibleImageSizes(__FUNCTION__);
    ConvertImage<C,D,Conv<C,D> >::convert(from, to);
  }

  template<class C, class D> void convert_image(const SubImage<C>& from, SubImage<D>& to)
  {
      if (from.size() != to.size())
          throw Exceptions::Image::IncompatibleImageSizes(__FUNCTION__);
      ConvertImage<C,D>::convert(from, to);
  }

  template<class C, class D> void convert_image(const BasicImage<C>& from, BasicImage<D>& to)
  {
      if (from.size() != to.size())
          throw Exceptions::Image::IncompatibleImageSizes(__FUNCTION__);
      ConvertImage<C,D>::convert(from, to);
  }

  template<class D, class Conv, class C> Image<D> convert_image(const SubImage<C>& from)
  {
    Image<D> to(from.size());
    convert_image<Conv>(from, to);
    return to;
  }
    
  template<class D, template <class From, class To> class Conv, class C> Image<D> convert_image(const SubImage<C>& from)
  {
    Image<D> to(from.size());
    convert_image<Conv>(from, to);
    return to;
  }

  template<class D, class C> Image<D> convert_image(const SubImage<C>& from)
  {
    Image<D> to(from.size());
    convert_image(from, to);
    return to;
  }

  template<class D, class C> Image<D> convert_image(const BasicImage<C>& from)
  {
    Image<D> to(from.size());
    convert_image(from, to);
    return to;
  }
  
  // Function name changed from 'convert_image' to prevent compile-time
  // error arising from the clash with a function of same name declared above.

  template<class D1, class D2, class C> std::pair<Image<D1>, Image<D2> > convert_image_pair(const BasicImage<C>& from)
  {
    std::pair<Image<D1>, Image<D2> > to(Image<D1>(from.size()), Image<D2>(from.size()));
    convert_image(from, to.first);
    convert_image(from, to.second);
    return to;
  }  


  #ifndef DOXYGEN_IGNORE_INTERNAL
  namespace Internal
  {
        template<class C> class ImageConverter{};
        template<class C>  struct ImagePromise<ImageConverter<C> >
        {
                ImagePromise(const BasicImage<C>& im)
                :i(im)
                {}

                const BasicImage<C>& i;
                template<class D> void execute(Image<D>& j)
                {
                        j.resize(i.size());
                        convert_image(i, j);
                }
        };
  };
  template<class C> Internal::ImagePromise<Internal::ImageConverter<C> > convert_image(const BasicImage<C>& c)
  {
    return Internal::ImagePromise<Internal::ImageConverter<C> >(c);
  }
  #else















        template<class D> Image<D> convert_image(const BasicImage<C>& from);

  #endif


        template<class In, class Out> struct IsConvertible
        { 
                static const bool is=Pixel::DefaultConvertible<In>::is && Pixel::DefaultConvertible<Out>::is;
        };

        template<class In, class Out> struct PixelByPixelConvertible
        { 
                static const bool is=Pixel::DefaultConvertible<In>::is && Pixel::DefaultConvertible<Out>::is;
        };

        template<class InOut> struct PixelByPixelConvertible<InOut, InOut>
        { 
                static const bool is=1;
        };

}

#endif

---

libcvd
Author(s): Edward Rosten, Paul Smith, Tom Drummond, Gerhard Reitmayr, Ethan Eade, Timothy Gan, Chris Kemp, Georg Klein
autogenerated on Fri Jan 11 09:13:09 2013