Compiled tree representations

Classes
struct	block_bytecode
	This struct contains a byte code compiled version of the detector. More...
struct	block_bytecode::fast_detector_bit
	This is a bytecode element for the bytecode-compiled detector. More...
Functions
block_bytecode	tree_element::make_fast_detector (int xsize) const
void	tree_element::make_fast_detector_o (std::vector< block_bytecode::fast_detector_bit > &v, int n, int xsize, int N, bool invert) const

---

Function Documentation

block_bytecode tree_element::make_fast_detector

(

int

xsize

)

const [inline, inherited]

Compile the detector to bytecode.

The bytecode is not a tree, but a graph. This is because the detector is applied in all orientations: offsets are integers which are indices in to a list of (x,y) offsets and there are multiple lists of offsets. The tree is also applied with intensity inversion.

Parameters:

xsize

The width of the image.

Returns:

The bytecode compiled detector.

Definition at line 92 of file faster_tree.h.

References tree_element::gt, invert(), tree_element::lt, tree_element::make_fast_detector_o(), and offsets.

Referenced by run_learn_detector(), tree_detect_corners(), and tree_detect_corners_all().

        {
            std::vector<block_bytecode::fast_detector_bit> f;
            
            for(int invert=0; invert < 2; invert++)
                for(unsigned int i=0; i <  offsets.size(); i++)
                {   
                    //Make a FAST detector at a certain orientation
                    std::vector<block_bytecode::fast_detector_bit> tmp(1);
                    make_fast_detector_o(tmp, 0, xsize, i, invert);

                    int endpos = f.size() + tmp.size();
                    int startpos = f.size();

                    //Append tmp on to f, filling in the non-corners (jumps to endpos)
                    //and correcting the intermediate jumps destinations
                    for(unsigned int i=0 ; i < tmp.size(); i++)
                    {
                        f.push_back(tmp[i]);

                        if(f.back().eq == -1)
                            f.back().eq = endpos;
                        else if(f.back().eq > 0)
                            f.back().eq += startpos;

                        if(f.back().gt == -1)
                            f.back().gt = endpos;
                        else if(f.back().gt > 0)
                            f.back().gt += startpos;

                        if(f.back().lt == -1)
                            f.back().lt = endpos;
                        else if(f.back().lt > 0)
                            f.back().lt += startpos;

                    }
                }

            //We need a final endpoint for non-corners
            f.resize(f.size() + 1);
            f.back().offset = 0;
            f.back().lt = 0;
            f.back().gt = 0;
            f.back().eq = 0;

            //Now we need an extra endpoint for corners
            for(unsigned int i=0; i < f.size(); i++)
            {
                //EQ is always non-corner
                if(f[i].lt == -2)
                    f[i].lt = f.size();
                if(f[i].gt == -2)
                    f[i].gt = f.size();
            }

            f.resize(f.size() + 1);
            f.back().offset = 0;
            f.back().lt = 0;
            f.back().gt = 1;
            f.back().eq = 0;

            block_bytecode r = {f};
            
            return r;
        }

void tree_element::make_fast_detector_o	(	std::vector< block_bytecode::fast_detector_bit > &	v,
		int	n,
		int	xsize,
		int	N,
		bool	invert
	)			const [inline, private, inherited]

This compiles the tree in a single orientation and form to bytecode.

This is called repeatedly by make_fast_detector. A jump destination of -1 refers to a non corner and a destination of -2 refers to a corner.

Parameters:

	v	Bytecode storage
	n	Position in v to compile the bytecode to
	xsize	Width of the image
	N	orientation of the tree
	invert	whether or not to perform and intensity inversion.

Definition at line 175 of file faster_tree.h.

References tree_element::eq, tree_element::gt, tree_element::is_corner, tree_element::is_leaf(), tree_element::lt, tree_element::make_fast_detector_o(), tree_element::offset_index, and offsets.

Referenced by tree_element::make_fast_detector(), and tree_element::make_fast_detector_o().

        {
            //-1 for non-corner
            //-2 for corner

            if(eq == NULL)
            {
                //If the tree is a single leaf, then we end up here. In this case, it must be 
                //a non-corner, otherwise the strength would be inf.
                v[n].offset = 0;
                v[n].lt = -1;
                v[n].gt = -1;
                v[n].eq = -1;
            }
            else
            {
                v[n].offset = offsets[N][offset_index].x + offsets[N][offset_index].y * xsize;

                if(eq->is_leaf())
                    v[n].eq = -1; //Can only be non-corner!
                else
                {
                    v[n].eq = v.size();
                    v.resize(v.size() + 1);
                    eq->make_fast_detector_o(v, v[n].eq, xsize, N, invert);
                }

                const tree_element* llt = lt;
                const tree_element* lgt = gt;

                if(invert)
                    std::swap(llt, lgt);

                if(llt->is_leaf())
                {
                    v[n].lt = -1 - llt->is_corner;
                }
                else
                {
                    v[n].lt = v.size();
                    v.resize(v.size() + 1);
                    llt->make_fast_detector_o(v, v[n].lt, xsize, N, invert);
                }


                if(lgt->is_leaf())
                    v[n].gt = -1 - lgt->is_corner;
                else
                {
                    v[n].gt = v.size();
                    v.resize(v.size() + 1);
                    lgt->make_fast_detector_o(v, v[n].gt, xsize, N, invert);
                }
            }
        }

---