Image.hpp

/* $Id$ */

#ifndef _JAFAR_IMAGE_IMAGE_HPP_
#define _JAFAR_IMAGE_IMAGE_HPP_

#include <fstream>  
#include <iostream>  

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include "boost/archive/xml_iarchive.hpp"
#include "boost/archive/xml_oarchive.hpp"
#include "boost/archive/binary_iarchive.hpp"
#include "boost/archive/binary_oarchive.hpp"
#include "boost/serialization/split_member.hpp"
#include "boost/serialization/binary_object.hpp"
#include <boost/serialization/string.hpp>
#include "boost/shared_ptr.hpp"

#include <kernel/jafarMacro.hpp>
#include "image/cImage.h"
#include <opencv/cxcore.h>
#if CV_MAJOR_VERSION*10 + CV_MINOR_VERSION > 21
#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/legacy/legacy.hpp>
#else
#include <cxcore.hpp> // opencv
#include <cvaux.hpp>
#include <highgui.hpp>
#endif

#ifndef SWIG
namespace cv {
std::ostream& operator<<(std::ostream& os, const cv::Rect &r);
std::ostream& operator<<(std::ostream& os, const cv::Point &p);
std::ostream& operator<<(std::ostream& os, const cv::Size &s);
}
#endif

namespace jafar {

  namespace image {
    void getQuadrangleSubPix(const cv::Mat& src, cv::Mat& dst, const cv::Mat& mapMatrix);

    class Image;
    typedef boost::shared_ptr<Image>  image_ptr_t;
    
    class Image {
      // Cubic kernels generated with generateCubicKernel
      static const int cubicKernelResolution = 255;
      static const double cubicKernel1[256];
      static const double cubicKernel2[256];
      cv::Mat m_matrix;
    public:
      Image() { }
      ~Image();
      Image(int width, int height, int depth, JfrImage_TypeColorSpace colorSpace);
      Image( Image const & img );
      Image& operator=( Image const & img );
      Image& operator=( const cv::Mat& matrix );
      Image( const CvImage& img );
      Image( IplImage* img );
      Image( const cv::Mat& matrix );
      Image(const Image& img, const cv::Rect& roi);

      Image clone() const;

      
      void copyTo(image::Image& dst, 
      const image::Image& mask = image::Image()) const;

      void create( int width, int height, int depth, JfrImage_TypeColorSpace colorSpace );
      
      static Image* loadImage( const char* filename, int iscolor = -1);
      
      bool load( const std::string& filename, int iscolor = -1 );
      
      void save( const std::string& filename) const {
        //std::string name(filename);
        cv::imwrite(filename, m_matrix);
      }
      void save( const std::string& filename, const std::string& imgname ) {
        //std::string name(filename);
        cv::imwrite(filename, m_matrix);
        m_name = imgname;
      }
      void save( const std::string& filename, const std::vector<int>& params ) {
        cv::imwrite(filename, m_matrix, params);
        m_name = filename;
      };

      void print() { JFR_DEBUG(*this); }

      void convertColorMode(jafar::image::Image& dst_) const;
      void convertDepth(jafar::image::Image& dst_, double scale = 1.0, double offset = 0.0, bool _abs = false) const;
      
      void resize(Image& resizedImage, int interpolation = CV_INTER_LINEAR) const;
      
      Image* resize(double scale, int interpolation = CV_INTER_LINEAR) const;
      
      Image* resize(int newWidth, int newHeight, int interpolation = CV_INTER_LINEAR) const;
      
      void resize(int newWidth, int newHeight, int interpolation = CV_INTER_LINEAR);
      
      int imageSize() const;
      
      inline JfrImage_TypeColorSpace colorSpace() const {
        return header.colorSpace;
      };
      void setColorSpace(JfrImage_TypeColorSpace cs);
      inline uchar* data(int line =0) {
        return m_matrix.ptr(line);
      };
      
      inline const uchar* data(int line =0) const {
        return m_matrix.ptr(line);
      };
      
      void copy( jafar::image::Image & dst, int x_src = 0, int y_src = 0, int x_dst = 0, int y_dst = 0 , int width = -1, int height = -1) const;
      bool robustCopy( jafar::image::Image & dst, int x_src = 0, int y_src = 0, int x_dst = 0, int y_dst = 0 , int width = -1, int height = -1) const;

      bool extractPatch(image::Image &dst, int x, int y, int width, int height) const;
      
      cv::Rect getROI() const
      {
  cv::Size size;
  return getROI(size);
      }
      cv::Rect getROI(cv::Size &size) const
      {
  //return cvROIToRect((*this)->roi);
  //return roi();
        
  cv::Point offset;
  m_matrix.locateROI(size, offset);
  return cv::Rect(offset.x,offset.y,m_matrix.size().width,m_matrix.size().height);
      }
      void setROI(const cv::Rect &rect)
      {
  //cvSetImageROI(*this, rect);
  //set_roi(rect);
        
  setROI(rect.x, rect.y, rect.width, rect.height);
      }
      void setROI(int x, int y, int w, int h)
      {
        
  cv::Size size; cv::Point offset;
  m_matrix.locateROI(size, offset);
  m_matrix.adjustROI(offset.y-y, (h+y)-(m_matrix.size().height+offset.y),
         offset.x-x, (w+x)-(m_matrix.size().width +offset.x));
      }
      void resetROI()
      {
  //cvResetImageROI(*this);
  //reset_roi();
        
  cv::Size size; cv::Point offset;
  m_matrix.locateROI(size, offset);
  m_matrix.adjustROI(offset.y,size.height-(m_matrix.size().height+offset.y),
         offset.x,size.width-(m_matrix.size().width+offset.x));
      }

      
      inline std::string name() const {
        return m_name;
      }

      void setName(const std::string& _name) {
        m_name = _name;
      }

      template<typename channeltype>
      inline channeltype getPixelValue(int x_, int y_, int channel_=0) const;
      
      template<typename channeltype>
      double getSubPixelValue(double x_, double y_, int channel_=0, JfrImage_InterpolationType _interpolation = JfrImage_INTERP_BILINEAR) const;
      
      template<typename channeltype>
      void setPixelValue(channeltype val_, int x_, int y_, int channel_ = 0);
      
      double computeZncc(Image const* im2) const;
      double computeZnccRoisWeight(Image const* im2, cv::Rect const* roi1_ = NULL, cv::Rect const* roi2_ = NULL, float const* weightMatrix = NULL ) const;
      double computeZnccRoi(Image const* im2, cv::Rect const* rectRoi) const;
      
      double computeRotatingZncc( Image const* im2, int rotationStep) const;
      
      Image* rankTransform (const int radius);

      void rotateScale(double angle, double factor, Image &dest) const;

      double orientation(double sigma = 1.5);
      
      bool compHeader(Image const & img) const {
  return (width() == img.width() && 
    height() == img.height() &&
    depth() == img.depth() &&
    colorSpace() == img.colorSpace());
      }
      operator cv::Mat& () { return this->m_matrix; }
      operator const cv::Mat& () const { return this->m_matrix; }

#if CV_MAJOR_VERSION*10 + CV_MINOR_VERSION > 22
      // OpenCV 2.3 or later
      // need this because no more than one implicit conversion using user-defined convertor can be made
      operator cv::_OutputArray() { return this->m_matrix; }
      operator const cv::_OutputArray() const { return const_cast<cv::Mat&>(this->m_matrix); }
#endif

      operator const IplImage () const { 
        return (const IplImage)m_matrix;
      }
      operator IplImage () { 
  return (IplImage)m_matrix;
      }
      operator const CvMat () const { return (const CvMat)m_matrix; }
      operator CvMat () { return (CvMat)m_matrix; }
      inline cv::Size size() const { return m_matrix.size(); }
      inline bool empty() const { return m_matrix.empty(); }
      inline int width() const { return m_matrix.cols; }
      inline int height() const { return m_matrix.rows; }
      inline size_t step() const { return m_matrix.step; }
      inline size_t step1() const { return m_matrix.step1(); }
      inline int depth() const { return m_matrix.depth(); }
      inline int channels() const { return m_matrix.channels(); }
      inline int type() const { return m_matrix.type(); }
      inline cv::Mat mat() const { return m_matrix; }
      inline void detach() { m_matrix.release(); }
      inline size_t pix_size() { return !m_matrix.empty() ? m_matrix.elemSize() : 0; }
      void setTo(const cv::Scalar& s, const image::Image& mask=image::Image()) {
  m_matrix.setTo(s, mask);
      }
      void convertTo(image::Image& dst, double alpha=1, double beta=0) const {
  m_matrix.convertTo(dst, dst.type(), alpha, beta);
      }

    private:
      
      void initImageHeader();
      // serialization
      friend class boost::serialization::access;
      
      template<class Archive>
      void save(Archive & ar, const unsigned int version) const {
  JFR_PRECOND(!m_matrix.empty(), "Nothing to save");
  IplImage image = (IplImage)m_matrix;
  ar << boost::serialization::make_nvp("width",image.width);  
  ar << boost::serialization::make_nvp("height",image.height);  
  ar << boost::serialization::make_nvp("depth",image.depth);
  ar << boost::serialization::make_nvp("colorSpace",header.colorSpace); 
  ar << boost::serialization::make_nvp("nChannels",image.nChannels);
  ar << boost::serialization::make_nvp("nSize",image.nSize);  
  ar << boost::serialization::make_nvp("ID",image.ID);   
  ar << boost::serialization::make_nvp("dataOrder",image.dataOrder);  
  ar << boost::serialization::make_nvp("origin",image.origin);   
  ar << boost::serialization::make_nvp("imageSize",image.imageSize);  
  ar << boost::serialization::make_nvp("pixeldata", boost::serialization::make_binary_object(image.imageData, image.imageSize));
  ar << boost::serialization::make_nvp("widthStep",image.widthStep);
      }
      
      template<class Archive>
      void load(Archive & ar, const unsigned int version) {
  int width, height, depth;
  JfrImage_TypeColorSpace cs;
  ar >> boost::serialization::make_nvp("width",width);
  ar >> boost::serialization::make_nvp("height",height);
  ar >> boost::serialization::make_nvp("depth",depth);
  ar >> boost::serialization::make_nvp("colorSpace",cs);
  create(width, height, depth, cs);
  IplImage image = (IplImage)m_matrix;
  ar >> boost::serialization::make_nvp("nChannels",image.nChannels);
  ar >> boost::serialization::make_nvp("nSize",image.nSize);  
  ar >> boost::serialization::make_nvp("ID",image.ID);
  ar >> boost::serialization::make_nvp("dataOrder",image.dataOrder);  
  ar >> boost::serialization::make_nvp("origin",image.origin);
  ar >> boost::serialization::make_nvp("imageSize",image.imageSize);
  ar >> boost::serialization::make_nvp("pixeldata", boost::serialization::make_binary_object(image.imageData, image.imageSize));  
  ar >> boost::serialization::make_nvp("widthStep",image.widthStep);  
  memset(image.BorderMode, 0, 4);  
  memset(image.BorderConst, 0, 4);  
  image.imageDataOrigin = image.imageData;
      }
#ifndef SWIG
      BOOST_SERIALIZATION_SPLIT_MEMBER()
#endif /* NOT SWIG */

    private:
      inline double cubicKernel( int t, double dt ) const;
      inline double cubicKernelI( int t, int idx ) const;
    private:
      JfrImage_ImageHeader header;

      std::string m_name;
    }; // class Image
    
    template<typename channeltype>
    channeltype Image::getPixelValue(int x_, int y_, int channel_) const {
      JFR_PRECOND(x_ >= 0 && y_ >= 0 && x_ < width() && y_ < height(), "JfrImage::pixelValue pixel coordinates are not in the image.");
      JFR_PRECOND( 0 <= channel_ && channel_ < channels(), "JfrImage::pixelValue wrong channel parameter ");
      channeltype const *pxPtr;
      pxPtr = reinterpret_cast<channeltype const *>(data(y_));
      return *(pxPtr + x_*channels() + channel_);
    }

    inline double Image::cubicKernelI( int _t, int _idx ) const
    {
      switch( _t )
      {
        case -1:
          return cubicKernel2[_idx];
        case 0:
          return cubicKernel1[_idx];
        case 1:
          return cubicKernel1[cubicKernelResolution - _idx];
        case 2:
          return cubicKernel2[cubicKernelResolution - _idx];
      }
      return 0;
    }
    inline double Image::cubicKernel( int _t, double _dt ) const
    {
      int idx =int (_dt * cubicKernelResolution );
      return cubicKernelI( _t, idx );
    }
    
    template<typename channeltype>
    double Image::getSubPixelValue(double x_, double y_, int channel_, JfrImage_InterpolationType _interpolation ) const {
      int height_ = height();
      int width_ = width();
      JFR_PRECOND(x_ >= 0. && y_ >= 0. && x_ <= (double)width_ - 1 && y_ <= (double)height_ - 1, 
                  "JfrImage::pixelValue pixel coordinates are not in the image.");
      JFR_PRECOND( 0 <= channel_ && channel_ < channels(), "JfrImage::getSubpixelValue wrong channel parameter ");
      if( x_ == width() - 1) x_ -= 1e-6;
      if( y_ == height() - 1) y_ -= 1e-6;
  
      switch( _interpolation )
      {
        case JfrImage_INTERP_NEAREST:
        {
          return getPixelValue<channeltype>( lrint( x_ ), lrint( y_ ), channel_ );
        }
        case JfrImage_INTERP_BILINEAR:
        {
          int xi = (int)floor(x_);
          int yi = (int)floor(y_);
      
          double dx = x_-floor(x_);
          double dy = y_-floor(y_);
          double c11 = (1-dx)*(1-dy);
          double c12 = (1-dy)*dx;
          double c21 = (1-dx)*dy;
          double c22 = dx*dy;
      
          return (
              c11 * getPixelValue<channeltype>(xi,yi, channel_)
              + c12 * getPixelValue<channeltype>(xi+1,yi, channel_)
              + c21 * getPixelValue<channeltype>(xi,yi+1, channel_)
              + c22 * getPixelValue<channeltype>(xi+1,yi+1, channel_));
        }
        case JfrImage_INTERP_CUBIC:
        {
          double result = 0.0;
          int xi = int(x_);
          int yi = int(y_);
          double dx = x_ - xi;
          int idxX =int( dx * cubicKernelResolution );
          double dy = y_ - yi;
          int idxY =int( dy * cubicKernelResolution );
          int channelsCount = channels();
          int offset = (xi - 1) * channelsCount + channel_;
          for(int v = -1; v < 3; ++v)
          {
            int yt = yi + v;
            if( yt >= 0 and yt < height_ )
            {
              channeltype const *pxPtr = reinterpret_cast<channeltype const *>(data(yt));
              pxPtr += offset;
              
              double ycoef = cubicKernelI( v, idxY);
              for(int u = -1; u < 3; ++u, pxPtr += channelsCount)
              {
                int xt = xi + u;
                if( xt >= 0 and xt < width_ ) // TODO use a better value than 0 when out of range
                {
                  result += ycoef * cubicKernelI( u, idxX ) * *pxPtr;
                }
              }
            }
          }
          return result;
        }
      }
      return -1;
    }
    
    template<typename channeltype>
    void Image::setPixelValue(channeltype val_, int x_, int y_, int channel_) {
      JFR_PRECOND(x_ >= 0 && y_ >= 0 && x_ < width() && y_ < height(), 
          "JfrImage::pixelValue pixel coordinates are not in the image.");
      JFR_PRECOND( 0 <= channel_ && channel_ < channels(), "JfrImage::pixelValue "
          "wrong channel parameter ");
      channeltype *pxPtr = reinterpret_cast<channeltype*>(data(y_));
      *(pxPtr+ x_ * channels() + channel_) = val_;
    }

    std::ostream& operator<<(std::ostream& s, const Image& image);
    std::ostream& operator<<(std::ostream& s, const JfrImage_TypeColorSpace tcs);

    class ImageIO {
    public:
      static void xml_load(jafar::image::Image & img, std::string const & filename);
      static void xml_save(jafar::image::Image & img, std::string const & filename);
      static void bin_load(jafar::image::Image & img, std::string const & filename);
      static void bin_save(jafar::image::Image & img, std::string const & filename);
    private:
      ImageIO() {};
    }; /* ImageIO */
    
  } /* image */
} /* jafar */

#endif