NICE_VisLearning/classifier/fpclassifier/randomforest/SplittingCriterion.h

/**
 * @file SplittingCriterion.h
 * @brief abstract interface for splitting criteria
 * @author Sven Sickert
 * @date 01/12/2017

*/
#ifndef SplittingCriterionINCLUDE
#define SplittingCriterionINCLUDE

#include "core/basics/Config.h"
#include "vislearning/cbaselib/Feature.h"

namespace OBJREC {
    
/* abstract interface for splitting criteria */
class SplittingCriterion
{
  protected:
    int min_examples;
    double entropy_cur;
    double min_entropy;
    double min_purity;

    /**
     * @brief computation of entropy
     * @param distribution given distribution
     * @param count amount of samples
     * @param maxClassNo maximum class number
     * @return computed entropy
     */
    double computeEntropy(
        const double* distribution,
        const double count ,
        const int maxClassNo );

  public:

    /** default constructor */
    SplittingCriterion( );
    
    /** simple constructor */
    SplittingCriterion( int _min_examples );

    /** config constructor */
    SplittingCriterion( const NICE::Config *conf );

    /** copy constructor */
    SplittingCriterion( const SplittingCriterion &obj );

    /** default destructor */
    virtual ~SplittingCriterion();

    /** cloning functioning */
    virtual SplittingCriterion* clone() = 0;

    /**
     * @brief evaluate the split and return if split is possible
     * @param values unsorted list of feature values of a certain dimension
     * @param threshold threshold for current feature dimension
     * @param distribution_left class distribution for left child node after splitting
     * @param distribution_right class distribution for right child node after splitting
     * @param maxClassNo maximum class number
     * @return possible split or not
     */
    virtual bool evaluateSplit(
        const FeatureValuesUnsorted & values,
        double threshold,
        double* distribution_left,
        double* distribution_right,
        int maxClassNo ) = 0;

    /**
     * @brief compute purity based on given split
     * @return purity value
     */
    virtual double computePurity() const = 0;

    /**
     * @brief return entropy value
     */
    double getEntropy() const
    {
        return entropy_cur;
    }

    /**
     * @brief return minimum allowed entropy value
     */
    double getMinimumEntropy() const
    {
        return min_entropy;
    }

    /**
     * @brief return target purity value
     */
    double getMinimumPurity() const
    {
        return min_purity;
    }

    /**
     * @brief return allowed minmum amount of examples
     */
    int getMinimumExamples() const
    {
        return min_examples;
    }

};
    
}  // namespace

#endif