---

stimulusparametermap.h

Go to the documentation of this file.

#ifndef __STIMULUSPARAMETERMAP_H__
#define __STIMULUSPARAMETERMAP_H__

#include <string>
using std::string;
#include <vector>
#include <functional>

#include "matrix.h"
#include "histogram.h"
#include "neuralregionmanager.h"



template <class MapBaseType, class ValuePointer>
class StimulusParameterMap {
public:
  typedef typename MapBaseType::size_type Subscript;

  virtual ~StimulusParameterMap() {}

  StimulusParameterMap(const string& name_, ValuePointer& valueptr_)
    : valueptr(valueptr_), namestr(name_)  { }

  int undefined_values() const {  return undefined_vals;  }

  virtual MapBaseType*  map() const =0;
  
  virtual MapBaseType*  selectivity() const =0;
  
  const string& name() const {  return namestr;  }

protected:
  void undefined_values_start(const int undefined_values) const
    {  undefined_vals = undefined_values;  }
  
  void undefined_values_end(const int undefined_values) const
    {  undefined_vals = undefined_values-undefined_vals;  }

  ValuePointer& valueptr;

private:
  const string namestr;
  mutable int undefined_vals;
};



template <class MapType, class MapBaseType, class ValuePointer>
class StimulusParameterMap_Combined
  : public StimulusParameterMap<MapBaseType,ValuePointer> {
  typedef mat::MatrixInterfaceAdapter <MapType,typename MapBaseType::value_type> MapAdapterType;

public:
  typedef Histo::OneDBinList<> Histogram;
  typedef typename MatrixType< typename MapType::value_type >::rectangular MapMatrix;
  typedef typename MatrixType< Histogram                    >::rectangular HistoMatrix;
  typedef typename StimulusParameterMap<MapBaseType,ValuePointer>::Subscript Subscript;
  typedef typename MapAdapterType::ScaleType ScaleType;

  
  virtual ~StimulusParameterMap_Combined() {}
      
  StimulusParameterMap_Combined(const MapType& reference_map, const string& name_,
                                ValuePointer& valueptr_,
                                bool measure_distribution_=true,
                                bool weighted_average_=false,
                                bool cyclic_=true,
                                const ScaleType& selectivity_scale_=ScaleType())
    : StimulusParameterMap<MapBaseType,ValuePointer>(name_, valueptr_),
    measure_distribution(measure_distribution_),
    weighted_average(weighted_average_), cyclic(cyclic_),
    selectivity_scale(selectivity_scale_),
    maxvals(reference_map.nrows(),reference_map.ncols()),
    /* For safety, this is always allocated, but ideally it would not
       be when measure_distribution_ is false: */
    maxvals_distribution(reference_map.nrows(),reference_map.ncols())
    { }
  

  inline void mark_current_value_as_max(   Subscript r, Subscript c) {  maxvals[r][c] = *valueptr;  }

  inline void update_distribution(Subscript r, Subscript c, Histogram::Magnitude val) {
    assert(measure_distribution);
    Histogram* h = &(maxvals_distribution[r][c]);
    Histogram::size_type bin = (cyclic ? h->bin_number(*valueptr)
                                : h->bin_number_inclusive(*valueptr));
    h->keep_peak(bin,val);
  }

  MapBaseType*  map() const {
    return (measure_distribution && weighted_average?
            (distribution_map
             (std::mem_fun_ref(cyclic ?
                               &Histogram::vector_direction :
                               &Histogram::weighted_average)))
            : coarse_map());
  }
  
  MapBaseType*  selectivity() const {
    return distribution_map
      (std::mem_fun_ref(cyclic ? &Histogram::vector_selectivity : &Histogram::relative_selectivity),
       selectivity_scale);
  }

private:
  
  MapBaseType* coarse_map() const {  return new MapAdapterType(new MapType(maxvals));  }

public:
  
  const bool has_distribution() const { return measure_distribution;  }
  
private:
  template <class HistoFn> 
  MapBaseType*  distribution_map
  (const HistoFn fn, const ScaleType& scale=ScaleType()) const {
    assert(measure_distribution);
    unsigned int orig_undefined_values=Histogram::undefined_values();
    MapMatrix* newmap = new MapMatrix(maxvals.nrows(),maxvals.ncols());
    undefined_values_start(Histogram::undefined_values());
    std::transform(CMSEQ(maxvals_distribution),MBEGIN(*newmap),fn);
    undefined_values_end(Histogram::undefined_values());
    Histogram::undefined_values_reset(orig_undefined_values);
    return new MapAdapterType(new MapType(*newmap), scale);
  }

  bool measure_distribution;
  bool weighted_average;
  bool cyclic;
  ScaleType selectivity_scale;

  MapMatrix   maxvals;
  HistoMatrix maxvals_distribution;
};




template <class MapType, class MapBaseType, class ValuePointer>
class StimulusParameterMapsForRegion {
  typedef typename MapType::size_type Subscript;
  typedef StimulusParameterMap_Combined<MapType, MapBaseType, ValuePointer>   SPM;
  typedef StimulusParameterMap_Combined<MapType, MapBaseType, ValuePointer>   SPMtoAllocate;
  typedef std::vector<SPM*> SPMs;
  
public:
  typedef typename SPM::ScaleType ScaleType;
  
  StimulusParameterMapsForRegion(NeuralRegionManager* regionmanager)
    : rm(regionmanager),
      max_activity(rm->region()->nrows(),rm->region()->ncols())
    {  mat::set(max_activity,0.0);  } /* Just in case. */

  void create_spm(const string& name_, ValuePointer& valueptr,
                  int num_bins, bool measure_distribution=true, 
                  bool weighted_average=false, bool cyclic=false,
                  const ScaleType& selectivity_scale=ScaleType()) {
    /* Hack: Passes the num_bins as a global to the Histogram class,
       which can't accept any argument at construction time if is to
       work with a Matrix. */
    Histo::OneDBinList<>::num_bins_default = num_bins;
    
    spms.push_back(new SPMtoAllocate(rm->region()->const_activity(),
                                     name_, valueptr, measure_distribution,
                                     weighted_average, cyclic, selectivity_scale));
  }
  
  /* For each unit in the region, if the current activation is the
     highest seen, enter the current stimulus parameters as the
     preferred value. */
  void update() {
    const NeuralRegion* reg = rm->region();
    
    for   (int r=0; r<reg->nrows(); r++)
      for (int c=0; c<reg->ncols(); c++)
        update(r,c);
  }

  string register_maps() const {
    string warnings;
    for (typename SPMs::const_iterator spm=spms.begin(); spm!=spms.end(); spm++) {
      const SPM* s = *spm;
      const string map_name = s->name()+"Preference";
      rm->map_add(map_name,s->map());
      if (s->undefined_values())
        warnings += " " + map_name + ": " + String::stringrep(s->undefined_values());
      if (s->has_distribution()) {
        const string select_name = s->name()+"Selectivity";
        rm->map_add(select_name,s->selectivity());
        if (s->undefined_values())
          warnings += " " + select_name + ": " + String::stringrep(s->undefined_values());
      }
    }
    return (warnings=="" ? "" : "Undefined values:" + warnings);
  }

private:

  inline void update(const Subscript r, const Subscript c) {
    const NeuralRegion::Activity newval = rm->region()->activity(r,c);
    NeuralRegion::Activity oldval = max_activity[r][c];
    const bool current_is_max_seen = (newval > oldval);

    if (current_is_max_seen)
      max_activity[r][c] = newval;
    
    for (typename SPMs::const_iterator spm=spms.begin(); spm!=spms.end(); spm++) {
      if (current_is_max_seen)        (*spm)->mark_current_value_as_max(r,c);
      if ((*spm)->has_distribution()) (*spm)->update_distribution(r,c,newval);
    }
  }

  NeuralRegionManager* rm;
  SPMs spms;
  NeuralRegion::ActivityMatrix max_activity;
};



#endif /* __STIMULUSPARAMETERMAP_H__ */

---