/** Author: Francois Fleuret
This heuristic extracts very crude edges quantified in 8
orientations at every pixel.
From that, it computes 1000 features (this is an arbitrary
parameter), each corresponding to the number of edges of certain
orientation in a certain rectangular sub-window of the area of
interest.
*/
#include <iostream>
#include <mash/heuristic.h>
#include <stdlib.h>
using namespace Mash;
#define PIXEL_DELTA(a, b) ((a) >= (b) ? (a) - (b) : (b) - (a))
bool edge( byte_t v0, byte_t v1,
byte_t v2, byte_t v3, byte_t v4, byte_t v5,
byte_t v6, byte_t v7) {
byte_t g = PIXEL_DELTA(v3, v4);
return
g > PIXEL_DELTA(v0, v3) && g > PIXEL_DELTA(v1, v4) &&
g > PIXEL_DELTA(v2, v3) && g > PIXEL_DELTA(v4, v5) &&
g > PIXEL_DELTA(v3, v6) && g > PIXEL_DELTA(v4, v7);
}
struct RectangleWithOrientation {
int e, xmin, ymin, xmax, ymax;
};
//------------------------------------------------------------------------------
// Declaration of the heuristic class
//------------------------------------------------------------------------------
class Zk: public Heuristic
{
//_____ Construction / Destruction __________
public:
Zk();
virtual ~Zk();
//_____ 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 int nb_edge_types = 8;
static const int nb_features = 1000;
int *_edge_count;
int _image_width, _image_height;
RectangleWithOrientation *_rectangles;
};
//------------------------------------------------------------------------------
// Creation function of the heuristic
//------------------------------------------------------------------------------
extern "C" Heuristic* new_heuristic()
{
return new Zk();
}
/************************* CONSTRUCTION / DESTRUCTION *************************/
Zk::Zk()
{
_rectangles = new RectangleWithOrientation[nb_features];
}
Zk::~Zk()
{
delete[] _rectangles;
}
/************************* IMPLEMENTATION OF Heuristic ************************/
void Zk::init()
{
for(int n = 0; n < nb_features; n++) {
_rectangles[n].e = int(drand48() * nb_edge_types);
do {
_rectangles[n].xmin = - roi_extent + int(drand48() * (2 * roi_extent + 1));
_rectangles[n].ymin = - roi_extent + int(drand48() * (2 * roi_extent + 1));
_rectangles[n].xmax = - roi_extent + int(drand48() * (2 * roi_extent + 1));
_rectangles[n].ymax = - roi_extent + int(drand48() * (2 * roi_extent + 1));
} while(_rectangles[n].xmax <= _rectangles[n].xmin || _rectangles[n].ymax <= _rectangles[n].ymin);
}
}
unsigned int Zk::dim()
{
return nb_features;
}
void Zk::prepareForImage()
{
byte_t **pixels = image->grayLines();
_image_width = image->width() + 1;
_image_height = image->height() + 1;
_edge_count = new int [_image_width * _image_height * nb_edge_types];
int d00, d01, d02, d03, d04, d05, d06, d07;
int d08, d09, d10, d11, d12, d13, d14, d15;
for(int y = 0; y < _image_height; y++) {
for(int x = 0; x < _image_width; x++) {
if(y == 0 || x == 0) {
for(int e = 0; e < nb_edge_types; e++)
_edge_count[e + nb_edge_types * (x + _image_width * y)] = 0;
} else {
for(int e = 0; e < nb_edge_types; e++)
_edge_count[e + nb_edge_types * (x + _image_width * y)] =
+ _edge_count[e + nb_edge_types * ((x - 1) + _image_width * y)]
+ _edge_count[e + nb_edge_types * (x + _image_width * (y - 1))]
- _edge_count[e + nb_edge_types * ((x - 1) + _image_width * (y - 1))];
}
if(x > 1 && x < _image_width - 3 && y > 1 && y < _image_height - 3) {
d00 = pixels[(x - 1)][(y - 1)];
d01 = pixels[(x + 0)][(y - 1)];
d02 = pixels[(x + 1)][(y - 1)];
d03 = pixels[(x + 2)][(y - 1)];
d04 = pixels[(x - 1)][(y + 0)];
d05 = pixels[(x + 0)][(y + 0)];
d06 = pixels[(x + 1)][(y + 0)];
d07 = pixels[(x + 2)][(y + 0)];
d08 = pixels[(x - 1)][(y + 1)];
d09 = pixels[(x + 0)][(y + 1)];
d10 = pixels[(x + 1)][(y + 1)];
d11 = pixels[(x + 2)][(y + 1)];
d12 = pixels[(x - 1)][(y + 2)];
d13 = pixels[(x + 0)][(y + 2)];
d14 = pixels[(x + 1)][(y + 2)];
d15 = pixels[(x + 2)][(y + 2)];
/*
XXXXXX .XXXXX ...XXX .....X
XXXXXX ..XXXX ...XXX ....XX
...... ...XXX ...XXX ...XXX
...... ....XX ...XXX ..XXXX
#0 #1 #2 #3
...... X..... XXX... XXXXX.
...... XX.... XXX... XXXX..
XXXXXX XXX... XXX... XXX...
XXXXXX XXXX.. XXX... XX....
#4 #5 #6 #7
*/
if(edge(d04, d08, d01, d05, d09, d13, d06, d10)) {
if(d05 < d09)
_edge_count[0 + nb_edge_types * (x + _image_width * y)]++;
else
_edge_count[4 + nb_edge_types * (x + _image_width * y)]++;
}
if(edge(d02, d07, d00, d05, d10, d15, d08, d13)) {
if(d05 < d10)
_edge_count[7 + nb_edge_types * (x + _image_width * y)]++;
else
_edge_count[3 + nb_edge_types * (x + _image_width * y)]++;
}
if(edge(d01, d02, d04, d05, d06, d07, d09, d10)) {
if(d05 < d06)
_edge_count[6 + nb_edge_types * (x + _image_width * y)]++;
else
_edge_count[2 + nb_edge_types * (x + _image_width * y)]++;
}
if(edge(d01, d04, d03, d06, d09, d12, d11, d14)) {
if(d06 < d09)
_edge_count[1 + nb_edge_types * (x + _image_width * y)]++;
else
_edge_count[5 + nb_edge_types * (x + _image_width * y)]++;
}
}
}
}
}
void Zk::finishForImage()
{
delete[] _edge_count;
}
void Zk::prepareForCoordinates()
{
// Nothing here
}
void Zk::finishForCoordinates()
{
// Nothing here
}
scalar_t Zk::computeFeature(unsigned int feature_index)
{
int xmin = coordinates.x + _rectangles[feature_index].xmin;
int ymin = coordinates.y + _rectangles[feature_index].ymin;
int xmax = coordinates.x + _rectangles[feature_index].xmax;
int ymax = coordinates.y + _rectangles[feature_index].ymax;
if(xmin < 0) xmin = 0;
if(xmax >= _image_width) xmax = _image_width - 1;
if(ymin < 0) ymin = 0;
if(ymax >= _image_height) ymax = _image_height - 1;
if(xmax > xmin && ymax > ymin) {
int e = _rectangles[feature_index].e;
return
scalar_t(+ _edge_count[e + nb_edge_types * (xmin + _image_width * ymin)]
+ _edge_count[e + nb_edge_types * (xmax + _image_width * ymax)]
- _edge_count[e + nb_edge_types * (xmax + _image_width * ymin)]
- _edge_count[e + nb_edge_types * (xmin + _image_width * ymax)]);
} else {
return 0.0;
}
}
