EMatrix.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_EMatrix_hh__
#define __BIAS_EMatrix_hh__
#include "bias_config.h" 


#include <Base/Debug/Error.hh>
#include <Base/Debug/Debug.hh>
#include "FMatrix.hh"
#include "RMatrix.hh"
#include "Triangulation.hh"

#define D_EMATRIX_ROT_TRANS 0x80000000

namespace BIAS {
  template <class T> class Quaternion;

  /** @class EMatrix
      @ingroup g_geometry
      @brief class representing an Essential matrix

      A essential matrix describes the orientation and position of 
      two image planes with known calibration. It can be used to estimate 
      the epipolarline and to distinguish between mismatches and 
      probably good matchesbecause there are some type of mismatches which
      are consistent with the epipolar geometry.      
  */
  class BIASGeometry_EXPORT EMatrix : public FMatrix
  {
  public:

    EMatrix() : FMatrix(){};

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

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

    EMatrix(const FMatrixBase &F,  const KMatrix &K1,  const KMatrix &K2)
    { if (InitFromF(F,K1,K2)!=0) this->SetZero(); }

    /** @brief assuming K1 and K2 as calibrations of the cameras which refer to
        the fmatrix, create the nearest valid essential matrix from F */
    int InitFromF(const FMatrixBase &F, const KMatrix &K1, const KMatrix &K2);
    
    /** @brief find R and C(direction), such that maximum number of 3d points
        triangulated from correspondences inlier1 and inlier2 are in front of
        both cameras 
        @return 0=ok, <0 on error, e.g. no triangulation possible */
    int GetRotationTranslation(RMatrix &R, Vector3<double> &C,
                               const std::vector<HomgPoint2D> &inlier1,
                               const std::vector<HomgPoint2D> &inlier2);

    /** @author woelk 07/2006 */
    int GetRotationTranslation(Quaternion<double>& Q, Vector3<double> &C,
                               const std::vector<HomgPoint2D> &inlier1,
                               const std::vector<HomgPoint2D> &inlier2);
    

    inline EMatrix& operator=(const Matrix3x3<FMATRIX_TYPE>& f){
      Matrix3x3<double>::operator=(f);
      return *this; 
    };
    
  };


}

#endif