cah.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
 */
 
#ifndef AIMS_CLASSIFICATION_CAH_H
#define AIMS_CLASSIFICATION_CAH_H
 
#include <aims/vector/vector.h>
#include <aims/data/data_g.h>
#include <aims/classification/individuals.h>
#include <vector>
#include <aims/math/discriminantanalysis.h>
 
namespace aims{
  class ProbabilisticPcaElement ;
} ;
 
template <typename T>
class Element{
 public:
  //    Constructeur :
  Element( int number, int card, const std::set<int>& constitutedFrom = std::set<int>() ) : 
    _number(number), _card(card), _constitutedFrom(constitutedFrom)
    {
      if( _constitutedFrom.empty() )
        _constitutedFrom.insert(number) ;
    }
  virtual ~Element(){}
  
  int number() const { return _number ;}
  void setNumber( int number ) { _number = number ;}
  
  int card() const { return _card ;}
  void setCard( int card ) { _card = card ;}
  
  const std::set<int>& constitutedFrom() const { return _constitutedFrom ; }
  
  virtual float distanceTo( Element<T> * other, 
                            const std::vector< std::list< Point3d > >& classes,
                            const AimsData<T>& data, const AimsData<float>& initDistances ) = 0 ;
  
  virtual Element<T> * agregateTo( Element<T> * other, 
                                   const std::vector< std::list< Point3d > >& classes,
                                   const AimsData<T>& data, const AimsData<float>& initDistances, int newNb = -1 ) = 0 ;
  
 protected:
  int _number;
  int _card;
  std::set<int> _constitutedFrom ;
} ;
 
template <typename T>
class BaryElement : public Element<T>{
 public:
  //    Constructeur :
  BaryElement( int card, const aims::Individuals<float>& bary, 
               const std::set<int>& constitutedFrom = std::set<int>(), int number = -1 ) ;
  BaryElement( const std::vector<std::list< Point3d > >& classes, 
               const AimsData<T>& data, 
               const std::set<int>& constitutedFrom = std::set<int>(), int number = -1 ) ;
  virtual ~BaryElement(){}
  
  const std::vector<float> & baryValue() const { return _bary.value() ; }
  const Point3df& baryPosition() const { return _bary.position() ; }
  
  virtual float distanceTo( Element<T> * other, 
                            const std::vector< std::list< Point3d > >& classes,
                            const AimsData<T>& data, const AimsData<float>& initDistances ) ;
  
  virtual Element<T> * agregateTo( Element<T> * other, 
                                   const std::vector< std::list< Point3d > >& classes,
                                   const AimsData<T>& data, const AimsData<float>& initDistances, int newNb = -1 ) ;
  
 private:
  void computeBary( const std::vector<std::list< Point3d > >& classes,
                    const AimsData<T>& data ) ;
 
  aims::Individuals<float> _bary ;
  //Individuals<T> _var ;
} ;
 
template <typename T>
class PcaElement : public Element<T>{
 public:
  //    Constructeur :
  PcaElement(  const std::vector<std::list< Point3d > >& classes, 
               const AimsData<T>& data, int numberOfSignificantVps,   
               const std::set<int>& constitutedFrom = std::set<int>(), int number = -1 ) ;
  virtual ~PcaElement(){}
  
 
  virtual float distanceTo( Element<T> * other, 
                            const std::vector< std::list< Point3d > >& classes,
                            const AimsData<T>& data, const AimsData<float>& initDistances ) ;
  
  virtual Element<T> * agregateTo( Element<T> * other, 
                                   const std::vector< std::list< Point3d > >& classes,
                                   const AimsData<T>& data, const AimsData<float>& initDistances, int newNb = -1 ) ;
  float unreconstructedInertia() ;
  float meanReconstructionError() ;
  float varReconstructionError() ;
  
  const AimsData<float>& errorMatrix( ) { return _errorMatrix ; }
  
 protected:
  void computeReconstructionError( const std::vector< std::list< Point3d > >& classes,
                                   const AimsData<T>& data ) ;
  float error( const Point3d& p, const AimsData<T>& data ) ;
  float _meanReconstructionError ;
  float _varReconstructionError ;
  
  AimsData<float> _errorMatrix ;
  std::vector<float> _mean ;
 
  float _unreconstructedInertia ;
  int _numberOfSignificantVps ;
  //TO DEFINE
  //Individual<T> _varIndividual ;
} ;
 
template <typename T>
class PcaReprocReconsErrorElement : public Element<T>{
 public:
  //    Constructeur :
  PcaReprocReconsErrorElement(  const std::vector<std::list< Point3d > >& classes, 
                                const AimsData<T>& data, int numberOfSignificantVps,   
                                const std::set<int>& constitutedFrom = std::set<int>(), int number = -1 ) ;
  virtual ~PcaReprocReconsErrorElement(){}
  
 
  virtual float distanceTo( Element<T> * other, 
                            const std::vector< std::list< Point3d > >& classes,
                            const AimsData<T>& data, const AimsData<float>& initDistances ) ;
  
  virtual Element<T> * agregateTo( Element<T> * other, 
                                   const std::vector< std::list< Point3d > >& classes,
                                   const AimsData<T>& data, const AimsData<float>& initDistances, int newNb = -1 ) ;
 
  const AimsData<float>& errorMatrix( ) { return _errorMatrix ; }
 
  float unreconstructedInertia() ;
  float meanReconstructionError() ;
  float varReconstructionError() ;
  
 private:
  void computeReconstructionError( const std::vector< std::list< Point3d > >& classes,
                                   const AimsData<T>& data ) ;
  float _meanReconstructionError ;
  float _varReconstructionError ;
  
  AimsData<float> _errorMatrix ;
  std::vector<float> _mean ;
 
  float _unreconstructedInertia ;
  int _numberOfSignificantVps ;
  //TO DEFINE
  //Individual<T> _varIndividual ;
} ;
 
template <typename T>
class PPcaElement : public Element<T>{
 public:
  //    Constructeur :
  PPcaElement(  const std::vector<std::list< Point3d > >& classes, 
                const AimsData<T>& data, int numberOfSignificantVps,   
                const std::set<int>& constitutedFrom = std::set<int>(), int number = -1 ) ;
  virtual ~PPcaElement(){}
  
 
  virtual float distanceTo( Element<T> * other, 
                            const std::vector< std::list< Point3d > >& classes,
                            const AimsData<T>& data, const AimsData<float>& initDistances ) ;
  
  virtual Element<T> * agregateTo( Element<T> * other, 
                                   const std::vector< std::list< Point3d > >& classes,
                                   const AimsData<T>& data, const AimsData<float>& initDistances, int newNb = -1 ) ;
  
/*   const AimsData<double> meanSignal() const { return _meanSignal ; } */
  aims::ProbabilisticPcaElement* ppca() { return _ppcaElement ; }
  
 private:
  void computeReconstructionError( const std::vector< std::list< Point3d > >& classes,
                                   const AimsData<T>& data ) ;
  
  AimsData<double> _meanSignal ;
  aims::ProbabilisticPcaElement * _ppcaElement ;
  
  int _numberOfSignificantVps ;
} ;
 
template <typename T>
class Max2By2DistanceElement : public Element<T>{
 public:
  //    Constructeur :
  Max2By2DistanceElement( const std::set<int>& constitutedFrom = std::set<int>(), int number = -1 ) ;
  virtual ~Max2By2DistanceElement(){}
  
 
  virtual float distanceTo( Element<T> * other, 
                            const std::vector< std::list< Point3d > >& classes,
                            const AimsData<T>& data, const AimsData<float>& initDistances ) ;
  
  virtual Element<T> * agregateTo( Element<T> * other, 
                                   const std::vector< std::list< Point3d > >& classes,
                                   const AimsData<T>& data, const AimsData<float>& initDistances, int newNb = -1 ) ;
  
 private:
} ;
 
template <typename T>
class SCKBDistanceElement : public Element<T>{
 public:
  //    Constructeur :
  SCKBDistanceElement( /*const std::vector<float> * classMaximumMoment, */
                      const AimsData<double> * maxMomentValueRatios,
                       const AimsData<double> * kinModel2by2Distances, 
                       const AimsData<double> * interactionSurf, 
                       const std::vector<double> * labelsVolumes,
                       float spatialregularizationWeight, float timeOfMaximumWeight, 
                       float meanDist2By2, float varDist2By2, float meanSurfVolRatio,
                       float varSurfVolRatio, float meanMaxMomentRatio, float varMaxMomentRatio,
                       const std::set<int>& constitutedFrom = std::set<int>(), int number = -1 ) :
    Element<T>( number, 0, constitutedFrom ), _maxMomentValueRatios(maxMomentValueRatios), 
    _kinModel2by2Distances(kinModel2by2Distances),
    _interactionSurf(interactionSurf), _labelsVolumes(labelsVolumes), 
    _spatialregularizationWeight(spatialregularizationWeight), _timeOfMaximumWeight(timeOfMaximumWeight),
    _meanDist2By2(meanDist2By2), _varDist2By2(varDist2By2), _meanSurfVolRatio(meanSurfVolRatio), 
    _varSurfVolRatio(varSurfVolRatio), _meanMaxMomentRatio(meanMaxMomentRatio), _varMaxMomentRatio(varMaxMomentRatio)
  {}
  
  virtual ~SCKBDistanceElement(){}
  
 
  virtual float distanceTo( Element<T> * other, 
                            const std::vector< std::list< Point3d > >& classes,
                            const AimsData<T>& data, const AimsData<float>& initDistances ) ;
  
  virtual Element<T> * agregateTo( Element<T> * other, 
                                   const std::vector< std::list< Point3d > >& classes,
                                   const AimsData<T>& data, const AimsData<float>& initDistances, int newNb = -1 ) ;
  
 private:
  //const std::vector<float> * _classMaximumMoment ;
  const AimsData<double> * _maxMomentValueRatios ;
  const AimsData<double> * _kinModel2by2Distances ;
  const AimsData<double> * _interactionSurf ;
  const std::vector<double> * _labelsVolumes ;
  float _spatialregularizationWeight ;
  float _timeOfMaximumWeight ;
  
  float _meanDist2By2 ;
  float _varDist2By2 ;
  float _meanSurfVolRatio ;
  float _varSurfVolRatio ;
  float _meanMaxMomentRatio ;
  float _varMaxMomentRatio ;
} ;
 
template <typename T>
class CahElementFactory{
 public:
  CahElementFactory( const std::vector< std::list< Point3d > >& classes = std::vector< std::list< Point3d > >(),
                     const AimsData<T>& data = AimsData<T>() ) ;
  virtual ~CahElementFactory( ) ;
  
  virtual Element<T> * creator( int n ) const  = 0 ;
  virtual std::list< Element<T>* > creator() const ;
  
  virtual std::string methodType() const  = 0 ;
  const std::vector< std::list< Point3d > >& classes() const { return _classes ; }
  const AimsData<T>& data() const { return _data ; }
  
  virtual bool initDistanceAlreadyComputed() const { return false ; }
  virtual const AimsData<float>* initDistances() const { return 0 ; }
  
 protected:
  const std::vector< std::list< Point3d > >& _classes ;
  const AimsData<T>& _data ;
} ;
 
template <typename T>
class BaryCahElementFactory : public CahElementFactory<T> {
 public:
  BaryCahElementFactory( const std::vector< std::list< Point3d > >& classes = std::vector< std::list< Point3d > >(),
                         const AimsData<T>& data = AimsData<T>() ) ;
  virtual ~BaryCahElementFactory( ) ;
  
  virtual Element<T> * creator( int n ) const  ;
  
  virtual std::string methodType() const { return "Barycenter" ;}
 private:
} ;
 
template <typename T>
class PcaCahElementFactory : public CahElementFactory<T> {
 public:
  PcaCahElementFactory( int nbOfSignificantVps, 
                        const std::vector< std::list< Point3d > >& classes = std::vector< std::list< Point3d > >(),
                        const AimsData<T>& data = AimsData<T>() ) ;
  virtual ~PcaCahElementFactory( ) ;
  
  virtual Element<T> * creator( int n ) const  ;
 
  virtual std::string methodType() const { return "Pca" ;}
  
 private:
  int _nbOfSignificantVps ;
} ;
 
template <typename T>
class PPcaCahElementFactory : public CahElementFactory<T> {
 public:
  PPcaCahElementFactory( int nbOfSignificantVps, 
                         const std::vector< std::list< Point3d > >& classes = std::vector< std::list< Point3d > >(),
                         const AimsData<T>& data = AimsData<T>() ) ;
  virtual ~PPcaCahElementFactory( ) ;
  
  virtual Element<T> * creator( int n ) const  ;
 
  virtual std::string methodType() const { return "PPca" ;}
  
 private:
  int _nbOfSignificantVps ;
} ;
 
template <typename T>
class Max2By2DistanceCahElementFactory : public CahElementFactory<T> {
 public:
  Max2By2DistanceCahElementFactory( const AimsData<float>& initDistances ) ;
  virtual ~Max2By2DistanceCahElementFactory( ) ;
  
  virtual std::list< Element<T>* > creator() const ;
  virtual Element<T> * creator( int n ) const  ;
 
  virtual std::string methodType() const { return "Max2By2Distance" ;}
  
  virtual bool initDistanceAlreadyComputed() const { return true ; }
  const AimsData<float>* initDistances() const { return &_initDistances ; } ;
  
  
 private:
  AimsData<float> _initDistances ;
  int _nbClasses ;
} ;
 
//Spatial coherence kinetics based segmentation method
template <typename T>
class SCKBDistanceCahElementFactory : public CahElementFactory<T> {
 public:
  SCKBDistanceCahElementFactory( const std::vector<std::list<Point3d> >& classes, 
                                 const std::vector<aims::DiscriminantAnalysisElement*>& classesKinDescription, 
                                 const AimsData<int>& locMap,
                                 const std::vector<short>& unfusionedLabels,
                                 const std::vector<float>& classMaximaMoment,
                                 float spatialregularizationWeight = 1., 
                                 float timeOfMaximumWeight = 0.5 ) ;
  virtual ~SCKBDistanceCahElementFactory( ) 
  {
    delete _classMaximumMoment ;
    delete _maxMomentValueRatios ;
    delete _antiCorrelatedMeans ;
    delete _kinModel2by2Distances ;
    delete _interactionSurf ;
    delete _labelsVolumes ;
  }
  
  virtual Element<T> * creator( int n ) const  ;
 
  virtual std::string methodType() const { return "SCKBDistance" ;}
  
  virtual bool initDistanceAlreadyComputed() const { return false ; }
  const AimsData<float>* initDistances() const { return 0 ; } ;
  
private:
  std::vector<float> * _classMaximumMoment ;
  AimsData<double> * _maxMomentValueRatios ;
  AimsData<char>  * _antiCorrelatedMeans ;
  AimsData<double> * _kinModel2by2Distances ;
  AimsData<double> * _interactionSurf ;
  std::vector<double> * _labelsVolumes ;
  float _spatialregularizationWeight ;
  float _timeOfMaximumWeight ;
  int _nbClasses ;
  float _meanDist2By2 ;
  float _varDist2By2 ;
  float _meanSurfVolRatio ;
  float _varSurfVolRatio ;
  float _meanMaxMomentRatio ;
  float _varMaxMomentRatio ;
} ;
 
template <typename T>
class PcaReprocReconsErrorCahElementFactory : public CahElementFactory<T> {
public:
  PcaReprocReconsErrorCahElementFactory( int nbOfSignificantVps, 
                                         const std::vector< std::list< Point3d > >& classes = std::vector< std::list< Point3d > >(),
                                         const AimsData<T>& data = AimsData<T>() ) ;
  virtual ~PcaReprocReconsErrorCahElementFactory( ) ;
  
  virtual Element<T> * creator( int n ) const  ;
  
  virtual std::string methodType() const { return "PcaReprocReconsError" ;}
  
private:
  int _nbOfSignificantVps ;
} ;
 
template <typename T>
class Cah
{
public:
  // 
  Cah( const CahElementFactory<T> * method ) ;
  ~Cah(){}
  
  
  //    void addElement(std::vector<double> , int);
  bool addElement(Element<T> * el);
  void initialisationDist();
  void oneStep(int);
  
  const std::vector< std::pair<Point2d, float> >& doit( ) ;
  const std::vector< std::pair<Point2d, float> >& result( ) { 
    if( _result.empty() ) return doit() ;
    return _result ;
  }
  std::vector<Point2d> cut( const std::vector< std::pair<Point2d, float> >& res, int );
  std::vector<Point2d> distanceCut( const std::vector< std::pair<Point2d, float> >& res, float );
 
  std::vector<Point2d> maxCurvatureCut( const std::vector< std::pair<Point2d, float> >& res );
 
  void save( const std::string& name ) ;
  const std::vector< std::pair<Point2d, float> >& load( const std::string& name ) ;
  const std::vector<std::set<short> >& newAgregateConstitution() const { return _newAgregatesConstitution ; }
 private:
  
  // Méthodes privées :
  //float distanceW(Element *element1, Element *element2);
  std::vector<int> leaves(int);
  std::vector<int> leaves(float);
  void Proc(int, std::vector<int>& );
  
 
  
  // Attributs privées :
  const std::vector< std::list< Point3d > >& _classes ;
  const AimsData<T>& _data ;
  std::list<Element<T>*> _listeN;
  std::multimap<float, Point2d> _mMap;
  std::vector< std::pair<Point2d, float> > _result;
  
  
  std::vector< std::set<short> > _newAgregatesConstitution ;
  AimsData<float> _distanceBetweenInitialElements ;
  unsigned int _m;              //nombre total d'individus
/*   std::vector<int> _uneClasse;       //variable locale utile */
  bool _canAddElement ;
 
  bool _initDistancesAlreadyComputed ;
};
 
 
 
#endif