PndPrzWindowClassify.h

Go to the documentation of this file.

/* ***************************************
 * Parzen Window based classifier.       *
 * Author: M.Babai@rug.nl                *
 * Version:                              *
 * license:                              *
 * ***************************************
 */
/*
 * Based on the straight parzen window algorithm Using a linear search
 * data structure.
 */
//#pragma once
#ifndef PND_PRZ_WINDOW_CLASSIFY_H
#define PND_PRZ_WINDOW_CLASSIFY_H

// Local includes
#include "PndMvaClassifier.h"

/*
 * Parzen Window based classification alg. implementation.
 */
class PndPrzWindowClassify : public PndMvaClassifier {
 public:
  /*
   * @param inputFile: The name of the file that holds the weights
   * @param classNames: The names of classes to which an event might be
   * assigned to.
   * @param varNames: Variable names from which the feature vector is
   * built.
   */
  explicit PndPrzWindowClassify(std::string const &inputFile, std::vector<std::string> const &classNames, std::vector<std::string> const &varNames);

  virtual ~PndPrzWindowClassify();

  void GetMvaValues(std::vector<float> eventData, std::map<std::string, float> &result);
  std::string *Classify(std::vector<float> EvtData);

  void setWindowSize(float wsize);

  inline void setWindowSize(std::map<std::string, float> const &wsize);

  inline float GetHyperCubeVolume() const;

  inline std::map<std::string, float> const &GetWindowSize() const;

 private:
  // To avoid mistakes.
  PndPrzWindowClassify(PndPrzWindowClassify const &other);
  PndPrzWindowClassify &operator=(PndPrzWindowClassify const &other);

  /*
   * A very simple implementation of a kernel function. It can be
   * considerd as a multi-dimensional histogram with constant bin size
   * in each dimension.
   *@param evtDat Vector containing event data.
   *@return 1 if the current test sample inside the window, else 0;
   */
  float histKernel(std::vector<float> const &evtDat, std::vector<float> const &trSample);

  // Compute the hypercube volume
  float CompHyperCubeVolume();

  // Hypercube volume
  float m_volumeN;

  // Window size in each dimension
  std::map<std::string, float> m_Wsize;
};

// ================================================================
inline void PndPrzWindowClassify::setWindowSize(std::map<std::string, float> const &wsize)
{
  m_Wsize = std::map<std::string, float>(wsize);
  // Set hypercube volume.
  m_volumeN = CompHyperCubeVolume();
};

inline float PndPrzWindowClassify::GetHyperCubeVolume() const
{
  return m_volumeN;
};

inline std::map<std::string, float> const &PndPrzWindowClassify::GetWindowSize() const
{
  return m_Wsize;
};
#endif // End of PndPrzWindowClassify interface.