FMatrix.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 __BIAS_FMatrix_hh__
#define __BIAS_FMatrix_hh__

#include <bias_config.h>
#include <Base/Geometry/FMatrixBase.hh>
#include <Base/Debug/Error.hh>
#include <Base/Debug/Debug.hh>

#include <Geometry/PMatrix.hh>

#define D_FMATRIX_GETEPIPOLES 0x0001

namespace BIAS {
  /** @class FMatrix
      @ingroup g_geometry
      @brief class representing a Fundamental matrix

      A fundemantal matrix describes the orientation and position of 
      two image planes. It can be used to estimate the epipolarline and to
      distinguish between mismatches and good matches */
  class BIASGeometry_EXPORT FMatrix : public FMatrixBase, public Debug
  {
  public:
    FMatrix() : Debug()
    {};

    explicit FMatrix(const MatrixInitType& i)
      : FMatrixBase(i){};

    FMatrix(const FMatrix& f) : FMatrixBase(f)
    {};
    
    FMatrix(const FMatrixBase& f) : FMatrixBase(f) {};

    FMatrix(const Matrix3x3<FMATRIX_TYPE>& f) : FMatrixBase(f) {};

    /** @brief computes an F matrix from two cameras (defined by arbitrary 
        P matrices, not only metric ones)
        @author koeser 09/2003 */
    FMatrix(BIAS::PMatrix &P1, BIAS::PMatrix &P2) : FMatrixBase() 
    { ComputeFromPMatrices(P1, P2); };
      
    ~FMatrix() {}; 

    FMatrix& operator=(const FMatrix& f);
    
    /** @brief computes an F matrix from two cameras (defined by arbitrary 
        P matrices, not only metric ones)
        @author koeser, updated 07/2004 */
    void ComputeFromPMatrices(BIAS::PMatrix &P1, BIAS::PMatrix &P2);

    /** @brief Computes the epipoles from this F Matrix
        @return 0 on success, <0 if epipoles could not be retrieved
        @author JMF/koeser **/
    int GetEpipoles(HomgPoint2D &Epipole1, HomgPoint2D &Epipole2) const;

    /** @brief same as above, additionally homogenizes epipoles  */
    inline void GetEpipolesHomogenized(HomgPoint2D &E1,
                                       HomgPoint2D &E2) const
    { GetEpipoles(E1, E2); E1.Homogenize(); E2.Homogenize(); };

  
    /** @brief Decomposes f matrix to product (skew)(rank3) */
    void DecomposetoSR(BIAS::Matrix3x3<double> &skew_matrix, 
                       BIAS::Matrix3x3<double> &rank3_matrix);

    /** @brief Returns true if all properties of the F-Matrix are correct,
        at the moment only rank 2 is checked
        @author mdunda 08 2003 **/
    bool IsValid();
    
     
    inline FMatrix& operator=(const Matrix3x3<FMATRIX_TYPE>& f){
      Matrix3x3<double>::operator=(f);
      return *this; 
    }
   
    /** returns residual error as in Zisserman p. 288 */
   double GetResidualError(const std::vector<BIAS::HomgPoint2D> &p1, 
                           const std::vector<BIAS::HomgPoint2D> &p2);
  };



} // namespace BIAS


#endif // __BIAS_FMatrix_hh__