ParticleFilter< ParticleT >::LowVarianceResamplingPolicy Class Reference
#include <ParticleFilter.h>
Inheritance diagram for ParticleFilter< ParticleT >::LowVarianceResamplingPolicy:
Detailed Description
template<typename ParticleT>
class ParticleFilter< ParticleT >::LowVarianceResamplingPolicy
This class provides a generic, default ResamplingPolicy. It is based on the low variance resampling policy algorithm found in "Probabilistic Robotics" by Sebastian Thrun, Wolfram Burgard, Dieter Fox.
This class is called "low variance" because it will maintain particle modalities in the face of uniform weighting. This means that if resamples are triggered when no new information is available, every particle is resampled for the next generation. This prevents the eventual convergence of particle clusters over time.
However, this implementation provides a varianceScale parameter for adding variance to the particle's state on each generation, which can be useful for more rapidly exploring the state space around a "winning" particle. Ideally, it is better to use a very low resampling variance, and rely on noise in the motion model and a broad probability distribution in the sensor model to allow particles to spread. varianceScale is really a crutch to manage an overconfident sensor model (one which weights "correct" particles with sharply higher values).
The varianceScale parameter defaults to a negative value, which indicates the resampling variance will be scaled with particle weight to provide broader sampling when particle weights are poor, and tighten sampling when particles are tracking accurately. This requires setting a value for minAcceptableWeight, described next.
The other trick this implementation provides is specification of a minimum acceptable particle weight (minAcceptableWeight). If the best particle's weight is below this value, new, randomly generated particles will be created, up to maxRedistribute percent of the particles on a round of resampling. This handles situations where the actual state has somehow jumped out of the region being sampled by the particles, and the filter is "lost". Without some further information (i.e. fixing the MotionModel to predict the "kidnapping"), this can provide automatic re-acquisition of the position in state space. (at the cost of spawning new modalities)
Finally, resampleDelay is provided to limit actual resampling to one in every resampleDelay attempts. This allows you to only resample at a lower frequency than the sensor model, without having to manually track the number of sensor samples and pass a parameter to the ParticleFilter::updateSensors() to limit resampling yourself. The reason you would want to limit the resampling frequency is to better evaluate the particles before selecting them for replication or pruning -- if your sensors are noisy and you resample too often, bad values will kill off good particles on a regular basis, causing the filter to continually be "lost".
This policy can interpret weights in either "log space" or "linear space". It defaults to "log space", but if your sensor model is providing linear weights, set logWeights to false.
Definition at line 286 of file ParticleFilter.h.
Public Member Functions | |
| LowVarianceResamplingPolicy () | |
| constructor | |
| virtual void | resample (particle_collection &particles, index_t &bestIndex) |
| the particle filter will call resample() when the particles have been evaluated and are ready to be selected | |
| bool | nextResampleIsFull () |
| returns true if the next call to resample will trigger a "real" resampling (is resampleCount greater than resampleDelay?) | |
Public Attributes | |
| float | varianceScale |
| If non-negative, passed to the DistributionPolicy's jiggle() for replicated particles; otherwise an "automatic" value is used which inversely scales with the best particle weight. | |
| float | maxRedistribute |
| A percentage (0-1) of the particles which can be randomly re-distributed on a single resampling if the best particle's weight is below minAcceptableWeight. | |
| float | minAcceptableWeight |
| The lowest weight per resample attempt to consider "acceptable". | |
| bool | logWeights |
| This controls the interpretation of particle weights. If true, they are interpreted as "log space", otherwise "linear space". | |
| unsigned int | resampleDelay |
| This indicates how many resampling attempts should be skipped before actually doing it. See class notes for rationale. | |
Protected Attributes | |
| particle_collection | newParticles |
| temporary scratch space as particles are created, and then the collections are swapped | |
| unsigned int | resampleCount |
| the number of resampling attempts which have occurred. | |
Member Data Documentation
| float ParticleFilter< ParticleT >::LowVarianceResamplingPolicy::minAcceptableWeight |
The lowest weight per resample attempt to consider "acceptable".
This is scaled by resampleDelay when being compared to particle weights, so that you don't have to adjust this parameter when you increase resampleDelay. As the best particle weight drops below this value, more particles will be randomly redistributed, up to maxRedistribute.
Definition at line 309 of file ParticleFilter.h.
Referenced by ParticleFilter< ParticleT >::LowVarianceResamplingPolicy::resample(), and ParticleFilter< ParticleT >::setMinAcceptableWeight().
| float ParticleFilter< ParticleT >::LowVarianceResamplingPolicy::varianceScale |
If non-negative, passed to the DistributionPolicy's jiggle() for replicated particles; otherwise an "automatic" value is used which inversely scales with the best particle weight.
A negative value is still used to control the maximum magnitude of the resampling variance. It's better to keep this small (or zero) and rely on the sensor and motion model's noise parameters
Definition at line 301 of file ParticleFilter.h.
Referenced by ParticleFilter< ParticleT >::LowVarianceResamplingPolicy::resample(), and ParticleFilter< ParticleT >::setVarianceScale().
The documentation for this class was generated from the following file:
