ProbMultiReg.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// $Id$
//
// Copyright 2008, 2009, 2010, 2011, 2012  Antonio Franchi and Paolo Stegagno    
//
// This file is part of MIP.
//
// MIP is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// MIP 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with MIP. If not, see <http://www.gnu.org/licenses/>.
//
// Contact info: antonio.franchi@tuebingen.mpg.de stegagno@diag.uniroma1.it
//
// ----------------------------------------------------------------------------





#ifndef __PROB_MULTI_REG_H
#define __PROB_MULTI_REG_H


#ifdef MIP_HOST_APPLE
#include <applePatch.h>
#endif

#include <map>

#include <Spaces.h>
#include <BiReg.h>
#include <BiRegRANSAC.h>
#include "MultiRegSol.h"

using namespace std;

namespace MipAlgorithms{
 
 /* @{ */
 
 class ProbMultiRegPar {
  private:
   Decimal _linearTollerance;
   Decimal _angularTollerance;
   Decimal _maxVisuale;    // 8
   Decimal _discretization;// 5
   Decimal _discretizationStep;
  
  public:
   ProbMultiRegPar();
   
   ProbMultiRegPar(Decimal lt, Decimal at, Decimal mV, Decimal di, Decimal ds);
   
   ProbMultiRegPar(const ProbMultiRegPar &A);
   
   ProbMultiRegPar operator= (ProbMultiRegPar A);
   
   Decimal linearTollerance(){ return _linearTollerance; }
   
   Decimal angularTollerance(){ return _angularTollerance; }
   
   Decimal maxVisuale(){ return _maxVisuale; }
   
   Decimal discretization(){ return _discretization; }
   
   Decimal discretizationStep(){ return _discretizationStep; }
 };
 
 
 class ProbMultiRegStepInput {
  
  public:
   int num;
   Observation obsLoc;
   vector< Observation >* obse;
   BiRegSol form;
   MultiRegSol *solution;
   DDubIntList *dubshortlist;
   int firstNewDot;
   
   
   ProbMultiRegStepInput();
   
   ProbMultiRegStepInput(const ProbMultiRegStepInput &A);
   
   ProbMultiRegStepInput(int n, Observation oL, vector< Observation >* o, BiRegSol f, MultiRegSol *so, DDubIntList *dsl, int fND);
   
   ProbMultiRegStepInput  operator= (ProbMultiRegStepInput A);
 };
 
 
 class ProbMultiReg {
  
  public:
   ProbMultiRegPar par;
   BiReg *biReg;
   
   
   ProbMultiReg();
   
   ProbMultiReg(ProbMultiRegPar p);
   
   ProbMultiReg(ProbMultiRegPar p, BiRegPar pa);
   
   ProbMultiReg(ProbMultiRegPar p, BiRegPar pa, BiRegType bType);
   
   ~ProbMultiReg();
   
   void registration(vector <Observation> observ, MultiRegSol *mrsols, int localizator = 0);
   
   void verboseOn(){ verbose = true; }
   
   void verboseOff(){ verbose = false; }
   
   void setLikelihood(vector<int>& ids, map <int, vector<Pose> >* lik);
   
  private:
   
   map <int, vector<Pose> > *likelihood;
   vector <int> activeLikelihoods;
   
   bool verbose;
   
   // a step of the multiple registration algorithm
   void step(ProbMultiRegStepInput &in);
   
   //
  public:
   void leastMeanSquare(Observation obs0, Observation obs1, BiRegOut* sol);  // TODO DA MODIFICARE IL CALCOLO DELLA SVD
   
  private:
   //
   Decimal computeProbability(Pose measure, int id);
 };
 
 /* @} */
 
 
};// end namespace MipAlgorithms



#endif