NICE_Core/core/image/MultiChannelImage3DT.h

#ifndef _NICE_CORE_MULTICHANNELIMAGE3DT_H
#define _NICE_CORE_MULTICHANNELIMAGE3DT_H

#include <core/image/MultiChannelImageAccess3D.h>
#include <core/image/ImageT.h>
#include <core/image/MultiChannelImageT.h>

#include <vector>
#include <fstream>

namespace NICE {

/**
 * @class MultiChannelImage3DT
 * A 3d image (arbitrary number of cross section images) consisting of an arbitrary number of channels.
 *
 * formaly known as Generic Image
 *
 * @author Björn Fröhlich and Sven Sickert
 * @example notyet
 */

template <class P>
class MultiChannelImage3DT : public MultiChannelImageAccess3D {
protected:
  typedef P Value;
  typedef unsigned int uint;

  /** image data, use carefully !!! data[channel][pixel_offset] */
  P **data;
  
  /** image width */
  int xsize;
  
  /** image height */
  int ysize;

  /** image depth */
  int zsize;
  
  /** number of image channels */
  uint numChannels;
  
public:

  virtual inline int width() const;
  virtual inline int height() const;
  virtual inline int depth() const;

  virtual inline int channels() const;

  virtual int getPixelInt( int x, int y, int z, int channel ) const;

  virtual double getPixelFloat( int x, int y, int z, int channel ) const;

  virtual void setPixelInt( int x, int y, int z, int channel, int pixel );

  virtual void setPixelFloat( int x, int y, int z, int channel, double pixel );

  /** simple constructor */
  MultiChannelImage3DT( int xsize, int ysize, int zsize, uint numChannels = 1);

  /** very simple constructor */
  MultiChannelImage3DT();

  /** copy constructor */
  MultiChannelImage3DT( const MultiChannelImage3DT<P>& p );

  /** simple destructor */
  virtual ~MultiChannelImage3DT();

  /** free all memory */
  void freeData();

  /** reinit */
  void reInit( int xsize, int ysize, int zsize, int numChannels = 1);

  /** reinit data structure using the same dimensions and
   number of channels as another image */
  template<class SrcP>
  void reInitFrom( const MultiChannelImage3DT<SrcP> & src);

  void addChannel( int newChans = 1 );

  /** add a channel to Multichannel Image */
  template<class SrcP>
  void addChannel( NICE::MultiChannelImageT<SrcP> &newImg );
  
  template<class SrcP>
  void addChannel(const NICE::MultiChannelImage3DT<SrcP> &newImg);
  
  /** get value */
  P get( int x, int y, int z, uint channel = 0 ) const;
  
  /** get data pointer */
  P** getDataPointer();

  /** set value */
  void set( int x, int y, int z, P val, uint channel = 0 );

  /** set value */
  void set( P val, uint channel = 0 );

  /** set value */
  void setAll( P val );

  /** calc integral image */
  void calcIntegral( uint channel = 0 );
  
  /** 
   * @brief calculate the gray level co-occurence matrix of a channel
   * @param max Co-occurence Matrix
   * @param dis displacement vector
   * @param channel channel
   */
  void calcGLCM( std::vector<std::vector<double> > & mat, const std::vector<int> dis, uint channel = 0 );
  
  /** 
   * @brief calculate the variance image map of a channel
   * @param srcchan source channel with raw data
   * @param tarchan target channel for the variance map
   */
  void calcVariance( uint srcchan = 0, uint tarchan = 1 );
  
  /**
   * @brief calculate the integral value in the volume given by upper left front corner and lower right back corner, including out of boundary check
   * @warning make sure that the given channel is an integral 3d image
   * @param ulfx upper left front x coordinate
   * @param ulfy upper left front y coordinate
   * @param ulfz upper left front z coordinate
   * @param lrbx lower right back x coordinate
   * @param lrby lower right back y coordinate
   * @param lrbz lower right back z coordinate
   * @param channel channel
   * @return P mean value of given volume
   **/
  P getIntegralValue(int ulfx, int ulfy, int ulfz, int lrbx, int lrby, int lrbz, int channel);

  /** convert to ice image */
  void convertToGrey( NICE::Image & img, int z, uint channel = 0, bool normalize = true ) const;

	/** convert to ice image template */
  void convertToGrey( NICE::ImageT<P> & img, int z, uint channel = 0, bool normalize = false ) const;
	
  /** convert to ice colorimage */
  void convertToColor( NICE::ColorImage & img, int z, const int chan1 = 0, const int chan2 = 1, const int chan3 = 2 ) const;

  /** return image for visualization */
  Image getChannel( int z, uint channel = 0 ) const;

	/** return image for visualization */
  ImageT<P> getChannelT( int z, uint channel = 0 ) const;

  /** return rgb image for visualization */
  ColorImage getColor(int z) const;

  /** calculate image statistics */
  void statistics( P & min, P & max, uint channel = 0 ) const;

  /** correct inhomogeneous illuminations (shading) between the image slices **/
  void correctShading( uint channel = 0 ) const;
  
  /** dump all data to RAW format: xsize, ysize, numChannels, <data> */
  void store( std::string filename ) const;

  /** read all data from RAW format: xsize, ysize, numChannels, <data> */
  void restore( std::string filename );
  
  /** copy alls data to new object */
  MultiChannelImage3DT<P>& operator=( const MultiChannelImage3DT<P>& orig );
  
  /** element operator */
  P & operator() (int x, int y, int z, uint channel = 0);
  
  /** element operator */
  MultiChannelImageT<P> operator[] (uint c);
};

} // namespace

#include <core/image/MultiChannelImage3DT.tcc>

#endif