plLearnUnKHistogram.h

/*==============================================================================
 * Product        : OpenPL 
 * File           : plLearnUnKHistogram.h
 * Author         : Manuel Yguel
 * Creation       : Mon Nov 10 08:52:09 2003
 *
 *==============================================================================
 *     (c) Copyright 2003, Centre National de la Recherche Scientifique,
 *                              all rights reserved
 *==============================================================================
 *
 *------------------------- Description ----------------------------------------
 *   Learning n dimensionnal histograms with UNKNOWN variables definition 
 *  sets.
 *   
 *------------------------------------------------------------------------------
 */


#ifndef __plLearnUnKHistogram_h__
#define __plLearnUnKHistogram_h__

#include <plLearn.h>
#include <plLearnType.h>
#include <pl.h>

//==============================================================================
enum { BOUNDARY, SELECT };

/* plUnKHistogramParameters class */
class plUnKHistogramParameters
{
protected :
  int _parameter_t;
  const plVariablesConjunction& _var;
  plValues _min;
  plValues _max;
  const vector<plValues>* _selected_values;
  
public :
  plUnKHistogramParameters( const plVariablesConjunction& var, 
                const plValues& min, const plValues& max )
    : _parameter_t( BOUNDARY ), _var( var ), _min( min ), _max( max ), 
      _selected_values( NULL ) {}
  
  plUnKHistogramParameters( const plVariablesConjunction& var, 
                const vector<plValues>& selected_values )
    : _parameter_t( SELECT ), _var( var ), _min( var ), _max( var ), 
      _selected_values( &selected_values ){}

  inline int getType() const
  {
    return _parameter_t;
  }

  inline const plVariablesConjunction& getVar() const
  {
    return _var;
  }

  inline const plValues& getMin() const
  {
    return _min;
  }

  inline const plValues& getMax() const
  {
    return _max;
  }

  inline const vector<plValues>* getSelectedValues() const
  {
    return _selected_values;
  }
};

//==============================================================================
class plLearnInitMap
{
 public:
  
  plLearnInitMap() : init(NULL){};
  plLearnInitMap( const map<plDataValues, plLearnFrequence >& initial );
  void assign( const map<plDataValues, plLearnFrequence >& initial );
  plLearnInitMap( map<plDataValues, plLearnFrequence >* initial,
          bool copie=false );
  void assign( map<plDataValues, plLearnFrequence >* initial,
           bool copie=false );

  map<plDataValues, plLearnFrequence >::const_iterator 
    begin(void) const
    {
      return init->begin();
    }
  
  map<plDataValues, plLearnFrequence >::const_iterator 
    end(void) const
    {
      return init->end();
    }

  map<plDataValues, plLearnFrequence >::const_iterator 
    find(const plDataValues& key ) const
    {
      return init->find(key);
    }

  friend class plLearnUnKHistogram;

  protected :
    map< plDataValues, plLearnFrequence > *const init;
};


void count_normalisation( const map<plDataValues, plLearnFrequence >& initial,
              plLearnFrequencesTotal* total );


//==============================================================================
class plLearnUnKHistogram : public plNonCndLearnObject
{
 protected:
  

  void get_boundaries( plDataValues& min_ref, plDataValues& max_ref ) const;


  const bool initialized;
  const bool copied;
  const plLearnFrequencesTotal _tot_init_samples;
  plLearnInitMap minit;

  map< plDataValues,plLearnFrequence> histo;


 public:
  /*CONSTRUCTORS*/
  plLearnUnKHistogram(const plLearnUnKHistogram & plLUKH);

  plLearnUnKHistogram( const plVariablesConjunction &vars );

  plLearnUnKHistogram( const plVariablesConjunction &vars,
               map< plDataValues, plLearnFrequence >*const initial,
               bool copie=false );

  plLearnUnKHistogram( const plVariablesConjunction &vars,
               const map< plDataValues, plLearnFrequence >& initial );


  /*********************/

  virtual ~plLearnUnKHistogram(){};
  
  void reset(void);

  void internal_addPoint(const plDataValues &point, double weight=1.0);

  virtual void get_boundaries( plValues& min_ref, plValues& max_ref ) const;




  virtual void get_frequencies(  map< plDataValues,plLearnFrequence>& map_ref ) const;

  virtual void select_frequencies( vector<plLearnFrequence>& frequencies_ref,
                   const vector<plValues>& selected_values ) const;


  virtual const map< plDataValues,plLearnFrequence>& get_map_histo( void ) const;

  virtual void get_plProbValue( map< plDataValues,plProbValue>& prob_map_ref ) 
    const;


  virtual void select_plProbValue(vector<plProbValue>& prob_ref, 
                  const vector<plValues>& selected_values ) const;


  virtual  plProbValue *
    select_plProbValue( const vector<plValues>& selected_values ) const;



  void get_frequencies( plLearnFrequence* frequencies ) const;
  void get_frequencies( vector<plLearnFrequence>& frequencies_ref ) const;

  void get_frequencies( plLearnFrequence* frequencies, 
            const plValues& min, 
            const plValues& max ) const;
  void get_frequencies( vector<plLearnFrequence>& frequencies_ref, 
            const plValues& min, 
            const plValues& max ) const;


  virtual void get_plProbValue( vector<plProbValue>& prob_ref ) const;
  
  virtual void get_plProbValue(vector<plProbValue>& prob_ref, 
                   const plValues& min, 
                   const plValues& max) const;

  virtual  plProbValue *get_plProbValue(const plValues& min, 
                    const plValues& max) const;
    
  void get_params(plValues &params) const;
  
  plKernel get_distribution( const void *parameters = NULL ) const
  {
    if(!parameters) return plKernel();
    
    vector<plProbValue> prob;
    const plUnKHistogramParameters *p =  (const plUnKHistogramParameters *)parameters;

    switch( p->getType() )
      {
      case BOUNDARY :
        get_plProbValue( prob, p->getMin(), p->getMax() ); break;
      case SELECT : select_plProbValue( prob, *(p->getSelectedValues()) ); break;
      default :printf( "Unknown parameter type for get_distribution of plLearnUnKHistogram\n" );
        abort();
        exit(-1);
      }

    return plProbTable( p->getVar(), prob, false );
  }

};

#endif

---