MultiReg.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 __MULTI_REG_H
#define __MULTI_REG_H

#include <stdlib.h>

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

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



#endif