imageprocessor.h

Go to the documentation of this file.

/* Copyright (C) 2000-2013 CEA
 *
 * This software and supporting documentation were developed by
 *     bioPICSEL
 *     CEA/DSV/I²BM/MIRCen/LMN, Batiment 61,
 *     18, route du Panorama
 *     92265 Fontenay-aux-Roses
 *     France
 */
 
/*
 *  Data reader class
 */
#ifndef BRAINRAT_UTILITY_IMAGEPROCESSOR_H
#define BRAINRAT_UTILITY_IMAGEPROCESSOR_H
 
#define BRAINRAT_IMAGE_PROCESSOR 1
#define BRAINRAT_NEW_EXTRACTORS 1
 
#include <cartobase/object/object.h>
#include <cartobase/type/converter.h>
#include <cartobase/smart/rcptr.h>
#include <aims/data/data.h>
#include <aims/roi/maskIterator.h>
#include <aims/utility/channel.h>
#include <aims/utility/progress.h>
#include <aims/border/borderfiller.h>
#include <aims/signalfilter/gaborfilter.h>
#include <aims/signalfilter/meanfilter.h>
#include <aims/signalfilter/variancefilter.h>
#include <aims/connectivity/structuring_element.h>
#include <string>
#include <vector>
 
namespace bio {
    
#ifdef BRAINRAT_IMAGE_PROCESSOR
    
  enum ImageProcessorMode
  {
    Init = 0,
    OnDemand = 1
  };
  
  template<class T, class U>
  class ImageProc {
    public:
      ImageProc(){}
      virtual ~ImageProc(){}
      
      virtual void get(AimsData<T> &in, 
                       AimsData<U> &out, 
                       const carto::rc_ptr<aims::MaskIterator> mask = carto::rc_ptr<aims::MaskIterator>()) = 0;
      virtual U get(AimsData<T> &in, const Point3dl & p) = 0;
  };
  
  template<class T, class U, class C>
  class ConvertibleImageProc : public ImageProc<T, U> {
    public:
      ConvertibleImageProc(){}
      virtual ~ConvertibleImageProc(){}
      
      virtual void get(AimsData<T> &in, 
                       AimsData<U> &out, 
                       const carto::rc_ptr<aims::MaskIterator> mask = carto::rc_ptr<aims::MaskIterator>()) = 0;
      virtual U get(AimsData<T> &in, const Point3dl & p) = 0;
      
    protected:
      inline virtual void convert(T &in, C &out) { _converter.convert(in, out); }
      
      carto::ShallowConverter<T, C> _converter;
      C _internal_value;
  };
  
  template<class T, class U>
  class ConvertibleImageProc<T, U, T> : public ImageProc<T, U> {
    public:
      ConvertibleImageProc(){}
      virtual ~ConvertibleImageProc(){}
      
      virtual void get(AimsData<T> &in, 
                       AimsData<U> &out, 
                       const carto::rc_ptr<aims::MaskIterator> mask = carto::rc_ptr<aims::MaskIterator>()) = 0;
      virtual U get(AimsData<T> &in, const Point3dl & p) = 0;
      
    protected:
      inline virtual void convert(T &in, T &out) { out = in; }
      
      T _internal_value; // Used to not allocate object many times
  };
 
  template<class T, class U, class C = T>
  class ChannelImageProc : public ConvertibleImageProc<T, U, C> {
    public:
      ChannelImageProc(uint8_t channel = 4);
      virtual ~ChannelImageProc(){}
 
      virtual void get(AimsData<T> &in, 
                       AimsData<U> &out, 
                       const carto::rc_ptr<aims::MaskIterator> mask = carto::rc_ptr<aims::MaskIterator>());
      virtual U get(AimsData<T> &in, const Point3dl & p);
      
    private:
      uint8_t _channel;
      ChannelSelector<C, U> _selector;
  };
 
  template<class T, class U>
  class MorphoImageProc : public ImageProc<T, U> {
    public:
      MorphoImageProc(const carto::Object options);
      virtual ~MorphoImageProc(){}
      
      virtual void get(AimsData<T> &in, 
                       AimsData<U> &out, 
                       const carto::rc_ptr<aims::MaskIterator> mask = carto::rc_ptr<aims::MaskIterator>());
      virtual U get(AimsData<T> &in, const Point3dl & p);
      
    private :
      carto::rc_ptr<aims::StructuringElement> _vse;
      int32_t _vsesize;
      int32_t _se;
      double _amplitude;
      bool _planar;
      bool _usecenter;
      bool _test;
      carto::Object _options;
  };
  
  template<class T, class U>
  class ImageProcessors {
    public:
      ImageProcessors(const AimsData<T> &in,
                      const carto::rc_ptr<aims::MaskIterator> mask = carto::rc_ptr<aims::MaskIterator>(),
                      const std::string & procids = "rgbm", 
                      const carto::Object options = carto::none(), 
                      const int32_t mode = OnDemand);
      virtual ~ImageProcessors(){}
      
      //static get(const AimsData<T> &d, string &p, carto::Object options, ImageProcessorMode mode )
      
      virtual void initialize();
      virtual U get(const Point3dl & p, const int32_t pi);
      virtual AimsData<U> get(const int32_t pi);
      virtual std::string procids();
      
      static std::string expandprocids(const std::string procids);
      
    private:
      
      AimsData<T> _in;
      carto::rc_ptr<aims::MaskIterator> _mask;
      carto::Object _options;
      std::vector<AimsData<U> > _data;
      std::vector<int32_t> _ptypes;
      std::vector<carto::rc_ptr<ImageProc<T, U> > > _procs;
      int32_t _mode;
      std::string _procids;
  };
 
#endif // BRAINRAT_IMAGE_PROCESSOR
  
#ifdef BRAINRAT_NEW_EXTRACTORS
  
  // Get time string
  std::string timeString(std::string format = "%d-%m-%Y %H:%M:%S");
  
  // Color Extractor
  template<class T, class U>
  class ColorExtractor {
    public:
        ColorExtractor(const carto::rc_ptr<aims::MaskIterator> mask = carto::rc_ptr<aims::MaskIterator>(),
                       const std::string & extract = "rgbm",
                       const bool forceGray = false,
                       const int  & featureOffset = 0);
        virtual ~ColorExtractor(){}
        
        // Accessors
        virtual carto::VolumeRef<U> getFeatures();
        virtual carto::VolumeRef<double> getGray();
        virtual int getCount();
        virtual carto::Object getDict();
        
        // Methods
        virtual void check();
        virtual void extract(const carto::VolumeRef<T> &vol);
    
    protected:
        virtual void initializeDict();
        virtual void checkExtract();
        virtual void checkColorSpace();
        virtual void checkGraySpace();
      
    private:      
        //carto::VolumeRef<T>               _in; // TODO: remove
        carto::VolumeRef<double>          _gray;
        carto::VolumeRef<U>               _features;
        carto::rc_ptr<aims::MaskIterator> _mask;
        std::string                       _extract;
        bool                              _forceGray;
        int                               _borderSize;
        int                               _featureOffset;
        
        bool                              _isSameColorSpace;
        bool                              _hasGraySpaceFeature;
        
        carto::Object                     _dictFeat;
  };
  
  // Neighbour Extractor
  class NeighbourExtractor {
    public:
        NeighbourExtractor(const carto::rc_ptr<aims::MaskIterator> mask = carto::rc_ptr<aims::MaskIterator>(),
                           const int amplitude = 1,
                           const std::string modes = "M",
                           const std::string shape = "D",
                           const std::vector<int> layers = std::vector<int>(),
                           const int featureOffset = 0);
        virtual ~NeighbourExtractor(){};
        
        // Accessors
        virtual carto::VolumeRef<float> getFeatures();
        virtual int getCount();
        virtual carto::Object getDict();
        
        // Methods
        virtual void extract(const carto::VolumeRef<double> &vol);
    
    protected:
        virtual void initializeDict();
        virtual carto::rc_ptr<aims::strel::Shape> getStructuringElement();
        carto::VolumeRef<uint8_t> extractNeighbours(
            carto::VolumeRef<double> const & grayImage,
            aims::strel::Shape & disk);
      
    private:
        carto::VolumeRef<float>            _features;
        carto::rc_ptr<aims::MaskIterator>  _mask;
        int                                _amplitude;
        std::string                        _extract;
        std::string                        _shape;
        std::vector<int>                   _layers;
        int                                _featureOffset;
        
        carto::rc_ptr<aims::strel::Shape>  _structuringElement;
        carto::Object                      _dictFeat;
  };  
  
  // Gabor Extractor
  class GaborExtractor {
    public:
        GaborExtractor(const carto::rc_ptr<aims::MaskIterator> mask = carto::rc_ptr<aims::MaskIterator>(),
                       const std::vector<double> sigma  = std::vector<double>(),
                       const std::vector<double> theta  = std::vector<double>(),
                       const std::vector<double> lambda = std::vector<double>(),
                       const std::vector<double> psi    = std::vector<double>(),
                       const std::vector<double> gamma  = std::vector<double>(),
                       const std::vector<int>    real   = std::vector<int>(),                        
                       const int featureOffset = 0);
        virtual ~GaborExtractor(){};
        
        // Accessors
        virtual carto::VolumeRef<float> getFeatures();
        virtual int getCount();
        virtual carto::Object getDict();
        virtual carto::Object getGaborDict();
        
        //Methods
        virtual void extract(const carto::VolumeRef<double> &vol);
        
    protected:
        virtual void initializeDict();
        virtual void initializeGaborDict();
        
    private:
        carto::VolumeRef<double> _gray;
        carto::VolumeRef<float> _features;
        carto::rc_ptr<aims::MaskIterator> _mask;
        
        std::vector<double> _sigma;
        std::vector<double> _theta;
        std::vector<double> _lambda;
        std::vector<double> _psi;
        std::vector<double> _gamma;
        std::vector<int>    _real;
        
        std::vector<aims::GaborFilter<double> > _filters;
        int _featureOffset;
        
        carto::Object _dictFeat;
        carto::Object _dictGabor;
  }; 
  
  // Texture Extractor
  class TextureExtractor {
    public:
        TextureExtractor(const carto::rc_ptr<aims::MaskIterator> mask = carto::rc_ptr<aims::MaskIterator>(),
                         const std::string tex_chara = "N",
                         const std::vector<int> tex_HTA = std::vector<int>(),
                         const std::string tex_lbp = "N",
                         const int featureOffset = 0);
        virtual ~TextureExtractor(){};
        
        // Accessors
        virtual carto::VolumeRef<float> getFeatures();
        virtual int getCount();
        virtual carto::Object getDict();
        
        //Methods
        virtual void extract(const carto::VolumeRef<double> &vol);
        
    protected:
        virtual void initializeDict();
        virtual void initializeMatrix();
        virtual void resetMatrix();
        virtual void computeMatrix(const carto::VolumeRef<double> &vol);
        virtual void computeLBP(const carto::VolumeRef<double> &vol);
        virtual void computeHaralick(const carto::VolumeRef<double> &vol);
        virtual void computeTamura(const carto:: VolumeRef<double> &vol);
        
    private:
        carto::VolumeRef<float> _features;
        carto::rc_ptr<aims::MaskIterator> _mask;
        
        Point3dl _coord;
        std::vector<carto::VolumeRef<double> > _coomat;
        carto::VolumeRef<double> _lbpImage;
        carto::VolumeRef<double> _haralickImage;
        carto::VolumeRef<double> _tamuraImage;
        
        std::string _tex_chara;
        std::string _tex_lbp;
        std::vector<int> _tex_HTA;
        
        int _k; // TODO: remove
        int _featureOffset;
        
        carto::Object _dictFeat;
        aims::strel::SquareXY _haralickStructuringElement;
  };
#endif // BRAINRAT_NEW_EXTRACTORS
}
 
#endif