block_bytecode Struct Reference
[Compiled tree representations]

#include <faster_bytecode.h>

List of all members.

---

Detailed Description

This struct contains a byte code compiled version of the detector.

Definition at line 35 of file faster_bytecode.h.

Public Member Functions
bool	detect_no_score (const CVD::byte *imp, int b) const
int	detect (const CVD::byte *imp, int b) const
void	print (std::ostream &o, int width) const
void	detect (const CVD::Image< CVD::byte > &im, std::vector< int > &corners, int threshold, int xmin, int xmax, int ymin, int ymax)
Public Attributes
std::vector < fast_detector_bit >	d
Classes
struct	fast_detector_bit
	This is a bytecode element for the bytecode-compiled detector. More...

---

Member Function Documentation

bool block_bytecode::detect_no_score	(	const CVD::byte *	imp,
		int	b
	)			const [inline]

Detects a corner at a given pointer, without the book keeping required to compute the score.

This is quite a lot faster than detect.

Parameters:

	imp	Pointer at which to detect corner
	b	FAST barrier

Returns:

is a corner or not

Definition at line 72 of file faster_bytecode.h.

References d.

Referenced by detect().

    {
        int n=0;    
        int cb = *imp + b;
        int c_b = *imp - b;
        int p;

        while(d[n].lt)
        {
            p = imp[d[n].offset];

            if(p > cb)
                n = d[n].gt;
            else if(p < c_b)
                n = d[n].lt;
            else
                n = d[n].eq;
        }
        
        return d[n].gt;
    }

int block_bytecode::detect	(	const CVD::byte *	imp,
		int	b
	)			const [inline]

Detects a corner at a given pointer, with book-keeping required for score computation.

Parameters:

	imp	Pointer at which to detect corner
	b	FAST barrier

Returns:

0 for non-corner, minimum increment required to make detector go down different branch, if it is a corner.

Definition at line 99 of file faster_bytecode.h.

References d.

Referenced by tree_detect_corners(), and tree_detect_corners_all().

    {
        int n=0;    
        int m = INT_MAX;
        int cb = *imp + b;
        int c_b = *imp - b;
        int p;

        while(d[n].lt)
        {
            p = imp[d[n].offset];

            if(p > cb)
            {
                if(p-cb < m)
                    m = p-cb;

                n = d[n].gt;
            }
            else if(p < c_b)
            {
                if(c_b - p < m)
                    m = c_b - p;
            
                n = d[n].lt;
            }
            else
                n = d[n].eq;
        }
        
        if(d[n].gt)
            return m;
        else
            return 0;
    }

void block_bytecode::print	(	std::ostream &	o,
		int	width
	)			const [inline]

Serialize the detector to an ostream.

The serialized detector a number of lines of the form:

       Block N [X Y] G E L

or:

       Block N corner

or:

       Block N non_corner

The first block type represents the code:

       if Image[current_pixel + (x, y)] > Image[current_pixel] + threshold
          goto block G
       elseif Image[current_pixel + (x, y)] < Image[current_pixel] -threshold
          goto block L
       else
          goto block E
       endif

Parameters:

	o	ostream for output
	width	width the detector was created at, required to back out the offsets correctly.

Definition at line 160 of file faster_bytecode.h.

References d.

Referenced by faster_learn::faster_learn(), and run_learn_detector().

    {
        using tag::operator<<;
        for(unsigned int i=0; i < d.size(); i++)
        {
            if(d[i].lt == 0)
                o << tag::print << "Block" << i <<  (d[i].gt?"corner":"non_corner");
            else
            {
                int a = abs(d[i].offset) + width / 2;
                if(d[i].offset < 0)
                    a = -a;
                int y = a / width;

                int x = d[i].offset - y * width;
                o << tag::print << "Block" << i << CVD::ImageRef(x , y) << d[i].gt << d[i].eq << d[i].lt;
            }
        }
    }

void block_bytecode::detect	(	const CVD::Image< CVD::byte > &	im,
		std::vector< int > &	corners,
		int	threshold,
		int	xmin,
		int	xmax,
		int	ymin,
		int	ymax
	)

Detect corners in an image.

The width of the image must match the width the detector was compiled to (using tree_elemeent::make_fast_detector for the results to make sense. The bytecode is JIT coimpiled if possible.

Parameters:

	im	The image in which to detect corners
	corners	Detected corners are inserted in to this container.
	threshold	Corner detector threshold to use
	xmin	x coordinate to start at.
	ymin	y coordinate to start at.
	xmax	x coordinate to go up to.
	ymax	y coordinate to go up to.

Definition at line 329 of file faster_bytecode.cc.

References d, and detect_no_score().

{
    #ifdef JIT
        jit_detector jit(d);
        for(int y = ymin; y < ymax; y++)
            jit.detect_in_row(im, y, xmin, xmax, corners, threshold);
    #else
        cerr << "Hello!\n";
        for(int y = ymin; y < ymax; y++)
            for(int x=xmin; x < xmax; x++)
                if(detect_no_score(&im[y][x], threshold))
                    corners.push_back(&im[y][x] - im.data());
    #endif
}

---

Member Data Documentation

std::vector<fast_detector_bit> block_bytecode::d

This contains the compiled bytecode.

Definition at line 64 of file faster_bytecode.h.

Referenced by detect(), detect_no_score(), and print().

---

The documentation for this struct was generated from the following files:

• faster_bytecode.h
• faster_bytecode.cc

---