drwnHOGFeatures.h

/*****************************************************************************
** DARWIN: A FRAMEWORK FOR MACHINE LEARNING RESEARCH AND DEVELOPMENT
** Distributed under the terms of the BSD license (see the LICENSE file)
** Copyright (c) 2007-2015, Stephen Gould
** All rights reserved.
**
******************************************************************************
** FILENAME:    drwnHOGFeatures.h
** AUTHOR(S):   Stephen Gould <stephen.gould@anu.edu.au>
**
*****************************************************************************/

#pragma once

#include <vector>

#include "cv.h"

// drwnHOGNormalization -----------------------------------------------------

typedef enum _drwnHOGNormalization {
    DRWN_HOG_L2_NORM, 
    DRWN_HOG_L1_NORM, 
    DRWN_HOG_L1_SQRT 
} drwnHOGNormalization;

// drwnHOGFeatures ----------------------------------------------------------

class drwnHOGFeatures {
 public:
    static int DEFAULT_CELL_SIZE;    
    static int DEFAULT_BLOCK_SIZE;   
    static int DEFAULT_BLOCK_STEP;   
    static int DEFAULT_ORIENTATIONS; 
    static drwnHOGNormalization DEFAULT_NORMALIZATION; 
    static double DEFAULT_CLIPPING_LB; 
    static double DEFAULT_CLIPPING_UB; 
    static bool DEFAULT_DIM_REDUCTION; 

 protected:
    int _cellSize;        
    int _blockSize;       
    int _blockStep;       
    int _numOrientations; 
    drwnHOGNormalization _normalization; 
    pair<double, double> _clipping;      
    bool _bDimReduction;  

 public:
    drwnHOGFeatures();
    virtual ~drwnHOGFeatures();

    inline int numFeatures() const;
    inline cv::Size numCells(const cv::Size& imgSize) const;
    inline cv::Size numBlocks(const cv::Size& imgSize) const;
    inline cv::Size padImageSize(const cv::Size& imgSize) const;

    pair<cv::Mat, cv::Mat> gradientMagnitudeAndOrientation(const cv::Mat& img) const;

    void computeFeatures(const cv::Mat& img, std::vector<cv::Mat>& features);
    void computeFeatures(const pair<cv::Mat, cv::Mat>& gradMagAndOri, std::vector<cv::Mat>& features);

    void computeDenseFeatures(const cv::Mat& img, std::vector<cv::Mat>& features);

    cv::Mat visualizeCells(const cv::Mat& img, int scale = 2);

 protected:
    void computeCanonicalOrientations(vector<float>& x, vector<float>& y) const;
    void computeCellHistograms(const pair<cv::Mat, cv::Mat>& gradMagAndOri, vector<cv::Mat>& cellHistorgams) const;
    void computeBlockFeatures(const vector<cv::Mat>& cellHistograms, vector<cv::Mat>& features) const;
    void normalizeFeatureVectors(std::vector<cv::Mat>& features) const;
    void clipFeatureVectors(std::vector<cv::Mat>& features) const;
};

// drwnHOGFeatures inline functions -----------------------------------------

inline int drwnHOGFeatures::numFeatures() const
{
    return _bDimReduction ? (_blockSize * _blockSize + _numOrientations) :
        (_blockSize * _blockSize * _numOrientations);
}

inline cv::Size drwnHOGFeatures::numCells(const cv::Size& imgSize) const
{
    return cv::Size((int)((imgSize.width + _cellSize - 1) / _cellSize),
        (int)((imgSize.height + _cellSize - 1) / _cellSize));
}

inline cv::Size drwnHOGFeatures::numBlocks(const cv::Size& imgSize) const
{
    cv::Size nCells = numCells(imgSize);
    return cv::Size(nCells.width - _blockSize + 1, nCells.height - _blockSize + 1);
}

inline cv::Size drwnHOGFeatures::padImageSize(const cv::Size& imgSize) const
{
    return cv::Size((int)((imgSize.width + _cellSize - 1) / _cellSize) * _cellSize,
        (int)((imgSize.height + _cellSize - 1) / _cellSize) * _cellSize);
}