mimas::hf::hypothesis_filter< image_loader_P, Observer_P, Analyse_result_T, Hypothesis_T, Picking_P, Compensate_P, Pixel_T > Class Template Reference
[Particle filter]

The host class, center of the hypothesis filter architecture. More...

#include <hypothesis_filter.h>

Inheritance diagram for mimas::hf::hypothesis_filter< image_loader_P, Observer_P, Analyse_result_T, Hypothesis_T, Picking_P, Compensate_P, Pixel_T >:

[legend]Collaboration diagram for mimas::hf::hypothesis_filter< image_loader_P, Observer_P, Analyse_result_T, Hypothesis_T, Picking_P, Compensate_P, Pixel_T >:

[legend]List of all members.


Public Member Functions
double	max_weight (void)
	gives the maximum weight of the particules, can serve to normalise measures for instance.
void	track (void)
	This method is implemented by the compiler only if it is called.
void	reset (Hypothesis_T &init)
	To re-initialize the filter, very usefull to regroup around one hypothesis the different hypothesis when they are wide-spreaded and the measurment is "good enough".
void	filter (void)
	When all has been set call this method to measure hypothesis validity.
	hypothesis_filter (Hypothesis_T &initial, int n, typename image_loader_P< Pixel_T >::set il_param, typename Observer_P< Hypothesis_T, Pixel_T >::set obs_param, typename Analyse_result_T< Hypothesis_T, Pixel_T >::set analyse_param)
	The constructor, you right it looks awful but it does a hell of a lot for you.
	hypothesis_filter (Hypothesis_T &initial, int n, typename image_loader_P< Pixel_T >::set il_param)
	~hypothesis_filter ()
Protected Attributes
int	nb_hypothesis
	for plublic access look at the vector size record the number of hypothesis used for re-initialisation

Detailed Description

template<template< typename > class image_loader_P, template< typename, typename > class Observer_P, template< typename, typename > class Analyse_result_T, typename Hypothesis_T, template< typename > class Picking_P = condensation, template< typename > class Compensate_P = no_compensation, typename Pixel_T = unsigned char>
class mimas::hf::hypothesis_filter< image_loader_P, Observer_P, Analyse_result_T, Hypothesis_T, Picking_P, Compensate_P, Pixel_T >

The host class, center of the hypothesis filter architecture.

It hosts different policy classes; if you want to do modifications you should start to examine this class and its policies.

If you just want to use this class browse through the provided examples. It might already provide you with an all ready solution.

Particle filter is a very versatile method, you can use it to do tracking using active contours, template matching in 2-D, 3-D... To take this into account we developed a generic implementation that shall adapt to a broad range of situations and that should save time to the programmer by providing the basic bricks common to different implementations. We thus used the policy idiom which is arguably faster than usual polymorphism since links are established at compile time. It is yet more flexible as it is possible to add unforcast functionalities to our tracking object without deep modifications. As a result the code might be more complex for the library programmer however the user get easier life as you may convince yourself by looking at the examples.

If you want to add building block to the library you may continue to read.

Following, the "raison d'être" of the different template parametres, what they implement and wether they are necessary for the hypothesis_filter class to work:

image_loader policy, to load the sequence of images from where the object of interest is tracked. next()
observer policy, to specify how the object presence is measured for a given location.To evaluate the weight of a particule. An observer policy is used. The validity of the hypothesis (its weight) is measured by the observer. The observer has to give positive weight. This function can be seen as an interface between the filter class and the observer. Hence it is adapted to check here if contract between the two objects is respected. the user is left with the displaying of the image, the image member can be used for this effect, a draw function that might be provided by the observer policiy can be used to display result on the image. The Observer is what will give you the measures on your image. The choice of your observer is fundamental for the result of the filtering.

The number of hypothesis you have to take depends a lot on the choice of your observer and the system you are observing. To give you an idea, for the first application of this class I was using 1000.

As a rule of thumbs, the more hypothesis you have, the better your filtering and the slowler the computation.

See also:

correlation_observer2D

analyse_result policy, to determine how the collected information is filtered to infer the location of the object. To this effect, it provides analyse() which post-process the information extracted by the particle filter (without necessarily modifying it). If the function is not implemented or has a different name it won't affect the hypothesis_filter class.

hypothesis template to implement the hypothesis concept and how hypotheses are drifted
See also:
hypothesis2D
picking policy, to implement the way of selecting the hypothesis that will be used to derive the new hypothesis.
See also:
condensation
compensation policy (cf no_compensation)
pixel template to specify the type of data we are working with (color/grey scale images) (ie rgba<unsigned char>)

See also:

For a theoretical background of particule filtering you can read: CONDENSATION- conditionnal density propagation for visual tracking. by Michael Isard and Andrew Blake. You can go to the condensation algorithm homepage to have an idea of what you can do with hypothesis filtering: https://www.dai.ed.ac.uk/CVonline/LOCAL_COPIES/ISARD1/condensation.html
Selvan, A.N., Boissenin, M., Amavasai, B.P. and Travis J.R., Tracking Translucent Objects in Cluttered Scenes IEEE Conference on Cybernetics Intelligence Challenges and Advances, pp. 110-118, Reading, UK, 17 Sept, 2003.
The policy idiom on the Internet. It explains why so many templates are used.

Author:: Manuel Boissenin

Date:: June 2003

Definition at line 142 of file hypothesis_filter.h.

Constructor & Destructor Documentation

template<template< typename > class image_loader_P, template< typename, typename > class Observer_P, template< typename, typename > class Analyse_result_T, typename Hypothesis_T, template< typename > class Picking_P = condensation, template< typename > class Compensate_P = no_compensation, typename Pixel_T = unsigned char>

mimas::hf::hypothesis_filter< image_loader_P, Observer_P, Analyse_result_T, Hypothesis_T, Picking_P, Compensate_P, Pixel_T >::hypothesis_filter	(	Hypothesis_T &	initial,
		int	n,
		typename image_loader_P< Pixel_T >::set	il_param,
		typename Observer_P< Hypothesis_T, Pixel_T >::set	obs_param,
		typename Analyse_result_T< Hypothesis_T, Pixel_T >::set	analyse_param
	)			`[inline]`

The constructor, you right it looks awful but it does a hell of a lot for you.

Definition at line 194 of file hypothesis_filter.h.

mimas::hf::hypothesis_filter< image_loader_P, Observer_P, Analyse_result_T, Hypothesis_T, Picking_P, Compensate_P, Pixel_T >::hypothesis_filter	(	Hypothesis_T &	initial,
		int	n,
		typename image_loader_P< Pixel_T >::set	il_param
	)			`[inline]`

Definition at line 210 of file hypothesis_filter.h.

mimas::hf::hypothesis_filter< image_loader_P, Observer_P, Analyse_result_T, Hypothesis_T, Picking_P, Compensate_P, Pixel_T >::~hypothesis_filter ( ) [inline]

Definition at line 223 of file hypothesis_filter.h.

Member Function Documentation

template<template< typename > class Image_Loader_P, template< typename, typename > class Observer_P, template< typename, typename > class Analyse_result_T, typename Hypothesis_T, template< typename > class Picking_P, template< typename > class Compensate_P, typename Pixel_T>

double mimas::hf::hypothesis_filter< Image_Loader_P, Observer_P, Analyse_result_T, Hypothesis_T, Picking_P, Compensate_P, Pixel_T >::max_weight ( void )

gives the maximum weight of the particules, can serve to normalise measures for instance.

Complexity: O(nb_hypothesis)

Definition at line 284 of file hypothesis_filter.h.

void mimas::hf::hypothesis_filter< image_loader_P, Observer_P, Analyse_result_T, Hypothesis_T, Picking_P, Compensate_P, Pixel_T >::track ( void ) [inline]

This method is implemented by the compiler only if it is called.

However policies won't necessarily provide the necessary method (here next() or analyse()). The compiler will tell you if it is the case. You may use this method as a reference how to use the hypothesis filter class to track.

Definition at line 160 of file hypothesis_filter.h.

References mimas::hf::hypothesis_filter< image_loader_P, Observer_P, Analyse_result_T, Hypothesis_T, Picking_P, Compensate_P, Pixel_T >::filter().

Here is the call graph for this function:

void mimas::hf::hypothesis_filter< Image_Loader_P, Observer_P, Analyse_result_T, Hypothesis_T, Picking_P, Compensate_P, Pixel_T >::reset ( Hypothesis_T & init )

To re-initialize the filter, very usefull to regroup around one hypothesis the different hypothesis when they are wide-spreaded and the measurment is "good enough".

May reduce the robustness of your tracker if used.

Definition at line 306 of file hypothesis_filter.h.

void mimas::hf::hypothesis_filter< Image_Loader_P, Observer_P, Analyse_result_T, Hypothesis_T, Picking_P, Compensate_P, Pixel_T >::filter ( void )