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.