MASH logo
Login | Register

kanma/blobs

User avatar

Core team
Author:
Kanma
Upload date:
April 29, 2010, 11:20 a.m.
Status:
Enabled
Summary:
This heuristic produces a 'blobbed' version of the (RGB) region of interest.
Description:

The computation of the blobs is done by segmenting the RGB space in 512 discrete values (each channel range is segmented in 8).

Evaluation:
Configuration Training error ( sd ) Test error ( sd )
adaboost-caltech 71.48% (1.719) 76.46% (2.0996)
perceptron-mnist 5.62% (0.6567) 12.33% (0.1567) 
 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
/** Author: Kanma

    This heuristic produces a 'blobbed' version of the (RGB) region of interest.
    The computation of the blobs is done by segmenting the RGB space in 512
    discrete values (each channel range is segmented in 8).
*/

#include <mash/heuristic.h>
#include <memory.h>

using namespace Mash;


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


    //_____ Implementation of Heuristic __________
public:
    virtual unsigned int dim();

    virtual scalar_t computeFeature(unsigned int feature_index);


    //_____ Attributes __________
protected:
    byte_t _lookup[256];
};


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


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

BlobsHeuristic::BlobsHeuristic()
{
    for (unsigned int i = 0; i < 256; ++i)
        _lookup[i] = i / 32;
}


BlobsHeuristic::~BlobsHeuristic()
{
}


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

unsigned int BlobsHeuristic::dim()
{
    // We have has many features than pixels in the region of interest
    unsigned int roi_size = roi_extent * 2 + 1;
    return roi_size * roi_size;
}


scalar_t BlobsHeuristic::computeFeature(unsigned int feature_index)
{
    // Compute the coordinates of the top-left pixel of the region of interest
    unsigned int x0 = coordinates.x - roi_extent;
    unsigned int y0 = coordinates.y - roi_extent;

    // Compute the coordinates of the pixel corresponding to the feature, in
    // the region of interest
    unsigned int roi_size = roi_extent * 2 + 1;
    unsigned int x = feature_index % roi_size;
    unsigned int y = (feature_index - x) / roi_size;

    // Return the blobbed value of the pixel corresponding to the desired feature
    RGBPixel_t pixel = image->rgbLines()[y0 + y][x0 + x];
    return (scalar_t) _lookup[pixel.r] + _lookup[pixel.g] * 8 +
                      _lookup[pixel.b] * 64;
}