Ransac.h

Go to the documentation of this file.

/*
 * This file is part of ALVAR, A Library for Virtual and Augmented Reality.
 *
 * Copyright 2007-2012 VTT Technical Research Centre of Finland
 *
 * Contact: VTT Augmented Reality Team <alvar.info@vtt.fi>
 *          <http://www.vtt.fi/multimedia/alvar.html>
 *
 * ALVAR 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.
 *
 * This library 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 ALVAR; if not, see
 * <http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html>.
 */

#ifndef __Ransac_h__
#define __Ransac_h__

#include "Alvar.h"
#include <stdlib.h>

namespace alvar {

class ALVAR_EXPORT RansacImpl {

 protected:
  void** samples;
  void* hypothesis;
  int min_params;
  int max_params;
  int sizeof_param;
  int sizeof_model;

  RansacImpl(int min_params, int max_params, 
             int sizeof_param, int sizeof_model);
  virtual ~RansacImpl();

  int _estimate(void* params, int param_c,
                int support_limit, int max_rounds,
                void* model);

  int _refine(void* params, int param_c,
              int support_limit, int max_rounds,
              void* model, char *inlier_mask = NULL);

  virtual void _doEstimate(void** params, int param_c, void* model) {};
  virtual bool _doSupports(void* param, void* model) { return false; };

  int *indices;

  RansacImpl(int min_params, int max_params, 
             int sizeof_model);

  int _estimate(int param_c,
                int support_limit, int max_rounds,
                void* model);

  int _refine(int param_c,
              int support_limit, int max_rounds,
              void* model, char *inlier_mask = NULL);

  virtual void _doEstimate(int* params, int param_c, void* model) {};
  virtual bool _doSupports(int param, void* model) { return false; };

 public:

  int estimateRequiredRounds(float success_propability,
                             float inlier_percentage);

};

  template <typename MODEL, typename PARAMETER>
    class Ransac : public RansacImpl {

    protected:
    virtual void doEstimate(PARAMETER** params, int param_c, MODEL* model) = 0;

    virtual bool doSupports(PARAMETER* param, MODEL* model) = 0;

    void _doEstimate(void** params, int param_c, void* model) {
      doEstimate((PARAMETER**)params, param_c, (MODEL*)model);
    }

    bool _doSupports(void* param, void* model) {
      return doSupports((PARAMETER*)param, (MODEL*)model);
    }

    public:
    Ransac(int min_params, int max_params) 
      : RansacImpl(min_params, max_params, sizeof(PARAMETER), sizeof(MODEL)) {}

    virtual ~Ransac() {}

    int estimate(PARAMETER* params, int param_c,
                 int support_limit, int max_rounds,
                 MODEL* model) {
      return _estimate(params, param_c, support_limit, max_rounds, model);
    }

    int refine(PARAMETER* params, int param_c,
               int support_limit, int max_rounds,
               MODEL* model, char *inlier_mask = NULL) {
      return _refine(params, param_c, support_limit, max_rounds, model, inlier_mask);
    }

  };


  template <typename MODEL>
    class IndexRansac : public RansacImpl {

  protected:
    virtual void doEstimate(int* params, int param_c, MODEL* model) = 0;

    virtual bool doSupports(int param, MODEL* model) = 0;

    void _doEstimate(int* params, int param_c, void* model) {
      doEstimate(params, param_c, (MODEL*)model);
    }

    bool _doSupports(int param, void* model) {
      return doSupports(param, (MODEL*)model);
    }

  public:
    IndexRansac(int min_params, int max_params) 
      : RansacImpl(min_params, max_params, sizeof(MODEL)) {}

    virtual ~IndexRansac() {}

    int estimate(int param_c,
                 int support_limit, int max_rounds,
                 MODEL* model) {
      return _estimate(param_c, support_limit, max_rounds, model);
    }

    int refine(int param_c,
               int support_limit, int max_rounds,
               MODEL* model, char *inlier_mask = NULL) {
      return _refine(param_c, support_limit, max_rounds, model, inlier_mask);
    }

  };

} // namespace alvar

#endif //__Ransac_h__