MASH logo
Login | Register

francoisfleuret/average

User avatar

Project Member
Author:
FrancoisFleuret
Upload date:
Oct. 2, 2009, 8:08 a.m.
Status:
Enabled
Summary:
Return the average level of the pixel gray levels.
Ranking:
Configuration Training error ( sd ) Test error ( sd )
adaboost-caltech 71.74% (1.3377) 75.28% (1.4297)
perceptron-mnist 8.49% (1.5252) 12.58% (0.4033) 
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
/** Author: FrancoisFleuret

    TODO: Write a description of your heuristic
*/

#include <mash/heuristic.h>

using namespace Mash;


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


    //_____ Implementation of Heuristic __________
public:
    //--------------------------------------------------------------------------
    // 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:
    // TODO: Declare all the attributes you'll need here
};


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



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

Average::Average()
{
    // TODO: Initialization of the attributes that doesn't depend of anything
}


Average::~Average()
{
    // TODO: Cleanup of the allocated memory still remaining
}


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

unsigned int Average::dim()
{
    // TODO: Implement it
    return 1;
}


void Average::prepareForImage()
{
    // TODO: Initialization of the attributes that depend of the whole image
}


void Average::finishForImage()
{
    // TODO: Frees the memory allocated by the prepareForImage() method
}


void Average::prepareForCoordinates()
{
    // TODO: Initialization of the attributes that depend of the coordinates
}


void Average::finishForCoordinates()
{
    // TODO: Frees the memory allocated by the prepareForCoordinates() method
}


scalar_t Average::computeFeature(unsigned int feature_index)
{
  scalar_t s = 0;
  byte_t** pLines = image->grayLines();
  for(int y = coordinates.y - roi_extent; y <= coordinates.y + roi_extent; y++) {
    for(int x=coordinates.x - roi_extent; x<= coordinates.x+roi_extent; x++) {
      s += scalar_t(pLines[y][x]);
    }
  }

  // TODO: Implement it
  return s/scalar_t((2 * roi_extent + 1) * (2 * roi_extent + 1));
}