---

kernelfactory.h

Go to the documentation of this file.

#ifndef __KERNEL_FACTORY_H__
#define __KERNEL_FACTORY_H__

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

#include "stringparser.h"
#include "pnm_io.h"
#include "radialfunction.h"
#include "neuralregion.h"
#include "generic_stdlib.h"


class KernelFactory {
public:
  typedef InternalNeuralRegion::WeightMatrix  KernelMatrix;

  KernelFactory() : max_blur_type(Blur_CircularRandom) { }
  virtual ~KernelFactory() { }

  KernelMatrix create( int index, double world_size_scale, StringArgs arglist );

  typedef double (*kernel_fnPtr)  (double x_sq, double sig_sq);

  inline KernelMatrix create(kernel_fnPtr fnptr, double radius,
                             double max_radius, string& errors,
                             bool circular=true, bool normalize=true) {
    return RadialFunction::matrix<KernelMatrix>
      (fnptr,radius,max_radius,errors,circular,normalize);
  }

  void register_params_and_commands( void );

  enum BlurTypes {Blur_SquareAverage,Blur_CircularAverage,Blur_Gaussian,Blur_DoG,Blur_LoG,
                  Blur_GoD,Blur_DoGGoD,Blur_PGM,Blur_SquareRandom,Blur_CircularRandom};
  
  const BlurTypes max_blur_type;

private:
  /* Static defaults */
  static double blur_radius;
  static double blur_radius_surround_multiplier;
  static double blur_scale;
  static double blur_range_multiplier;
  static int    blur_type;
  static char   default_kernel_filename[];
};


class KernelFactoryWrapper : public Generic::unary_virtual_function<double,KernelFactory::KernelMatrix> {
public:
  KernelFactoryWrapper(KernelFactory factory, StringArgs args, int num=0)
    : e(num), arglist(args), kf(factory)  { }
  virtual KernelFactory::KernelMatrix operator() ( double size_scale )
    {  return kf.create(e,size_scale,arglist);  }
private:
  int e;
  StringArgs arglist;
  KernelFactory& kf;
};

#endif /* __KERNEL_FACTORY_H__ */

---