---

retinalobjs.h

Go to the documentation of this file.

#ifndef __RETINALOBJS_H__
#define __RETINALOBJS_H__

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

#include "matrix.h"

#include "genericalgs.h"
#include "valuegen.h"
#include "valuegenmap.h"
#include "pnm_io.h"
#include "boundingbox.h"
#include "robj.h"
#include "tristate.h"
#include "mathconstants.h"


/******************************************************************************/
/*  Global defines                                                            */
/******************************************************************************/

#ifndef RADIANS_TO_DEGREES
#define RADIANS_TO_DEGREES(theta) (180.0*(theta)/(Math::pi))
#endif

#ifndef CONSTRAIN_ANGLE
#define CONSTRAIN_ANGLE(angle)                                    \
  (((angle)>=0) ?                                                  \
   fmod( (angle),                                  (Math::pi) ) :   \
   fmod( (angle) + 2*(Math::pi)*(-1*floor((angle)/((Math::pi)*2))+1),  (Math::pi))     )
#endif



/******************************************************************************/
/* Retinal_Object class                                                       */
/******************************************************************************/
class Retinal_Composite;

class Retinal_Object : public Retinal_Obj {
protected:
  typedef AARBoundingBox<Coordinate> BBox;

public:
  typedef double Variable;
  typedef ValueGenerator<Variable> VarGen;
  typedef ValueGeneratorMap<Variable> VarMap;

  Retinal_Object(const string& name_val, const VarMap& init_vars=VarMap())
    : bounding_box(), active(true), name_(name_val),
      default_act(0.0), parentptr(0) {
    vars.merge(init_vars);
    set_var_default("scale",1.0);
  }

  Retinal_Object(const Retinal_Object& b) /* Copy constructor */
    : Retinal_Obj(b), bounding_box(b.bounding_box), vars(b.vars),  
      active(b.active), name_(b.name_),
      default_act(b.default_act), parentptr(0) { }

  virtual ~Retinal_Object() { }
  
  
  virtual bool next()  {  return vars.next();  }
  virtual void reset() {  vars.reset();  }
  virtual bool update() const  {
    /* Cache the result of sub-computations */    
    theta       = get_var("theta");
    cx          = get_var("cx");
    cy          = get_var("cy");
    scale       = get_var("scale");
    offset      = get_var("offset");
    default_act = default_activ();
    
    return true;
  }

  virtual Activity activation(Coordinate x, Coordinate y) const {
    return offset + scale *
      ((!active || !bounding_box.inside(x,y)) ? default_act : activ(x,y)); 
  }



  virtual string stringrep() const;
  
  virtual Retinal_Object* clone() const =0;

  virtual void relink (const Retinal_Object* master)
    {  if (master) vars.relink(&(master->vars));  }

  bool get_active() const { return active; }
  void set_active(bool whether_active) {  active=whether_active;  }

  const string& name()     const                {  return name_;   }
  const string& get_name() const                {  return name_;   } // Deprecated
  void          set_name(const string& newname) {  name_=newname;  }

  const Variable get_var(const string& varname) const {  return vars.get(varname);  }

  Variable* get_varptr(const string& varname) {  return vars.getptr(varname);  }

  string vargen_stringrep(const string& varname) const {
    VarGen* v = vars.getvalgenptr(varname);
    return v? v->stringrep() : "";
  }

  virtual const Retinal_Composite* get_parent() const {  return parentptr;  }

  virtual void                     set_parent(const Retinal_Composite* _parentptr)
    {  parentptr=_parentptr;  }


  virtual Angle angle() const {  return get_var("theta");  }

  virtual Retinal_Object* find(const string& othername)
    {  return (othername=="" || othername==name_ ? this : 0);  }

  void merge_vars(const VarMap& init_vars) {  vars.merge(init_vars);  }

  virtual bool inside(Coordinate x, Coordinate y) const
    {  return bounding_box.inside(x,y);  }


  virtual Activity default_activation() const 
    {  return get_var("offset") + get_var("scale") * default_act;  }

  mutable BBox bounding_box;


protected:
  friend class DefaultActivityAccumulator;

  const void set_var_default(const string& varname, Variable val)
    {  vars.set_default(varname,val);  }

private:
  VarMap vars; 
  bool active;
  string name_;
  mutable Variable default_act,theta,cx,cy,scale,offset;
  const Retinal_Composite* parentptr;

  virtual Activity activ(Coordinate x, Coordinate y) const =0;

  virtual Activity default_activ() const { return 0.0; }
  //virtual Activity default_activ() const { return 0.5; } /* To debug non-Composite bounding boxes */

  void operator= (const Retinal_Object &) { abort(); } 
};




#ifndef NO_VALGEN_STRINGS

class RetinalObjectStringArgs {
public:
  typedef std::map<string,string> DefaultsMap;
  typedef std::vector<string> ParamList;

  RetinalObjectStringArgs( StringArgs arglist,
                           VGenFactory<Retinal_Object::Variable>& vgf,
                           DefaultsMap dm=DefaultsMap(),
                           Retinal_Object* m=0)
    : args(arglist), defaults(dm), master(m), f(vgf), parser(args.p) { }
  
  Retinal_Object::VarMap vars(const ParamList& params);


  
  string get_default(const string& name) const {
    std::map<string,string>::const_iterator existing = defaults.find(name);
    return (existing ==  defaults.end() ? string() : (*existing).second);
  }

  void set_default(const string& name, const string& value)
    {  defaults[name]=value;  }

  void error(const string& s) const {  parser.error(s);  }

  const string parsed_get_default(const string& name) const
    {  return parser.parse(get_default(name));  }

  const string parsed_next(const string& name)
    {  return parser.parse(args.next(get_default(name))); }

  Retinal_Object::Variable& parse(const string& s, Retinal_Object::Variable& x) const
    {  return parser.parse(s,x);  }

  
private:
  inline void set_linked(const string& name, const string& value,
                         Retinal_Object::VarMap& vars) {
    vars.set(name, f.create(StringArgs(parser,parser.parse(value)),
                            (!master ? 0 : master->get_varptr(name)) ) );
  }

  friend class RetinalObjectFactory; /* For new_Retinal_Clone */
  
  StringArgs args;
  DefaultsMap defaults;
  Retinal_Object* master;
  VGenFactory<Retinal_Object::Variable>& f;
  const StringParser& parser;
};
#endif /* NO_VALGEN_STRINGS */



/******************************************************************************/
/* Retinal_Composite classes                                                  */
/******************************************************************************/

class Retinal_Composite : public Retinal_Object {
public:
  enum AccumulationType { Max, Min, Add, OneHot, Replace };

  Retinal_Composite( const string& name_val, AccumulationType accum_type_i=Max,
                     const VarMap& init_vars=VarMap())
    : Retinal_Object(name_val,init_vars),
      accum_type(accum_type_i), dominant_child(0) {
    set_var_default("size_scale",1.0);
  }
    
#ifndef NO_VALGEN_STRINGS
  RetinalObjectStringArgs::ParamList paramlist();
  Retinal_Composite( const string& name_val, RetinalObjectStringArgs& sa)
    : Retinal_Object(name_val), dominant_child(0) {
    sa.set_default("size_scale","1.0"); /* Special default */    
    merge_vars(sa.vars(paramlist()));
    accum_type = Retinal_Composite::AccumulationType(get_var("accum_type"));
  }
#endif

  Retinal_Composite(const Retinal_Composite& b) /* Copy constructor */
    : Retinal_Object(b), children(b.children), accum_type(b.accum_type),
      dominant_child(0) {
    std::transform(ISEQ(children),children.begin(),std::mem_fun(&Retinal_Object::clone));
  }
  
  virtual ~Retinal_Composite() {  remove_all();  };


  virtual bool next();
  virtual void reset();
  virtual bool update() const;




  virtual Coordinate nominal_height() const {
    const Variable size_scale = get_var("size_scale");
    return (get_parent()? get_parent()->nominal_height()/size_scale : 0);
  }
  
  virtual Coordinate nominal_width()  const {
    const Variable size_scale = get_var("size_scale");
    return (get_parent()? get_parent()->nominal_width()/size_scale : 0);
  }
  
  virtual void   add(Retinal_Object* obj) {
    children.push_back(obj);
    if (obj) obj->set_parent(this);
  }

  virtual bool   is_empty() const {  return (children.empty()); }

  virtual Retinal_Object* find(const string& othername) {
    if (Retinal_Object::find(othername)) return this;
    for (iterator i=children.begin(); i!=children.end(); i++) {
      Retinal_Object* child_ptr = (*i)->find(othername);
      if (child_ptr) return child_ptr;
    }
    return 0;
  }

  virtual void   remove(const string& childname="") {
    for (iterator i=children.begin(); i!=children.end(); i++)
      if (childname=="" || ((*i)->name() == childname)) {
        if (dominant_child==*i) dominant_child=0;
        delete *i;          /* Remove object pointed to */
        children.erase(i);  /* Compact remaining objects */
        i--;                /* Adjust iterator to account for the missing elem */
      }
  }

  virtual void   remove_all() {  Generic::delete_contents(children);  dominant_child=0; }

  virtual const Retinal_Object& mostactive(Coordinate x, Coordinate y) const;


  Retinal_Object* operator[] (unsigned int idx) const { return children[idx]; }
  size_t size() const { return children.size(); }

  
  virtual string stringrep() const;
  virtual Retinal_Object* clone() const
    { return new Retinal_Composite(*this); };
  bool inside(Coordinate x, Coordinate y) const;
  
protected:
  typedef std::vector<Retinal_Object*>      ChildrenContainer;
  typedef ChildrenContainer::iterator       iterator;
  typedef ChildrenContainer::const_iterator const_iterator;
  ChildrenContainer children;

  AccumulationType accum_type;
  Activity accum_base() const;
  mutable Variable cosmt,sinmt,cx,cy,div_size;
  mutable Retinal_Object* dominant_child;

private:
  virtual Activity activ(Coordinate x, Coordinate y) const;
  virtual Activity default_activ() const;
};



class Retinal_ManagedComposite : public Retinal_Composite {
public:
  Retinal_ManagedComposite
  ( const string& name_val,
    Tristate* min_distance_enforce, double* min_distance,
    Tristate* max_distance_enforce, double* max_distance,
    AccumulationType accum_type_i=Max, const VarMap& init_vars=VarMap())
    : Retinal_Composite(name_val,accum_type_i,init_vars),
      min_dist_enforce(min_distance_enforce),  min_dist(min_distance),
      max_dist_enforce(max_distance_enforce),  max_dist(max_distance) { }

  Retinal_ManagedComposite(const Retinal_ManagedComposite& b)
    : Retinal_Composite(b), /* Copy constructor */
      min_dist_enforce(b.min_dist_enforce),    min_dist(b.min_dist),
      max_dist_enforce(b.max_dist_enforce),    max_dist(b.max_dist) { }

  virtual bool next();

  virtual Retinal_Object* clone() const
    { return new Retinal_ManagedComposite(*this); };
  
private:
  Tristate* min_dist_enforce; double* min_dist;
  Tristate* max_dist_enforce; double* max_dist;
  
  bool distance_valid(const Retinal_Object& obj1, const Retinal_Object& obj2);
  bool accumulate_managed_next(bool val, Retinal_Object* r);
};



class Retinal_AnchoredManagedComposite : public Retinal_ManagedComposite {
public:
  Retinal_AnchoredManagedComposite
  ( const string& name_val,
    Tristate* min_distance_enforce, double* min_distance,
    Tristate* max_distance_enforce, double* max_distance,
    AccumulationType accum_type_i=Add, const VarMap& init_vars=VarMap(),
    Coordinate height_=0, Coordinate width_=0)
    : Retinal_ManagedComposite(name_val, 
                               min_distance_enforce,  min_distance,
                               max_distance_enforce,  max_distance,
                               accum_type_i, init_vars),
    height(height_), width(width_) { }
  
  virtual string stringrep() const;

  virtual Retinal_Object* clone() const
    { return new Retinal_AnchoredManagedComposite(*this); };
  
  virtual Angle angle() const {
    /* Returns angle of last child, since own angle is always zero */
    return ( (children.begin()==children.end()) ? 0 :
             children.back()->angle() );
  }

  virtual Coordinate nominal_height() const {  return height;  }
  virtual Coordinate nominal_width()  const {  return width;   }

  void resize(const Coordinate height_, const Coordinate width_)
    {  height=height_; width=width_;  }
  
private:
  virtual Activity activ(Coordinate x, Coordinate y) const;
  Coordinate height;
  Coordinate width;
};



/******************************************************************************/
/* Derived Retinal_Object classes                                             */
/******************************************************************************/

template<class RandomGen=Distributions::uniform>
class Retinal_RandomNoise : public Retinal_Object {
public:
  Retinal_RandomNoise( const string& name_val, const VarMap& init_vars=VarMap())
    : Retinal_Object(name_val, init_vars)  { }

#ifndef NO_VALGEN_STRINGS  
  RetinalObjectStringArgs::ParamList paramlist() {
    RetinalObjectStringArgs::ParamList p;
    p.push_back("scale");
    p.push_back("offset");
    return p;
  }
  Retinal_RandomNoise( const string& name_val, RetinalObjectStringArgs& sa)
    : Retinal_Object(name_val,sa.vars(paramlist())) { }
#endif

  virtual Activity activation(Coordinate, Coordinate) const {
    const Activity rad=scale*0.5;
    return RandomGen()(offset+rad,rad);
  }

  virtual bool update() const  {
    scale  = get_var("scale");
    offset = get_var("offset");

    return Retinal_Object::update();
  }

  virtual Retinal_Object* clone() const
    {  return new Retinal_RandomNoise(*this);  }
  
private:
  mutable Variable scale,offset;
  virtual Activity activ(Coordinate, Coordinate) const { return 0; } // Unused 
};

typedef Retinal_RandomNoise<> Retinal_UniformRandomNoise;


class Retinal_CircularGaussian : public Retinal_Object {
public:
  Retinal_CircularGaussian( const string& name_val, const VarMap& init_vars=VarMap(),
                            const Coordinate bound_multiplier=2.5) /* Empirical default */
    : Retinal_Object(name_val,init_vars), bound_mult(bound_multiplier) {  }

#ifndef NO_VALGEN_STRINGS  
  RetinalObjectStringArgs::ParamList paramlist();
  Retinal_CircularGaussian( const string& name_val, RetinalObjectStringArgs& sa,
                            const Coordinate bound_multiplier=2.5) /* Empirical default */
    : Retinal_Object(name_val,sa.vars(paramlist())), bound_mult(bound_multiplier) { }
#endif

  Retinal_CircularGaussian(const Retinal_CircularGaussian& b) /* Copy constructor */
    : Retinal_Object(b), bound_mult(b.bound_mult) {  }

  virtual bool update() const;
  
  virtual Retinal_Object* clone() const
    { return new Retinal_CircularGaussian(*this); };

private:
  const Coordinate bound_mult;
  mutable Variable cx,cy,div_sigmasq;
  virtual Activity activ(Coordinate x, Coordinate y) const;
};



class Retinal_Gaussian : public Retinal_Object {
public:
  Retinal_Gaussian( const string& name_val, const VarMap& init_vars=VarMap(),
                    const Coordinate bound_multiplier=2.5) /* Empirical default */
    : Retinal_Object(name_val,init_vars), bound_mult(bound_multiplier) {  }

#ifndef NO_VALGEN_STRINGS  
  RetinalObjectStringArgs::ParamList paramlist();
  Retinal_Gaussian( const string& name_val, RetinalObjectStringArgs& sa,
                    const Coordinate bound_multiplier=2.5) /* Empirical default */
    : Retinal_Object(name_val,sa.vars(paramlist())), bound_mult(bound_multiplier) { }
#endif

  Retinal_Gaussian(const Retinal_Gaussian& b) /* Copy constructor */
    : Retinal_Object(b), bound_mult(b.bound_mult) {  }

  virtual bool update() const;
  
  virtual Retinal_Object* clone() const
    {  return new Retinal_Gaussian(*this);  };
  
private:
  const Coordinate bound_mult;
  mutable Variable cx,cy,cost,sint,div_xsigma,div_ysigma;
  virtual Activity activ(Coordinate x, Coordinate y) const;
};



class Retinal_Rectangle : public Retinal_Object {
public:
  Retinal_Rectangle( const string& name_val, const VarMap& init_vars=VarMap())
    : Retinal_Object(name_val,init_vars) {  }

#ifndef NO_VALGEN_STRINGS  
  RetinalObjectStringArgs::ParamList paramlist();
  Retinal_Rectangle( const string& name_val, RetinalObjectStringArgs& sa)
    : Retinal_Object(name_val,sa.vars(paramlist())) { }
#endif

  virtual bool update() const;
  
  virtual Retinal_Object* clone() const
    {  return new Retinal_Rectangle(*this);  };
  
private:
  virtual Activity activ(Coordinate, Coordinate) const 
    {  return 1.0;  } /* Brightness is constant within the bounding box */
};



class Retinal_SineGrating : public Retinal_Object {
public:
  Retinal_SineGrating( const string& name_val, const VarMap& init_vars=VarMap())
    : Retinal_Object(name_val,init_vars) {  }

#ifndef NO_VALGEN_STRINGS
  RetinalObjectStringArgs::ParamList paramlist();
  Retinal_SineGrating( const string& name_val, RetinalObjectStringArgs& sa)
    : Retinal_Object(name_val,sa.vars(paramlist())) {  }
#endif

  virtual bool update() const;

  virtual Retinal_Object* clone() const
    { return new Retinal_SineGrating(*this); };
  
private:
  mutable Variable cost,sint,phase,freq,cx,cy;
  virtual Activity activ(Coordinate x, Coordinate y) const;
};


class Retinal_Gabor : public Retinal_Object {
public:
  Retinal_Gabor( const string& name_val, const VarMap& init_vars=VarMap(),
                 const Coordinate bound_multiplier=2.5) /* Empirical default */
    : Retinal_Object(name_val,init_vars), bound_mult(bound_multiplier) {  }
  
#ifndef NO_VALGEN_STRINGS
  RetinalObjectStringArgs::ParamList paramlist();
  Retinal_Gabor( const string& name_val, RetinalObjectStringArgs& sa,
                 const Coordinate bound_multiplier=2.5) /* Empirical default */
    : Retinal_Object(name_val), bound_mult(bound_multiplier) {
    /* Special defaults */
    sa.set_default("ysigma", sa.get_default("xsigma")); //* Defaults to circular pattern
    sa.set_default("freq",   "1.0");  //* Defaults to show three lobes for typical Gabor sigma
    sa.set_default("phase",  "0");    //* Defaults to fix sine wave in center
    merge_vars(sa.vars(paramlist()));
  }
#endif
      
  Retinal_Gabor(const Retinal_Gabor& b) /* Copy constructor */
    : Retinal_Object(b), bound_mult(b.bound_mult) {  }

  virtual bool update() const;
  
  virtual Retinal_Object* clone() const
    { return new Retinal_Gabor(*this); };
  
private:
  const Coordinate bound_mult;
  mutable Variable cx,cy,cost,sint,div_xsigmasq,div_ysigmasq,freq,phase;
  virtual Activity activ(Coordinate x, Coordinate y) const;
};


class Retinal_FuzzyLine : public Retinal_Object {
public:
  Retinal_FuzzyLine( const string& name_val, const VarMap& init_vars=VarMap() )
    : Retinal_Object(name_val,init_vars) {  }

#ifndef NO_VALGEN_STRINGS
  RetinalObjectStringArgs::ParamList paramlist();
  Retinal_FuzzyLine( const string& name_val, RetinalObjectStringArgs& sa)
    : Retinal_Object(name_val,sa.vars(paramlist())) {  }
#endif

  virtual bool update() const;

  virtual Retinal_Object* clone() const
    { return new Retinal_FuzzyLine(*this); };
  
private:
  mutable Variable cx,cy,centerw,cost,sint,div_ysigmasq;
  virtual Activity activ(Coordinate x, Coordinate y) const;
};


class Retinal_FuzzyDisc : public Retinal_Object {
public:
  Retinal_FuzzyDisc( const string& name_val, const VarMap& init_vars=VarMap() )
    : Retinal_Object(name_val,init_vars) {  }

#ifndef NO_VALGEN_STRINGS
  RetinalObjectStringArgs::ParamList paramlist();
  Retinal_FuzzyDisc( const string& name_val, RetinalObjectStringArgs& sa)
    : Retinal_Object(name_val,sa.vars(paramlist())) {  }
#endif

  virtual bool update() const;

  virtual Retinal_Object* clone() const
    { return new Retinal_FuzzyDisc(*this); };
  
private:
  mutable Variable cx,cy,centerw,div_ysigmasq;
  virtual Activity activ(Coordinate x, Coordinate y) const;
};


class Retinal_FuzzyRing : public Retinal_Object {
public:
  Retinal_FuzzyRing( const string& name_val, const VarMap& init_vars=VarMap() )
    : Retinal_Object(name_val,init_vars) {  }

#ifndef NO_VALGEN_STRINGS
  RetinalObjectStringArgs::ParamList paramlist();
  Retinal_FuzzyRing( const string& name_val, RetinalObjectStringArgs& sa)
    : Retinal_Object(name_val,sa.vars(paramlist())) {  }
#endif

  virtual bool update() const;

  virtual Retinal_Object* clone() const
    { return new Retinal_FuzzyRing(*this); };
  
private:
  mutable Variable cx,cy,centerw,div_ysigmasq,radius;
  virtual Activity activ(Coordinate x, Coordinate y) const;
};


class Retinal_PGM : public Retinal_Object {
public:
  Retinal_PGM(const string& name_val, const string& filename_base,
              const VarMap& init_vars=VarMap() )
    : Retinal_Object(name_val,init_vars), basename(filename_base), ascale(1.0),
      aoffset(0.0), transparent_level(-1)
    {  set_active(pgm_read(basename,image)); border=mat::edge_average(image);  }

#ifndef NO_VALGEN_STRINGS
  RetinalObjectStringArgs::ParamList paramlist();
  Retinal_PGM( const string& name_val, RetinalObjectStringArgs& sa,
               Retinal_Composite* parent);
#endif

  Retinal_PGM(const Retinal_PGM& b) /* Copy constructor */
    : Retinal_Object(b), basename(b.basename), image(b.image),
      border(b.border), transparent_level(b.transparent_level) { }

  virtual bool update() const;

  virtual Retinal_Object* clone() const
    {  return new Retinal_PGM(*this);  };

  virtual string stringrep() const {  return Retinal_Object::stringrep()+ " " + basename;  }
  
  virtual bool inside(Coordinate x, Coordinate y) const;

private:
  
  string basename;
  typedef MatrixType<Activity>::rectangular image_type;
  image_type image;
  mutable Variable border,cx,cy,cosmt,sinmt,div_size,xoff,yoff,ascale,aoffset;
  Activity transparent_level;
  virtual Activity activ(Coordinate x, Coordinate y) const;
  virtual Activity default_activ() const {  return border;  }
  //virtual Activity default_activ() const {  return 0.5;  } /* To debug PGM bounding boxes */
  Activity pixel_value(Coordinate x, Coordinate y, bool& inbounds) const;
};



/******************************************************************************/
/* RetinalObjectFactory class                                                 */
/******************************************************************************/

#ifndef NO_VALGEN_STRINGS
class RetinalObjectFactory {
public:
  virtual ~RetinalObjectFactory() { }

  virtual Retinal_Object* create(const string& name,
                                 RetinalObjectStringArgs sa,
                                 Retinal_Composite* basecomposite,
                                 Retinal_Composite* parent) const {
    const string typenam = sa.parsed_next("type");
    
    if      (typenam=="Input_CircularGaussian"     )  return new Retinal_CircularGaussian     (name,sa);
    else if (typenam=="Input_Composite"            )  return new Retinal_Composite            (name,sa);
    else if (typenam=="Input_FuzzyDisc"            )  return new Retinal_FuzzyDisc            (name,sa);
    else if (typenam=="Input_FuzzyLine"            )  return new Retinal_FuzzyLine            (name,sa);
    else if (typenam=="Input_FuzzyRing"            )  return new Retinal_FuzzyRing            (name,sa);
    else if (typenam=="Input_Gabor"                )  return new Retinal_Gabor                (name,sa);
    else if (typenam=="Input_Gaussian"             )  return new Retinal_Gaussian             (name,sa);
    else if (typenam=="Input_Rectangle"            )  return new Retinal_Rectangle            (name,sa);
    else if (typenam=="Input_PGM"                  )  return new Retinal_PGM                  (name,sa,parent);    
    else if (typenam=="Input_SineGrating"          )  return new Retinal_SineGrating          (name,sa);
    else if (typenam=="Input_UniformRandomNoise"   )  return new Retinal_UniformRandomNoise   (name,sa);
    else if (typenam=="Input_Clone"                )  return new_Retinal_Clone                (name,sa,basecomposite);
    else {
      sa.error("Unknown retinal object type: `"+typenam+"'");
      return 0;
    }
  }

private:
  Retinal_Object* new_Retinal_Clone( const string& name_val,
                                     RetinalObjectStringArgs& sa,
                                     Retinal_Composite* basecomposite) const {
    const string oldname = sa.parsed_next("clone_name");
    Retinal_Object* oldobj = basecomposite->find(oldname);
    if (!oldobj) {
      sa.error("No object named `" + oldname + "' found to clone");
      return 0;
    }

    /* Make a new object and override certain fields as necessary */
    Retinal_Object* newobj = oldobj->clone();
    if (name_val!="")  newobj->set_name(name_val);
    if (sa.master) newobj->relink(sa.master);
    /* Process named parameters */
    newobj->merge_vars(sa.vars(RetinalObjectStringArgs::ParamList()));
    newobj->reset();
    
    return newobj;
  }
};
#endif /* NO_VALGEN_STRINGS */


#endif /* __RETINALOBJS_H__ */

---