Parametrization.hh

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

Copyright (C) 2003-2009    (see file CONTACT 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 __Parametrization_hh__
#define __Parametrization_hh__

#include <Base/Common/BIASpragmaStart.hh>

#include <vector>

#include "FMatrix.hh"
#include "HMatrix.hh"
#include "EMatrix.hh"

namespace BIAS
{

#define NUM_PARAM_ESSENTIAL 5
#define MINIMUM_ROTATION 1e-6

/** This class is used for parametrizing F- and H-matrices, generally for
    optimization purposes.
    Be sure to use one and the same instance of this class for parametrization
    and deparametrization of your matrix!!!
    This parametrization is needed during the MotionModelSelection which
    is part of my diploma thesis.
    @author Matthias Dunda
    @date 09 2003 */
  class BIASGeometry_EXPORT Parametrization
  {
  public:
    Parametrization();
    ~Parametrization();
    
    /** parametizes an F-matrix to seven parameters
        @return true on success, false on error
        @author mdunda 09 2003 */
    bool FMatrixToParams( const BIAS::FMatrix &Mat,
                          std::vector<double> &Params );
    
    /** composes an F-matrix from the seven given parameters
        The deparametrization only works with the previously parametized
        values of 'FMatrixToParams', because some internally stored
        parameters are important for the correct composition.
        @return true on success, false on error
        @author mdunda 09 2003 */
    bool ParamsToFMatrix( BIAS::FMatrix &Mat,
                          const std::vector<double> &Params );
    
    /** parametizes an H-matrix to eight parameters
        @return true on success, false on error
        @author mdunda 09 2003 */
    bool HMatrixToParams( const BIAS::HMatrix &Mat,
                          std::vector<double> &Params );
    
    /** composes an H-matrix from the seven given parameters
        @return true on success, false on error
        @author mdunda 09 2003 */
    bool ParamsToHMatrix( BIAS::HMatrix &Mat,
                          const std::vector<double> &Params );

     /** parametizes an essential-matrix to five parameters
        @return true on success, false on error
        @author frahm 03 2004 */
    static bool EMatrixToParams( BIAS::EMatrix &Mat,
                                 Vector<double> &Params, 
                                 std::vector<BIAS::HomgPoint2D> &inlier1,
                                 std::vector<BIAS::HomgPoint2D> &inlier2,
                                 bool UseQuaternion = false);
    
    /** composes an essential-matrix from the five given parameters
        @return true on success, false on error
        @author frahm 03 2004 */
    static bool ParamsToEMatrix( BIAS::EMatrix &Mat,
                                 const Vector<double> &Params,
                                 bool UseQuaternion = false);
    
    inline double GetFScaling() { return Fscale_; }
    inline double GetHScaling() { return Hscale_; }
    
  protected:
    // protected attributes for F-matrix parametrization
    BIAS::FMatrix F_;
    std::vector<double> FParams_;
    
    /* the next variables hold the position of the element in the F matrix 
       that was used for the normalization */
    int Frow_,Fcol_;
    
    // protected attributes for H-matrix parametrization
    BIAS::HMatrix H_;
    std::vector<double> HParams_;
    
    // protected methods (helpers)
    /** Find the biggest absolute entry of the upper left 2x2 submatrix of 
        the internally stored F matrix member.
        The position of this element is stored internally and used for
        the composition of the F matrix in ParamsToFMatrix.
        @return value of the entry with biggest absolute value
        @author mdunda 09 2003 */
    double GetBiggestAbsEntry();
    double Fscale_;
    double Hscale_;
  }; // class Parametrization
} // namespace BIAS

#include <Base/Common/BIASpragmaEnd.hh>

#endif /* __Parametrization_hh__ */