MatchDataBase.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 __MatchDataBase_hh__
#define __MatchDataBase_hh__

#include <bias_config.h>
#include <Base/Debug/Debug.hh>
#include <Base/Geometry/HomgPoint2D.hh>
#include <Base/Geometry/HomgPoint3D.hh>
#include <Base/Geometry/KMatrix.hh>
#include <Base/Geometry/RMatrixBase.hh>
#include <Base/Geometry/PMatrixBase.hh>
#include <Utils/Param.hh>

#define D_MD_IO 0x00000001

namespace BIAS {
  
  /** @class MatchDataBase
      @ingroup g_utils
      @brief class for representing matches, used in GenSynthMatches and biasshowsm
      @author woelk 2004 */
  class BIASUtils_EXPORT MatchDataBase : public Debug
  {
  public:
    MatchDataBase(Param &para);
    virtual ~MatchDataBase();

    void Reset();
    
    void GetK(KMatrix& K) const;
    
    void GetR(int imNo, RMatrixBase& R) const;
    void GetR(std::vector<RMatrixBase>& R) const;

    void GetC(int imNo, HomgPoint3D& C) const;
    void GetC(std::vector<HomgPoint3D>& C) const;

    void GetP(int imNo, PMatrixBase& P) const;
    void GetP(std::vector<PMatrixBase>& P) const;

    void GetPoints(int imNo, std::vector<HomgPoint2D>& p) const;
    /// p[i][k] is point number k in image i
    void GetPoints(std::vector<std::vector<HomgPoint2D> >& p) const;
    /// same as GetPOints with inverted indices :
    /// p[i][k] is point number i in image k
    void GetCorrespondences(std::vector<std::vector<HomgPoint2D> >& p) const;

    void GetNormalizedPoints(int imNo, std::vector<HomgPoint2D>& p) const;
    /// p[i][k] is point number k in image i
    void GetNormalizedPoints(std::vector<std::vector<HomgPoint2D> >& p) const;
    /// same as GetNormalizedPoints with inverted indices :
    /// p[i][k] is point number i in image k
    void GetNormalizedCorrespondences(std::vector<std::vector<HomgPoint2D> >& p) const;


    void SetData(KMatrix& K, std::vector<RMatrixBase>& R, 
                 std::vector<HomgPoint3D>& C,
                 std::vector<std::vector<HomgPoint2D> >& m);

    void SetNormalizedData(KMatrix& K, std::vector<RMatrixBase>& R, 
                           std::vector<HomgPoint3D>& C, 
                           std::vector<std::vector<HomgPoint2D> >& m);

    inline int GetNumImages() const
    { return *_NumImages; }

    /// binary read 
    int Read(const std::string& fname);
    /// binary read 
    virtual int Read(std::istream& is);

    /// binary write 
    int Write(const std::string& fname) const;
    /// binary write 
    virtual int Write(std::ostream& os) const;

    friend BIASUtils_EXPORT std::ostream& operator<<(std::ostream& os, const MatchDataBase& m);

    friend BIASUtils_EXPORT std::istream& operator>>(std::istream& is, MatchDataBase& m);

    bool operator==(MatchDataBase& l);

  protected:
    int *_NumImages, *_NumPoints;

    // internal calibration matrix
    KMatrix _K, _Ki; // _Ki is inverse of _K
    // vector of rotation matrizes of cameras
    std::vector<RMatrixBase> _R;
    // vector of camera centers
    std::vector<HomgPoint3D> _C;
    // vector of projection matrizes, composed from _K, _R[i] and _C[i]
    std::vector<PMatrixBase> _P;

    // the generated match data
    // _Points[k][i] is point number i in image k
    std::vector<std::vector<HomgPoint2D> > _Points;
    std::vector<std::vector<HomgPoint2D> > _NormalizedPoints;

    void _SetCamData(KMatrix& K, std::vector<RMatrixBase>& R, 
                     std::vector<HomgPoint3D>& C);

    // fills all protected pointer values
    virtual void _AddParameter(Param &para);

    inline void _Transpose(const std::vector<std::vector<HomgPoint2D> >& src, 
                           std::vector<std::vector<HomgPoint2D> >& dst) const
    {
      const int numimg=(int)src.size();
      if (numimg>0){
        const int numpoints=(int)src[0].size();
        dst.resize(numpoints);
        for (int i=0; i<numpoints; i++){
          dst[i].resize(numimg);
          for (int k=0; k<numimg; k++){
            dst[i][k]=src[k][i];
          }
        }
      }
    }
                           
  }; // class

  BIASUtils_EXPORT std::ostream& operator<<(std::ostream& os, const MatchDataBase& m);

  BIASUtils_EXPORT std::istream& operator>>(std::istream& is, MatchDataBase& m);
  
  
  
} // namespace


#endif // __MatchDataBase_hh__