---

worldviews.h

Go to the documentation of this file.

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

#include "genericalgs.h"
#include "stringparser.h"
#include "retinalobjs.h"
#include "ipc.h"
#include "cmdparam.h"
#include "globals.h"

/******************************************************************************/
/* DistributedValueGeneratorFactory class                                     */
/******************************************************************************/


template<class RandomGen>
struct synchronized_distribution {
double operator() ( double mean, double radius )
{
  static double value;
  int  youngest_pe    = ipc_num_processes()-1;
  bool am_youngest_pe = (ipc_my_process() == youngest_pe);
    
  if (am_youngest_pe) value = RandomGen()(mean,radius);
  ipc_barrier();

  if (!am_youngest_pe) ipc_get(&value, 1, youngest_pe);
  const double valcopy=value;
  ipc_barrier();
  
  return valcopy;
}
};

template<class T,
         class urf=synchronized_distribution<Distributions::uniform>,
         class nrf=synchronized_distribution<Distributions::normal> >
class DistributedValueGeneratorFactory
  : public ValueGeneratorFactory<T,urf,nrf> { };



/******************************************************************************/
/* WorldViews class                                                           */
/*******************************************************************************/


class WorldViews : public ValueGen {
public:
  virtual ~WorldViews() { }

  virtual void uninit()  {  Generic::delete_contents(contents);  }

  virtual void define( const string& regionname, const double height, const double width);

  virtual void generate_default_contents();

  virtual void reset()  {  reset(random_seed);  }

  virtual void reset(long int seed) {
    std::for_each(ISEQ(contents),std::mem_fun(&Retinal_Obj::reset));
    shuffled_rand_reset(seed);
  }

  virtual bool next();

  bool has_been_defined() const {  return !contents.empty();  }
  bool create_object(StringArgs arglist, const string& name,
                     WorldViews& reference_contents, bool link_eyes=true);
  void remove_object(const string& parent="", const string& name="");
  void print_object ( const string& parent="", const string& name="") const;
  bool is_empty() const {  return !std::count_if(ISEQ(contents),std::not1(std::mem_fun(&Retinal_Composite::is_empty)));  }


  typedef Retinal_Composite*          value_type;
  typedef std::vector<value_type>     vector_type;
  typedef vector_type::iterator       iterator;
  typedef vector_type::const_iterator const_iterator;
  iterator       begin()       {  return contents.begin();  }
  iterator       end()         {  return contents.end();    }
  const_iterator begin() const {  return contents.begin();  }
  const_iterator end()   const {  return contents.end();    } 
  
  const Retinal_Obj* view(int eye) const {
    return contents[eye];
  }
  
  
  virtual bool   is_active(int objnumber, int eye) const {
    return (objnumber>= int(contents[eye]->size()) ? false :
            ((*contents[eye])[objnumber]->get_active()));
  }

  virtual double angle_of_object(int objnumber, int eye) const {
    if (objnumber< int(contents[eye]->size()))
      return contents[eye][objnumber].angle();
    else {
      const string name = contents[eye]->name();
      ipc_notify(IPC_ONE,IPC_WARNING,"Not enough objects in %s to retrieve object %d",name.c_str(),objnumber);
      return 0;
    }
  }

  virtual double angle_of_object_at_location(int i, int j, int eye) const
    {  return contents[eye]->mostactive(i+0.5,j+0.5).angle();  }

  
  static void set_current_eye(int eye)
    {  current_eye = eye; }

  static void register_params_and_commands( void );

  static cmdstat set_distribution(int dist, bool& changed);
    

private:
  typedef ValueGenerator<Retinal_Object::Variable> VGen;
  typedef ValueGenerator_Random<Retinal_Object::Variable,synchronized_distribution<Distributions::uniform> >  UR_VGen;
  
  vector_type contents;

  /* Static parameter */
  static int  random_seed;

  /* Static defaults for retinal objects */
  static string default_command;
  static string default_subcommand;

  static string default_type;
  static string default_angle;
  static string default_position;
  static string default_scale;
  static string default_offset;
  static string default_xsigma;
  static string default_ysigma;
  static string default_phase;
  static string default_size_scale;
  static string default_image_filename;
  static string default_clone_name;

  static string imagepath;

  static int    distribution;
  static double input_offset;
  static int    inputs_pereye;
  static double xsigma;
  static double ysigma;
  static int    current_eye;
  static double scale_input;
  static Tristate input_log;
  static int    input_accum_type;
  static double input_separation_max;
  static Tristate input_separation_max_enforce;
  static double input_separation_min;
  static Tristate input_separation_min_enforce;
};

---