/** Author: jena

 Computes scalar product of the gray-scale patch and many random vectors (projections).
 
 Inspired by Randomfaces approach. Due to high dimensionality of the patch and 
 small number of projections, no orthogonalisation is done as the projections are
 assumed to be nearly orthogonal.
 */

#include <iostream>
#include <stdlib.h>
#include <mash/heuristic.h>

using namespace Mash;
using namespace std;


//------------------------------------------------------------------------------
// Declaration of the heuristic class
//------------------------------------------------------------------------------
class RandomProjections: public Heuristic
{
    //_____ Construction / Destruction __________
public:
    RandomProjections();
    virtual ~RandomProjections();


    //_____ Implementation of Heuristic __________
public:
    //--------------------------------------------------------------------------
    /// @brief  Called once at the creation of the heuristic
    ///
    /// Pre-computes all the data that will never change during the life-time of
    /// the heuristic
    ///
    /// When this method is called, the 'roi_extent' attribute is initialized
    ///
    /// @remark The implementation of this method is optional
    //--------------------------------------------------------------------------
    virtual void init();

    //--------------------------------------------------------------------------
    /// @brief  Called once when the heuristic is destroyed
    ///
    /// Frees the memory allocated by the init() method
    ///
    /// @remark This method must be implemented if init() is used and allocated
    ///         some memory
    //--------------------------------------------------------------------------
    virtual void terminate();

    //--------------------------------------------------------------------------
    // Returns the number of features this heuristic computes
    //
    // When this method is called, the 'roi_extent' attribute is initialized
    //--------------------------------------------------------------------------
    virtual unsigned int dim();

    //--------------------------------------------------------------------------
    // Called once per image, before any computation 
    //
    // Pre-computes from a full image the data the heuristic will need to compute
    // features at any coordinates in the image
    //
    // When this method is called, the following attributes are initialized:
    //     - roi_extent
    //     - image
    //--------------------------------------------------------------------------
    virtual void prepareForImage();

    //--------------------------------------------------------------------------
    // Called once per image, after any computation 
    //
    // Frees the memory allocated by the prepareForImage() method
    //--------------------------------------------------------------------------
    virtual void finishForImage();

    //--------------------------------------------------------------------------
    // Called once per coordinates, before any computation
    //
    // Pre-computes the data the heuristic will need to compute features at the
    // given coordinates
    //
    // When this method is called, the following attributes are initialized:
    //     - roi_extent
    //     - image
    //     - coordinates
    //--------------------------------------------------------------------------
    virtual void prepareForCoordinates();
    
    //--------------------------------------------------------------------------
    // Called once per coordinates, after any computation 
    //
    // Frees the memory allocated by the prepareForCoordinates() method
    //--------------------------------------------------------------------------
    virtual void finishForCoordinates();

    //--------------------------------------------------------------------------
    // Computes the specified feature
    //
    // When this method is called, the following attributes are initialized:
    //     - roi_extent
    //     - image
    //     - coordinates
    //--------------------------------------------------------------------------
    virtual scalar_t computeFeature(unsigned int feature_index);


    //_____ Attributes __________
protected:
    static const unsigned int NUM_FEATURES = 200;
    float** projections;
};


//------------------------------------------------------------------------------
// Creation function of the heuristic
//------------------------------------------------------------------------------
extern "C" Heuristic* new_heuristic()
{
    return new RandomProjections();
}



/************************* CONSTRUCTION / DESTRUCTION *************************/

RandomProjections::RandomProjections()
{
}


RandomProjections::~RandomProjections()
{
}


/************************* IMPLEMENTATION OF Heuristic ************************/

void RandomProjections::init()
{
    unsigned int roi_size = roi_extent * 2 + 1;
    unsigned int roi_size2 = roi_size * roi_size;
    int i, j;
    
    projections = new float*[NUM_FEATURES];
    for (i=0; i<NUM_FEATURES; ++i) {
        projections[i] = new float[roi_size2];
    }

    srand((unsigned)time(NULL));
    for (i=0; i<NUM_FEATURES; ++i) {
        // generate random vector
        float* proj = projections[i];
        float sum = 0;
        for (j=0; j<roi_size2; ++j) {
            float r = ((float)rand()/(float)RAND_MAX);
            *proj++ = r;
            sum += r;
        }
        // vector normalisation
        proj = projections[i];
        for (j=0; j<roi_size2; ++j) {
            *proj++ /= sum;
        }
    }
}


void RandomProjections::terminate()
{
    for (int i=0; i<NUM_FEATURES; ++i)
        delete [] projections[i];
    delete [] projections;
}

unsigned int RandomProjections::dim()
{
    return NUM_FEATURES;
}


void RandomProjections::prepareForImage()
{
}


void RandomProjections::finishForImage()
{
}


void RandomProjections::prepareForCoordinates()
{
}


void RandomProjections::finishForCoordinates()
{
}


scalar_t RandomProjections::computeFeature(unsigned int feature_index)
{
    unsigned int x0 = coordinates.x - roi_extent;
    unsigned int y0 = coordinates.y - roi_extent;
    unsigned int roi_size = roi_extent * 2 + 1;
    
    float fvalue = 0.0;
    float* proj = projections[feature_index];
    byte_t** pLines = image->grayLines();
  
    for (int y=0; y<roi_size; ++y) {
        byte_t* line = pLines[y0 + y] + x0;
        for (int x=0; x<roi_size; ++x) {
            fvalue += ((float) *line) * *proj;
            ++line;
            ++proj;
        }
    }

    return fvalue;  
}