CornerMatcher.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 __CornerMatcher_hh__
#define __CornerMatcher_hh__
#include "bias_config.h" 

#include <Base/Geometry/HomgPoint2D.hh>
#include <Base/Image/Image.hh>
#include <Base/Image/Image.hh>
#include <Image/PyramidImage.hh>
#include "RegionMatcher.hh"

#define D_CORNER_MATCHER_SEARCH     0x0010
#define D_CORNER_MATCHER_KLT        0x0020
#define D_CORNER_MATCHER_PARABOLA   0x0040
#define D_CORNER_MATCHER_PYKLT      0x0080

namespace BIAS {

  /** @class CornerMatcher
      @ingroup g_corresp
      @brief class with various functions to detect corresponding image points.
      This class implements SSD, NCC
  */
  class BIASMatcher2D_EXPORT CornerMatcher : public RegionMatcher
  {
  public:

    CornerMatcher();

    ~CornerMatcher();

    /** wrapper for SSD from RegionMatcher, does boundary checks 
        and casts uses rint to determine location of ssd*/
    template <class StorageType>
    int SSD(const HomgPoint2D& p1, const HomgPoint2D& p2, 
            const Image<StorageType>& im1, const Image<StorageType>& im2, 
            const unsigned int halfwinsize, double& result) const;

    /** wrapper for NCC from RegionMatcher, does boundary checks 
        and casts uses rint to determine location of ncc */
    template <class StorageType>
    int NCC(const HomgPoint2D& p1, const HomgPoint2D& p2, 
            const Image<StorageType>& im1, const Image<StorageType>& im2, 
            const unsigned int halfwinsize, double& result) const;

    /** wrapper for RegionMatcher::NCCSearchOdd/NCCSearchEven, 
        does boundary checks and casts     */
    template <class StorageType>
    int NCCSearch(const HomgPoint2D& p1, const HomgPoint2D& p2, 
                  const Image<StorageType>& im1, const Image<StorageType>& im2, 
                  const unsigned int halfnccwinsizeconst, 
                  const unsigned int halfsearchwinsize, 
                  HomgPoint2D& resultpoint, 
                  const double mincorrelation, 
                  double & result );

    /** wrapper with range checking for RegionMatcher::KLT 
        for a description see RegionMatcher::KLT
        gradientborder is the halfwinsize of the gradient filter mask */
    //    template <class StorageType>
//     int KLT(HomgPoint2D& p1, HomgPoint2D& p2, Image<StorageType>& im1, 
//             Image<StorageType>& im2, Image<StorageType>& gradx, 
//             Image<StorageType>& grady, unsigned int halfwinsize,
//             unsigned int gradientborder, unsigned int numiterations, 
//             HomgPoint2D& result, KLT_TYPE& error);

//     /** as above, but iterates until either maxerror or maxnumiterations is
//         reached */
//     template <class StorageType>
//     int KLT(HomgPoint2D& p1, HomgPoint2D& p2, Image<StorageType>& im1, 
//             Image<StorageType>& im2, Image<StorageType>& gradx, 
//             Image<StorageType>& grady, unsigned int halfwinsize,
//             unsigned int gradientborder, unsigned int maxnumiterations, 
//             KLT_TYPE maxerror, HomgPoint2D& result, KLT_TYPE& error);

//     /** wrapper for RegionMatcher::KLT2 and pyramid images
//         @authopr woelk 10/2003 */
//     template <class StorageType>
//     int KLT2(KLT_TYPE p1[2], KLT_TYPE p2[2], PyramidImage2<StorageType>& im1,
//              PyramidImage2<StorageType>& im2, PyramidImage2<StorageType>& gx1,
//              PyramidImage2<StorageType>& gy1, PyramidImage2<StorageType>& gx2,
//              PyramidImage2<StorageType>& gy2, unsigned pyindex, unsigned hws,
//              unsigned maxiterations, double SADThresh, KLT_TYPE maxerror, 
//              KLT_TYPE res[2], KLT_TYPE& error);

    /** wrapper for RegionMatcher::ParabolaNCC */
    template <class StorageType>
    int ParabolaNCC(const HomgPoint2D& p1, const HomgPoint2D& p2, 
                    const Image<StorageType>& im1, 
                    const Image<StorageType>& im2, 
                    const unsigned int halfwinsize,
                    HomgPoint2D& result) const;

    /** wrapper for RegionMatcher::ParabolaNCC5 */
    template <class StorageType>
    int ParabolaNCC5(const HomgPoint2D& p1, const HomgPoint2D& p2, 
                     const Image<StorageType>& im1,
                     const Image<StorageType>& im2, 
                     const unsigned int halfwinsize,
                     HomgPoint2D& result) const;

    /** Assumes that ps1 is fully filled.
        The matches on the smallest pyramid level must be given, 
        i.e. matches[im1.size()-1][i] must correspond to ps1[im1.size()-1][i]
        with correlation quality matchquality[i].
        It then propagates the matches to the upper (bigger) pyramid levels
        using ncc correlation.
        @author woelk 05 2003 */
    template <class StorageType>
    int RefinePyramideNCC(std::vector<std::vector<HomgPoint2D> >& ps1,
                          PyramidImage<StorageType>& im1, 
                          PyramidImage<StorageType>& im2,
                          unsigned int halfnccwinsize, 
                          std::vector<std::vector<HomgPoint2D> >& matches,
                          std::vector<std::vector<double> >& matchquality);
 
    
  }; // class
} // namespace
#endif // __CornerMatcher_hh__