rtcImage.h

Go to the documentation of this file.

/*
 * Copyright (C) 2008
 * Robert Bosch LLC
 * Research and Technology Center North America
 * Palo Alto, California
 *
 * All rights reserved.
 *
 *------------------------------------------------------------------------------
 * project ....: PUMA: Probablistic Unsupervised Model Acquisition
 * file .......: Image.h
 * authors ....: Benjamin Pitzer
 * organization: Robert Bosch LLC
 * creation ...: 10/13/2006
 * modified ...: $Date: 2009-03-11 10:01:02 -0700 (Wed, 11 Mar 2009) $
 * changed by .: $Author: wg75pal $
 * revision ...: $Revision: 825 $
 */
#ifndef IMAGE_H
#define IMAGE_H

//== INCLUDES ==================================================================
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <cstdio>
#include <rtc/rtcArray2.h>
#include <rtc/rtcVec2.h>
#include <rtc/rtcVec3.h>
#include <rtc/rtcVec4.h>
//== NAMESPACES ================================================================
namespace rtc {

//== CLASS DEFINITION ==========================================================
template<typename T>
class Image : public Array2<T> {
public:
  typedef T Pixel;
  using Array2<T>::columns;
  using Array2<T>::rows;
  using Array2<T>::at;
  using Array2<T>::set;
  using Array2<T>::x;

  // c'tor
  Image():Array2<Pixel>(1,1){}
  Image(int _rows, int _columns):Array2<Pixel>(_rows,_columns){}
  Image(const Image& other):Array2<Pixel>(other){}
  // d'tor
  virtual ~Image(){}

  // scaling/resizing operators
  Pixel interpolate(const float row, const float col) const;
  bool resize(int rows, int columns);
  bool resized(Image& dest) const;

  // file i/o
  bool readFromFile(const char* filename);
  bool writeToFile(const char* filename) const;

  // convert to/from openCV cv::Mat
  bool fromOpenCV(const cv::Mat& image);
  bool toOpenCV(cv::Mat& image) const;

  // stream IO
  virtual bool write(OutputHandler& oh) const;
  virtual bool read(InputHandler& ih);
  void write(FILE *fp) const;
  void read(FILE *fp);

  // Assignment operator
  Image<T>& operator = (const Image<T>& img);

  // Image Process
  // resize() can do that only slower
  void halfImageTo(Image<T> &other);
  void halfImage(){Image<T> img;halfImageTo(img);*this=img;}
  void doubleImageTo(Image<T> &other);
  void doubleImage(){Image<T> img;doubleImageTo(img);*this=img;}
  void doubleImage2To(Image<T> &other);
  void doubleImage2(){Image<T> img;doubleImage2To(img);*this=img;}
  void operator-=(const Image<T> &other){for (int i=0;i<rows();i++) for (int j=0;j<columns();j++) at(i,j)-=other.at(i,j);}
  void operator*=(const Image<T> &other){for (int i=0;i<rows();i++) for (int j=0;j<columns();j++) at(i,j)*=other.at(i,j);}
  void operator+=(const Image<T> &other){for (int i=0;i<rows();i++) for (int j=0;j<columns();j++) at(i,j)+=other.at(i,j);}
  void operator/=(const Image<T> &other){for (int i=0;i<rows();i++) for (int j=0;j<columns();j++) at(i,j)/=other.at(i,j);}
  void operator*=(const T &v){for (int i=0;i<rows();i++) for (int j=0;j<columns();j++) at(i,j)*=v;}
  void operator-=(const T &v){for (int i=0;i<rows();i++) for (int j=0;j<columns();j++) at(i,j)-=v;}
  void operator+=(const T &v){for (int i=0;i<rows();i++) for (int j=0;j<columns();j++) at(i,j)+=v;}
  void operator/=(const T &v){for (int i=0;i<rows();i++) for (int j=0;j<columns();j++) at(i,j)/=v;}
};

// Declare a few common typedefs
typedef Image<Vec4uc> Image4uc;
typedef Image<Vec3uc> Image3uc;
typedef Image<Vec3f> Image3f;
typedef Image<unsigned char> Imageuc;

template<typename T>
inline void Image<T>::halfImageTo( Image<T> &other )
{
  int row=rows()/2;
  int column=columns()/2;

  other.setSize(row,column);

  for (int i=0;i<row;i++) for (int j=0;j<column;j++)
    other.at(i,j)=at(i*2,j*2);
}

template<typename T>
inline void Image<T>::doubleImageTo( Image<T> &other )
{
  int row=rows()*2;
  int column=columns()*2;

  other.setSize(row,column);

  for (int i=0;i<row;i++) for (int j=0;j<column;j++)
    other.at(i,j)=at(i/2,j/2);
}

template<typename T>
inline void Image<T>::doubleImage2To( Image<T> &other )
{
  int row=rows()*2;
  int column=columns()*2;

  other.setSize(row,column);

  // fill every pixel so we don't have to worry about skipping pixels later
  for (int i = 0; i < row; i++) for (int j = 0; j < column; j++)
    other.at(i, j)= at(i/2, j/2);
  /*
  A B C
  E F G
  H I J

  pixels A C H J are pixels from original image
  pixels B E G I F are interpolated pixels

  */

  // interpolate pixels B and I
  for (int i = 0; i < row; i += 2) for (int j = 1; j < column - 1; j += 2)
    other.at(i, j)= (at(i/2, j/2) + at(i/2 + 1, j/2)) / 2.0;


  // interpolate pixels E and G
  for (int i = 1; i < row - 1; i += 2) for (int j = 0; j < column; j += 2)
    other.at(i, j)= (at(i/2, j/2) + at(i/2, j/2 + 1)) / 2.0;


  // interpolate pixel F
  // interpolate pixels E and G
  for (int i = 1; i < row - 1; i += 2) for (int j = 1; j < column - 1; j += 2)
    other.at(i, j)= (at(i/2, j/2) + at(i/2, j/2 + 1) + at(i/2 + 1, j/2) + at(i/2 + 1, j/2 + 1)) / 4.0;
}

template<typename T>
inline bool Image<T>::resize(int _rows, int _columns)
{
  Image dest(_rows,_columns);
  resized(dest);
  set(dest);
  return true;
}

template<typename T>
inline bool Image<T>::resized(Image& dest) const
{
  int x,y;
  float fx,fy;
  const float dx = static_cast<float>(columns()-1)/(dest.columns()-1);
  const float dy = static_cast<float>(rows()-1)/(dest.rows()-1);
  for (fy=0.0,y=0;y<dest.rows();++y,fy+=dy) for (fx=0.0,x=0;x<dest.columns();++x,fx+=dx)
    dest.at(y,x) = interpolate(fy,fx);
  return true;
}

// stream IO
template<typename T>
inline bool Image<T>::write(OutputHandler& oh) const
{
  Array2<Pixel>::write(oh);
  return true;
}

template<typename T>
inline bool Image<T>::read(InputHandler& ih)
{
  Array2<Pixel>::read(ih);
  return true;
}

template<typename T>
inline void Image<T>::write(FILE *fp) const
{
  int nrow=rows(),ncol=columns();
  fwrite(&nrow,sizeof(nrow),1,fp);
  fwrite(&ncol,sizeof(ncol),1,fp);
  fwrite(x,sizeof(Pixel),nrow*ncol,fp);
}

template<typename T>
inline void Image<T>::read(FILE *fp)
{
  size_t res = 0;
  int nrow,ncol;
  res+=fread(&nrow,sizeof(nrow),1,fp);
  res+=fread(&ncol,sizeof(ncol),1,fp);
  this->setSize(nrow,ncol);
  res+=fread(x,sizeof(Pixel),nrow*ncol,fp);
}

// Assignment operator
template<typename T>
inline Image<T>& Image<T>::operator = (const Image<T>& img)
{
  set(img);
  return *this;
}

//==============================================================================
} // namespace rtc
//==============================================================================
#endif //IMAGE_H