BiReg.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 __BI_REG_H
#define __BI_REG_H

#include <Spaces.h>

namespace MipAlgorithms{
 
 /* @{ */
 
 enum BiRegType {
  UNINIT_BIREG,
  RANSAC_BIREG,
  BIREG_NUM
 };
 
 static const char* BiRegNames[BIREG_NUM] = {
  "UninitializedRansac",
  "BiRegRansac"
 };
 
 
 class DDubInt {
  protected: 
   DubInt _m;
   Decimal _dist;
  
  public:
   Decimal dist();
   
   int m1();
   
   int m2();
  
   DubInt m();
   
   DDubInt();
   
   DDubInt(int a, int b, Decimal c);
   
   DDubInt(const DDubInt &db);
   
   DDubInt operator= (DDubInt db);
   
   string print();
 };
 
 
 class DDubIntListPar{
  public:
   Decimal discretization;
   Decimal maxDist;
   Decimal discToll;
   
   DDubIntListPar();
   
   DDubIntListPar(Decimal disc, Decimal mD, Decimal dToll);
   
   void operator= (DDubIntListPar A);
 };
 
 
 class DDubIntList : public vector < vector < DDubInt > >{
  
  public:
   
   DDubIntListPar par;
   
   DDubIntList();
   
   DDubIntList(Observation &obs, DDubIntListPar p);
   
   DDubIntList(DDubIntList &d);
   
   void update(Observation &obs, int firstNewDot);
   
   string print();
 };
 
 
 class BiRegOut{
   
  protected:
   Decimal _x; 
   Decimal _y;
   Angle _rot;
   int _id;
   
   vector<int> _inlier;
   int _numInliers;
   
  public:
   
   Decimal x(void);
   
   Decimal y(void);
   
   Angle rot(void);
   
   int id(void);
   
   int numInliers(void);
   
   int inlier(int i);
   
   int size();
   
   void setX(Decimal a);
   
   void setY(Decimal a);
   
   void setRot(Angle a);
   
   void setId(int a);
   
   void setNumInliers(int a);
   
   void clear();
   
   void resize(int i);
   
   void setInlier(int i, int a);
   
   
   BiRegOut();
   
   BiRegOut(const BiRegOut &A);
   
   ~BiRegOut();
   
   void operator= (BiRegOut A);
   
   bool operator!= (BiRegOut A);
   
   string print();
   
   void init();
 };
 
 
 class BiRegSol : public vector <BiRegOut>{
   
  public:
   BiRegSol();
   
   BiRegSol(int a);
   
   string print();
 };
 
 
 class BiRegIn{
  public:
   
   Observation obs0;
   Observation obs1;
   
   vector< vector <DDubInt> > *dubshortlist;
   
   BiRegIn();
   
   BiRegIn(Observation o0, Observation o1, vector< vector <DDubInt> > *dsh);
 };
 
 
 class BiRegPar {
  
  public:
   Decimal linThld;
   Angle angThld;
   int obs0Trials;
   int obs1Trials;
   int minInliersNum;
   Decimal discStep;
   Decimal prewrpToll;
   
   BiRegPar(){
    linThld  = 0.1;
    angThld  = 0.1;
    obs0Trials = 10;
    obs1Trials = 10;
    minInliersNum = 3;
    discStep = 5.0;
    prewrpToll = 0.05;
   }
   BiRegPar(Decimal lTh, Decimal aTh, int o0T, int o1T, int mInlNum, Decimal dSt, Decimal pw);
   
   BiRegPar(const BiRegPar &A);
   
   BiRegPar operator= (BiRegPar A);
 };
 
 
 class BiReg {
   
   BiRegType type;
   
  protected:
   
   BiRegPar par;
   
   bool verbose;
   
   void setType(BiRegType t);
   
  public:
   
   BiReg();
   
   BiReg(BiRegPar BRP);
   
   BiRegType getType();
   
   virtual void registration(BiRegIn &in, BiRegSol *solution) = 0;
   
   void verboseOn();
   
   void verboseOff();
 };
 
 /* @} */
 
}; // end namespace MipAlgorithms

#endif