ExampleRANSAC_double.hh

/* 
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003, 2004    (see file CONTACTS for details)
  Multimediale Systeme der Informationsverarbeitung
  Institut fuer Informatik
  Christian-Albrechts-Universitaet Kiel


BIAS is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

BIAS is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef __ExampleRANSAC_double_hh__
#define __ExampleRANSAC_double_hh__

#include "MathAlgo/RANSAC.hh"

namespace BIAS {

  /** @class RANSAC_double
      @brief Robust mean computation for double values using RANSAC.
      
      This class implements a simple example for RANSAC class overloading.

      Method RANSAC_double::GetSampleSolutions picks a number of values
      and computes the mean from them. The sample size is not fixed here
      but can be chosen when calling method RANSAC_double::Init.

      Method RANSAC_double::EvaluateSolution evaluates how many values are
      considered as "inliers" with respect to the mean hypothesis, i.e.
      their distance to the mean does not exceed a certain threshold.
      
      In RANSAC_double::RefineSolution the mean is recomputed for all inliers.
      
      You have to set the inlier threshold (max. distance to mean to accept
      a value as being an inlier) and the fraction of valid input values
      which will define the number of samples evaluated by RANSAC.      

      @author MIP
  */
  class RANSAC_double : public RANSAC<double>
  {
  public:
   
    RANSAC_double();

    ~RANSAC_double();

    void Init(std::vector<double>& data, unsigned int sample_size,
              double inlier_distance_threshold, bool refine_solution, 
              double expected_inlier_fraction,
              double solution_error_threshold);

    virtual int GetSampleSolutions(std::vector<unsigned int> &which_samples,
                                   std::vector<double> &solutions);

    virtual bool EvaluateSolution(const double& solution,  
                                  bool existing_solution_flag,
                                  std::vector<bool>& inlier,    
                                  int& accept_count,
                                  double& evaluate_score,
                                  bool& ok_to_terminate_flag);

    virtual bool RefineSolution(std::vector<unsigned int>& which_samples,
                                double& solution,
                                std::vector<bool>& new_inliers);

  protected:

    // @brief Vector of all input values to compute the robust mean for
    std::vector<double> _vData; 

    // @brief Data closer to solution than this threshold is regarded as inlier
    double _dInlierDistanceThreshold;

    // @brief If a sample yields more than _dExpectedInlierFraction inliers and 
    // the evaluate_score is lower than _dSolutionErrorThreshold, RANSAC will stop
    double _dExpectedInlierFraction;
    double _dSolutionErrorThreshold;
  };
  
  RANSAC_double::RANSAC_double() : RANSAC<double>()
  {}

  RANSAC_double::~RANSAC_double() 
  {}

  void RANSAC_double::Init(std::vector<double>& data,
                           unsigned int sample_size,
                           double inlier_distance_threshold, 
                           bool refine_solution,
                           double expected_inlier_fraction, 
                           double solution_error_threshold)
  {
    RANSAC<double>::Init(sample_size, 1, refine_solution);
    _vData = data;
    _uiDataSize = data.size();
    _dInlierDistanceThreshold = inlier_distance_threshold;
    _dExpectedInlierFraction = expected_inlier_fraction;
    _dSolutionErrorThreshold = solution_error_threshold;
  }
  
  int RANSAC_double::
  GetSampleSolutions(std::vector<unsigned int> &which_samples,
                     std::vector<double> &solutions)
  {
    double mean = 0.0;
    for (unsigned int i = 0; i < which_samples.size(); i++)
      mean += _vData[which_samples[i]];
    mean /= which_samples.size();
    solutions.clear();
    solutions.push_back(mean);
    return solutions.size();
  }

  bool RANSAC_double::
  EvaluateSolution(const double& solution,  
                   bool existing_solution_flag,
                   std::vector<bool>& inlier,    
                   int& accept_count,
                   double& evaluate_score,
                   bool& ok_to_terminate_flag)
  {
    bool good_flag = true;
    inlier.clear();
    inlier.resize(_uiDataSize);

    int my_accept_count = 0;
    evaluate_score = 0.0;

    for (unsigned int i = 0; i < _uiDataSize; i++){
      inlier[i] = (fabs(solution-_vData[i]) < _dInlierDistanceThreshold);
      if (inlier[i]) {
        my_accept_count++;
        evaluate_score += fabs(solution-_vData[i]);
        if (existing_solution_flag && my_accept_count > accept_count) break;
      }
    }
    if (my_accept_count!=0) {
      evaluate_score /= my_accept_count;
    } else {
      evaluate_score = DBL_MAX;
      good_flag = false;
    }
    accept_count = my_accept_count;
    
    ok_to_terminate_flag =
      (((accept_count/(double)_uiDataSize) > _dExpectedInlierFraction) &&
       (evaluate_score < _dSolutionErrorThreshold));
    
    return good_flag;
  }

  bool RANSAC_double::
  RefineSolution(std::vector<unsigned int>& which_samples,
                 double& solution, std::vector<bool>& new_inliers)
  {
    solution = 0.0;
    for (unsigned int i = 0; i < which_samples.size(); i++)
      solution += _vData[which_samples[i]];
    solution /= which_samples.size();
    
    new_inliers.clear();
    new_inliers.resize(_uiDataSize);
    for (unsigned int i = 0; i < _uiDataSize; i++)
      new_inliers[i] = (fabs(solution-_vData[i]) < _dInlierDistanceThreshold);

    return true;
  }

} // namespace 

#endif // __ExampleRANSAC_double_hh__