biovision.h

Go to the documentation of this file.

/* Copyright (C) 2000-2016 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
 */
 
#ifndef BRAINRAT_CLASSIFICATION_BIOVISION_H
#define BRAINRAT_CLASSIFICATION_BIOVISION_H
 
//--- brainrat ----------------------------------------------------------
#include <brainrat/data/classes.h>
//--- aims -------------------------------------------------------------------
#include <aims/data/data_g.h>
#include <aims/utility/channel.h>
//--- cartobase --------------------------------------------------------------
#include <cartobase/smart/rcptr.h>
//----------------------------------------------------------------------------
#include <cartodata/volume/volume.h>
 
namespace biovision {
 
//============================================================================
//   U T I L I T I E S
//============================================================================
 
  template< typename T1, typename T2>
  inline bool pair_key_comparer( const std::pair<T1, T2>& p1,
                                 const std::pair<T1, T2>& p2 )
  {
    return p1.first < p2.first;
  }
  
//============================================================================
//   L E A R N I N G
//============================================================================
  
  class LearningAlgorithm
  {
    public:
        
      LearningAlgorithm( int          sizeT_im,
                         double       clustering_sigma_min,
                         double       clustering_sigma_ratio,
                         int32_t      clustering_number_max,
                         double       clustering_size_min,
                         double       clustering_threshold,
                         int32_t      clustering_new_policy );
 
      virtual ~LearningAlgorithm() {}
      
      // Undestand the image and gather informations for the learning
      template <typename T> int32_t
      processOneImage( carto::VolumeRef<T>      & inputImage,
                       const std::string        & inputGraph,
                       const std::string        & fileOutMeasure,
                       std::vector<carto::Object >                      & classDesc,
                       std::vector<std::vector<std::vector<double> > >  & classVectors );
 
      // Builds the model based on computed vectors.
      virtual int32_t
      learnClustering( std::list<double> & inputListOfPrior,
                       std::vector<carto::Object >                      & classDesc,
                       std::vector<std::vector<std::vector<double> > >  & classVectors );
 
      // Writes the model as a Dpy file.
      virtual void saveModel( std::string  & fileOutData );
 
    private:
 
//=== Methods ================================================================
      // Compute determinant and inverse I of a square matrix M using
      // Gaussian elimination.
      double det(carto::VolumeRef<double > M, carto::VolumeRef<double > & I);
      // Process the euclidian distance between two vectors of double
      double distance( std::vector<double> aa, std::vector<double> bb );
      // Processes centroid of new cluster using histogram.
      int32_t HistogramCandidateCentroid( const std::vector<std::vector<double> >    & mv,
                                          const std::vector<std::pair<double, int> > & vcandidates, 
                                          const int32_t bins = 256 );
      // Clustering a set of MeasureVectors with respect to entropy
      // minimization, and returning centroids C contains cluster assignment 
      // for each MeasureVector threshold is used when testing whether a 
      // measure vector fits poorly in clusters : if so, creates a new 
      // cluster process stops when sigmamin or nbclustermax is reached.
      std::vector<std::vector<double> >
      Clustering ( const std::vector<std::vector<double> > &mv,
                   double threshold, double sigmamin,
                   double sigmaratio, int nbclustermax,
                   int newclusterpolicy, double clustersizemin,
                   carto::VolumeRef< int > &C );
 
//=== Fields =================================================================
      int32_t      _measuresize;    
 
//=== Clustering =============================================================
      double   _sigmamin;           
      double   _sigmaratio;         
      int32_t  _nbclustermax;       
      double   _clustersizemin;     
      double   _threshold;          
      int32_t  _newclusterpolicy;   
 
      carto::Object _learningmodel; 
 
      int _loopcount;               
  };
  
//============================================================================
//   C L A S S I F I C A T I O N 
//============================================================================
  
  class ClassificationAlgorithm
  {
    public:
        
      ClassificationAlgorithm( const std::string &fileInData, const int numbfeat );
 
      virtual ~ClassificationAlgorithm() {}
      
      // Classify an image
      template <typename T>
      int32_t classify( carto::VolumeRef<T>            &image,
                        const std::vector<int32_t>     &labels,
                        const std::vector<std::string> &classesorder,
                        const std::string &maskFile = "",
                        const bool keepClasses      = true,
                        const bool keepProba        = false,
                        const bool keepDensity      = false);
 
      // Write classification results
      // Corresponding "keep" options must have been set at true
      // in classify function.
      int32_t writeResults( const std::string &outputFile        = "",
                            const std::string &outputProbaFile   = "",
                            const std::string &outputDensityFile = "");
 
      // Classify a point
      template <typename T>
      int32_t classify( const Point3dl &t, carto::VolumeRef<T> &image );
 
      // Accessors
      carto::VolumeRef<int16_t> getClassesImage() { return _Cimage.copy(); }
      carto::VolumeRef<double>  getProbaImage() { return _Pimage.copy(); }
      carto::VolumeRef<double>  getDensityImage() { return _Dimage.copy(); }
 
    private:
//=== Methods ================================================================
      void InitializeClasses( const std::vector<carto::Object > &c );
 
      double Density( const int32_t ic, const std::vector<double> &w );
 
      int32_t Classifier( const std::vector<double> &w, 
                          const Point3dl            &p, 
                          const bool storeproba = false,
                          const bool storedensity = false,
                          const bool display = false );
 
//=== Fields =================================================================
      std::string  _pixelmeasure; // Channels used for measure vectors
      int32_t      _measuresize;  // Measure vector size.
 
//=== Classification =========================================================
      int32_t              _nbclasses;  // Number of classes
      std::vector<double>  _prior;      // Prior probabilities (optional)
 
//=== Variables declared for acceleration purpose ============================
      carto::VolumeRef<double> _v;
      std::vector<std::vector<carto::VolumeRef<double> > > _modelcov; // covariance matrices for each cluster
      carto::rc_ptr<std::vector<double> > _mu;
      carto::VolumeRef<double>   _Dimage;               // density image
      carto::VolumeRef<double>   _Pimage;               // probability image
      carto::VolumeRef<int16_t>  _Cimage;               // class label image
 
      carto::Object                                 _learningmodel;
      std::vector<carto::Object >                   _classdesc;    // Model info
      std::vector<std::vector<carto::Object> >      _density;
  };
  
}// namespace biovision
 
#endif // BRAINRAT_CLASSIFICATION_BIOVISION_H