---

neuralregionmap.h

Go to the documentation of this file.

#ifndef __NEURALREGIONMAP_H__
#define __NEURALREGIONMAP_H__

#include <string>
using std::string;

#include "pointermap.h"
#include "neuralregionmanager.h"
#include "parammap.h"
#include "cmdparam.h"


class NeuralRegionMap : public PointerMap<NeuralRegionManager> {
public:
  NeuralRegionMap(const string& name, ParamMap& parentparams)
    : params(parentparams.new_child(name),true) {  define_globals();  }
  virtual ~NeuralRegionMap() { }

  typedef NeuralRegionManager         RegionManager;
  
  void activate(bool learn, bool settle, bool activatefn, bool verbose=false) const;

  const bool plot_write_unit(const ParamMap& argparams, const NeuralRegionManager* rm, 
                             const int ui, const int uj) const;

  const bool measure_stimulus_map(StringArgs& arglist, ParameterMap<>& argparams);
  
  virtual void register_params_and_commands( void );

  static void message(Msg::MessageLevel m, const string& s, const bool terminate=True)
    {  NeuralRegionManager::PlotSpec::message(m,s,terminate);  }

  NeuralRegionManager* new_manager(NeuralRegion& region, ParamMap* existing_params=0) {
    erase(region.name());
    NeuralRegionManager* nm = new
      NeuralRegionManager(&region,(existing_params? *existing_params
                                   : *params->new_child(region.name())),
                          (existing_params==0));
    set(region.name(),nm);
    return nm;
  }

  bool restore_state(const ParamMap& argparams, const int iteration, const string& filenamebase);

  double size_connection_bytes()   const        {  return Generic::accumulate(begin(),end(),0.0,&size_bytes);  }
  double size_unique_connections() const        {  return Generic::accumulate(begin(),end(),0.0,&size_conns);  }

private:
  static double size_bytes(const value_type& v) {  return v.second->region()->size_connection_bytes();         }
  static double size_conns(const value_type& v) {  return v.second->region()->size_unique_connections();       }

  void ppm_init_hook( void );
  int  ppm_post_write_hook(const char* filename ) const;


  static int rm_nrows(const value_type& p)      {  return p.second->region()->nrows();  }
  static int rm_ncols(const value_type& p)      {  return p.second->region()->ncols();  }
  static int max_int( const int a, const int b) {  return std::max(a,b);  }
  int min_of_max_dimensions() const {
    int max_width  = Generic::accumulate(begin(), end(), 0, &rm_nrows, &max_int);
    int max_height = Generic::accumulate(begin(), end(), 0, &rm_ncols, &max_int);
    return std::min(max_height,max_width);
  }


  
  typedef std::vector<RegionManager*> RegionManagerList;
  
  RegionManagerList retrieve_matching_regions(const string& region_names_string,
                                              Tristate plastic=Uninitialized,
                                              Tristate internal=Uninitialized) const;

  RegionManagerList retrieve_matching_regions(const ParamMap& params,
                                              const string& name_of_regionlist_param="regions",
                                              const bool uselimits=true) const;
  
  typedef NeuralRegionManager::PlotSpecList PlotSpecList;
  const PlotSpecList retrieve_matching_plots
  (const PlotSpecList::const_iterator& plotsbegin,
   const PlotSpecList::const_iterator& plotsend,
   const string& names_string) const;
  
  const bool plot_write_unit_range
  (const ParamMap& argparams, const NeuralRegionManager* rm, const string& plotitem, 
   int ui_start, int uj_start, int ui_end, int uj_end, int step) const;

  const NeuralRegionManager* lookup_internal_region(const string& name) const;
  const NeuralRegionManager* lookup_region(         const string& name) const;
  
  typedef Plot::RGBPixel<> Color;
  
  Color lookup_param(const ParamMap& parammap, const char* basename, const Color& default_val) const
    {  return lookup_color(parammap,basename,default_val);  }

  typedef NeuralRegionManager::PlotSpec::SubRegion SpecRegion;

  SpecRegion max_subregion() const {
    double maxheight=0;
    double maxwidth=0;
    for (const_iterator ri=begin(); ri!=end(); ri++) {
      const data_type region = (*ri).second;
      SpecRegion specified = lookup_subregion(region->param_map(),SpecRegion());
      const double height = (!specified.isinfinite()? specified.height() : region->region()->nrows());
      const double width  = (!specified.isinfinite()? specified.width()  : region->region()->ncols());
      if (height > maxheight) maxheight = height;
      if (width  > maxwidth)  maxwidth  = width;
    }

    return SpecRegion(0,0,maxwidth,maxheight);
  }


  const string overriding_colorspec(const NeuralRegionManager* rm, int ui, int uj, const string colorspec) const;


  /* Define values that are sometimes needed in filenames; call with
     no arguments to mark them with clearly invalid values when such
     information is unavailable. */
  static void define_globals(const RegionManager* rm=0, const int ui=-1, const int uj=-1, const string& plotname=string()) {
    const NeuralRegion* r = (rm? rm->region() : 0);
    current_region  = (r?  r->name()    : string());
    current_width   = (r?  r->nrows()   : -1);
    current_height  = (r?  r->ncols()   : -1);
    current_ui      = ui;
    current_uj      = uj;
    current_plot    = plotname;
  }
  
  
  static int current_width, current_height, current_ui, current_uj;
  static string current_region, current_plot;


  typedef std::vector<Plot::AARImage<>*>   ImagePList;
  typedef std::vector<ImagePList*>         ImagePListList;

  const bool add_maps_for_unit(NeuralRegionManager::PlotSpec::MatrixTable& tempmaps,
                               const NeuralRegionManager& rm,
                               const NeuralRegionManager::PlotSpec& plotspec,
                               const int ui, const int uj) const;
  
  bool unit_bitmap(const double master_scale, ImagePList& imagelist,
                   const NeuralRegionManager::PlotSpec& plotspec,
                   const NeuralRegionManager::PlotSpec::MatrixTable* tempmaps,
                   const InternalNeuralRegion::WeightBounds& bounds,
                   const Color& pagecolor,
                   bool draw_outline=true, int  outline_width=1,
                   bool situate=true, bool mainplot=true,
                   bool separate_plots=false, bool combined_plots=false,
                   const string& filebase="", bool histograms=true,
                   int border_width=-1, bool fill_bg=false,
                   const string& overriding_colorspec="") const;
  
  const bool ppmgrid_write(const string& filebase,
                           const ImagePListList& imagelists, int interior_border,
                           const Color& pagecolor, bool column_major=true) const;
  
  const bool gnuplot_image(const ParamMap& argparams,
                           NeuralRegionManager::PlotSpec& plotspec,
                           const string& filebase,                         
                           const NeuralRegionManager::PlotSpec::MatrixTable* tempmaps,
                           const SpecRegion& subregion=SpecRegion()) const;

  bool unit_gnuplot(const ParamMap& argparams,
                    NeuralRegionManager::PlotSpec& plotspec,
                    const string& filebase,                        
                    const NeuralRegionManager::PlotSpec::MatrixTable* tempmaps,
                    const InternalNeuralRegion::WeightBounds& bounds,
                    bool situate) const;
  
  const string filenamebase(const string& plotgroup,
                            const string& suppliedformat) const;

  OwningPointer<ParamMap> params;

  template<class LoopContainer, class SPMRContainer>
  class measure_stimulus_map_iteration;

  bool define_plotgroup(const string plotgroup, const string filename_format="");
  CMDOBJ_DECLARE(NeuralRegionMap,define_plot);
  CMDOBJ_DECLARE(NeuralRegionMap,measure_stimulus_map);
  CMDOBJ_DECLARE(NeuralRegionMap,kill_connections);
  CMDOBJ_DECLARE(NeuralRegionMap,child_set);
  CMDOBJ_DECLARE(NeuralRegionMap,map_statistics);
  CMDOBJ_DECLARE(NeuralRegionMap,plot);
  CMDOBJ_DECLARE(NeuralRegionMap,plot_unit);
  CMDOBJ_DECLARE(NeuralRegionMap,plot_unit_range);
  CMDOBJ_DECLARE(NeuralRegionMap,save_snapshot);
  CMDOBJ_DECLARE(NeuralRegionMap,backproject);
#ifdef OBJ_LISSOM
  CMDOBJ_DECLARE(NeuralRegionMap,resp_to_residual);
  CMDOBJ_DECLARE(NeuralRegionMap,train_obj_weights);
  CMDOBJ_DECLARE(NeuralRegionMap,randomize_lat_wts);
#endif /* OBJ_LISSOM */
  
  const string pe_extension () const;
  static int plot_pe;

  SETFNOBJ_DECLARE2(NeuralRegionMap,color_param_setfn2);
};
 


#endif /* __NEURALREGIONMAP_H__ */

---