---

neuralregionmanager.h

Go to the documentation of this file.

#ifndef __NEURALREGIONMANAGER_H__
#define __NEURALREGIONMANAGER_H__

#include "neuralregion.h"
#include "matrixadapter.h"
#include "plotspecification.h"
#include "parametermap.h"
#include "ppm_draw.h"



class NeuralRegionManager {
  typedef string bStr;
  typedef const string cStr;
  typedef InternalNeuralRegion::Weights Weights;
  typedef Scale::Linear<double> ScaleType;
  
public:
  NeuralRegionManager(NeuralRegion* region, ParamMap& params_,
                      bool owns_params=true, const bool register_maps=true)
    : r(region), params(&params_,owns_params) {
    if (register_maps) {
      const NeuralRegion::Table& table = r->table();
      for (NeuralRegion::Table::const_iterator i=table.begin(); i!=table.end(); i++) {
        const string name = i->first;
        define_plot("Activity", name, name);    
      }
      region->table_set("Activity", new NeuralRegion::ActivityAdapter(region->const_activity()));
      define_plot("Activity", "Activity", "Activity");

      region->table_set("Backprojection", new NeuralRegion::ActivityAdapter(region->backprojection()));
      define_plot("Backprojection", "Backprojection", "Backprojection");

      region->table_set("Residual", new NeuralRegion::ActivityAdapter(region->residual_activity()));
      define_plot("Residual", "Residual", "Residual");
    }

    /* Declare useful parameters.  Should probably also mark them read-only. */
    ParameterMap<>& p = *dynamic_cast< ParameterMap<>* >(params.valueptr());
    p.set_local("plastic", (region->is_plastic()?  True : False ));
    p.set_local("internal",(region->is_internal()? True : False ));
  }
  
  virtual ~NeuralRegionManager() {  }

  void map_add(const string& name, NeuralRegion::MapBaseType* map) {
    assert (int(map->nrows())==int(r->const_activity().nrows()));
    assert (int(map->ncols())==int(r->const_activity().ncols()));
    r->table_set(name,map);
  }

  typedef Plot::PlotSpecification<NeuralRegion::MapBaseType,bStr,Scale::Linear<>,
                                  NeuralRegion::Table> PlotSpec;
  typedef std::vector<PlotSpec*>                     PlotSpecList;
  typedef PointerMap<PlotSpecList>              PlotSpecListTable;

  virtual PlotSpecList::const_iterator plotspeclist_begin(const string& group) const {
    const PlotSpecList* p=plotspecs.getptr(group);
    return (p? plotspecs.getptr(group)->begin() : PlotSpecList::const_iterator());
  }

  virtual PlotSpecList::const_iterator plotspeclist_end(const string& group) const {
    const PlotSpecList* p=plotspecs.getptr(group);
    return (p? plotspecs.getptr(group)->end() : PlotSpecList::const_iterator());
  }

  inline PlotSpec* define_plot(const string& group, cStr& plotname,
                               cStr& strength, cStr& color="", cStr& confidence="")
    {  return define_plot(group,newPlotSpec(plotname,strength,color,confidence));  }


  inline bool add_maps_for_unit(PlotSpec::MatrixTable& maptable,
                                const PlotSpec& spec,
                                const int ui, const int uj) const 
    {  return add_maps_for_unit(maptable,spec.name(),spec.name(),spec,ui,uj);  }
    
  inline bool add_maps_for_unit(PlotSpec::MatrixTable& maptable,
                                const string& weightname,
                                const string& mapname,
                                const PlotSpec& spec,
                                const int ui, const int uj) const {
    
    const InternalNeuralRegion* p = internalregion();  assert(p);

    /* Error checking */
    if (ui>=p->nrows() || uj>=p->ncols()) {
      message(Msg::Error,"Unit (" +
              String::stringrep(ui) + "," +
              String::stringrep(uj) + ") is out of range of region " + p->name() );
      return false;
    }

    /* Add a map for the specified weights.  Currently does not supply
       any "reference count" arguments to the weight_scale command,
       since those are tough to determine in general. */
    const Scale::Linear<double> scale = weight_scale(spec, p->weights(weightname,ui,uj));
    maptable.set(mapname,p->weights(weightname,ui,uj).as_map(*(spec.reference_mapptr()),scale));

    return true;
  }


  Scale::Linear<double> weight_scale(const PlotSpec& spec, const Weights& weights, int reference_count=-1) const {
    double factor=1.0;
    double offset=0.0;
    
    const WtScale::Type type       = WtScale::Type(spec.lookup_param("ppm_weight_scale_type",       int(WtScale::Relative)));
    const double        fixed_weight_multiplier  = spec.lookup_param("ppm_weight_fixed_multiplier", 1.0);
    const double        fixed_weight_offset      = spec.lookup_param("ppm_weight_fixed_offset",     1.0);
    const double        threshold                = spec.lookup_param("ppm_weight_threshold",        1.0);
    
    /* Simplest case */
    if (type == WtScale::Fixed) {
      factor = fixed_weight_multiplier;
      offset = fixed_weight_offset;
      }
    else {
      /* Compute scaling from max value, min value, number of connections, and/or num active */

      /* Initialize counts and totals to minimum or maximum possible, as appropriate */
      double max    = 0.0;
      double min    = 1.0;
      int    count  =   0;
      int    active =   0;

      typedef Weights::Matrix   Matrix;
      typedef Weights::Bounds   Bounds;
      typedef Matrix::size_type Subscript;
      
      const Matrix&   A  = weights.matrix();
      const Bounds&   b  = weights.bounds();
      const Subscript ro = b.aarectangle().corners().xl;
      const Subscript co = b.aarectangle().corners().yl;
      
      for   (Subscript rr=0; rr<A.nrows(); rr++)
        for (Subscript cc=0; cc<A.ncols(); cc++)
          if (b.inside(rr+ro,cc+co)) {
            count++;
            const double value = mat::elem(A,rr,cc);
            if (value > threshold) {
              active++;
              if (value > max) max = value;
              if (value < min) min = value;
            }
          }
          
      /* Override actual count if appropriate */
      if (reference_count>0) count = reference_count;

      switch (type) {
      case WtScale::Relative:     factor = ((max-min)>0 ? 1.0/(max-min) : 1.0);
                                  offset = -min;                    break;
      case WtScale::PeakRelative: factor = (max>0 ? 1.0/max : 1.0); break;
      case WtScale::Active:       factor = 1.0*active;              break; 
      case WtScale::Count:        factor = 1.0*count;               break;
      default:
        /* It would be nice to limit the number of these messages generated... */
        message(Msg::Error,"Unknown WtScale type: " + String::stringrep(int(type)));
        factor = 0; break;
      }
    }
    
    //cout << "plot: (" << factor << "," << offset << ")" << endl;
    return ScaleType(factor,offset);
  }

  
  inline NeuralRegion* region() {  return r;  }

  inline const NeuralRegion* region() const {  return r;  }

  inline InternalNeuralRegion* internalregion()
    {  return dynamic_cast<InternalNeuralRegion*>(r);  }

  inline const InternalNeuralRegion* internalregion() const
    {  return dynamic_cast<const InternalNeuralRegion*>(r);  }


  PlotSpec* add_input(const string& name,
                      NeuralRegionManager& upstream_manager,
                      InternalNeuralRegion::WeightFunction& fn,
                      NeuralRegion::Length size_scale=1.0) {
    assert (region());
    assert (internalregion());
    internalregion()->add_input(name,*(upstream_manager.region()), fn, size_scale);
    PlotSpec* p=upstream_manager.newPlotSpec(name,name);
    assert (p);
    define_plot("Weights",p);
    return p;
  }

  int default_ui() const {  return std::max(0,region()->nrows()/2-1);  }
  int default_uj() const {  return std::max(0,region()->ncols()/2-1);  }

  static void message(Msg::MessageLevel m, const string& s)
    {  PlotSpec::message(m,s);  }

  ParamMap&       param_map()       {  return *(params.valueptr());  }
  const ParamMap& param_map() const {  return *params;               }
  
private:  

  PlotSpec* newPlotSpec(cStr& plotname, cStr& strength, cStr& color="", cStr& confidence="") const {
    // Can the dynamic_cast be eliminated?
    /* Specific type is needed here for set_local; requires that the
       call originally used a ParameterMap<>. */
    ParameterMap<>* p = dynamic_cast< ParameterMap<>* >(params.valueptr());
    assert (p);
    return new PlotSpec(r->name(),r->table(),plotname,*p,strength,color,confidence);
  }
    
  PlotSpec* newPlotSpec(PlotSpec& o, cStr& plotname, cStr& strength, cStr& color="", cStr& confidence="") const {
    // Can the dynamic_cast be eliminated?
    ParameterMap<>* p= dynamic_cast<ParameterMap<>*>(&(o.param_map()));
    assert (p);
    return new PlotSpec(r->name(),r->table(),plotname,*p,strength,color,confidence);
  }

  inline PlotSpecList& plotspec_group(const string& name) {
    PlotSpecList* p=plotspecs.getptr(name);
    if (!p) {
      p=new PlotSpecList;
      plotspecs.set(name,p);
    }
    return *p;
  }

  inline PlotSpec* define_plot(const string& group,PlotSpec* spec) {
    Generic::insert_named(plotspec_group(group), spec->name(), spec);
    return spec;
  }

  PlotSpecListTable plotspecs;

  NeuralRegion* r;

  OwningPointer<ParamMap> params;
};



#endif /* __NEURALREGIONMANAGER_H__ */

---