TrackerBaseAffine2.hh

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

Copyright (C) 2003, 2004    (see file CONTACTS 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 __TrackerBaseAffine2_hh__
#define __TrackerBaseAffine2_hh__

#include <Matcher2D/TrackerBaseInterface.hh>
#include <Image/PyramidImage.hh>
  
namespace BIAS {

  /** @class TrackerBaseAffine2
      @ingroup g_tracker
      @brief devel version of antialiased affine tracker
      @author koeser 10/2007 */
  template <class StorageType>
  class BIASMatcher2D_EXPORT TrackerBaseAffine2 
    : public TrackerBaseInterface<StorageType>
  {
  public:
    TrackerBaseAffine2(bool only4params = false);

    /** Estimate all 6 parameters or only 4? */
    inline void SetOnly4(bool Only4) { _SimilarityTransformOnly = Only4; }
    inline void SetMaxAffineChange(const KLT_TYPE maxerr) { 
      _MaxAffineChange=maxerr;
    }

    /** enable brightness variance and offset invariant computation */
    virtual void SetAffineBrightnessInvariance(bool bi) { 
      _AffineBrightnessInvariance = bi;
    }

    inline bool IsSimilarityTransformOnly() {
      return _SimilarityTransformOnly ;
    }
    

    inline void SetRegion1(const Matrix3x3<double>& R1){
      R1_ = R1;
      affineNormalization_ = true;
    }

    inline void UnsetRegion1(){
      R1_.SetIdentity();
      affineNormalization_ = false;
    }

    inline void SetInitialUncertainty(const Matrix<double>& Cov) {
      initialCov_ = Cov;
    }

  protected:
    /// iteration stops if position refinement is less than *_Maxerror
    KLT_TYPE _MaxAffineChange; 

    /// Estimate all 6 parameters or only 4?
    bool _SimilarityTransformOnly;

    /// workaround: save values from Track_ so we dont lose them
    Matrix<KLT_TYPE> Cov_;
    KLT_TYPE residuumMAD_;
    KLT_TYPE residuumMSD_;

    Matrix3x3<double> R1_;
    bool affineNormalization_;

    PyramidImage<StorageType> _pim1, _pgradim1x, _pgradim1y, 
      _pim2, _pgradim2x, _pgradim2y;


    Matrix<double> initialCov_;

    /** @brief fill in computed residui from Track_ */
    virtual void EvaluateResult_(KLT_TYPE& mad,KLT_TYPE& msd, 
                                 Matrix<KLT_TYPE>& cov);


    virtual int Track_(Vector2<KLT_TYPE>& p1, Vector2<KLT_TYPE>& p2,
                       Vector2<KLT_TYPE>& result, KLT_TYPE& error, 
                       int &iter,
                       const Matrix2x2<KLT_TYPE>& AffinePred,
                       Matrix2x2<KLT_TYPE>& AffineResult);

    /** @brief track using affine warp
        @param p1 point in image 1
        @param p2 prediction for point in image 2
        @param p2A prediction for affine warp
        @param result result after tracking
        @param resultA affine warp after tracking
        @param error maxnorm of last iteration step
        @param iter number of iterations done
        @param Cov resulting covariance
        @param sad sum of absolute differences
        @param ssd sum of squared differences
        @param SimilarityTransformOnly only estimate A, not dx,dy
        @param ComputeCovariance, if true Cov is computed using svd

        This implementation is based on Thorsten Thormaelen's version,
        see cpp file.

        @author koeser 06/2005
    */
    int TrackAffine_(KLT_TYPE p1[2], KLT_TYPE p2[2], 
                     const Matrix2x2<KLT_TYPE>& p2A,
                     KLT_TYPE result[2],  Matrix2x2<KLT_TYPE>& resultA,
                     KLT_TYPE& error, int &iter, Matrix<KLT_TYPE>& Cov,
                     KLT_TYPE& mad, KLT_TYPE& msd,
                     bool SimilarityTransformOnly = false, 
                     bool ComputeCovariance = true);

     // ------------ affine worker functions ----------------------------
    void GetGradientWinAffine_(const KLT_TYPE& x, const KLT_TYPE& y,
                               const KLT_TYPE& Axx, const KLT_TYPE& Ayx,
                               const KLT_TYPE& Axy, const KLT_TYPE& Ayy,   
                               const int halfwidth, const int halfheight,
                               KLT_TYPE* imgdiff, 
                               KLT_TYPE* out_gradx,     
                               KLT_TYPE* out_grady,
                               const Matrix<double>& Cov);   

  
    void BilinearRegion1_(KLT_TYPE x, KLT_TYPE y, 
                          int hws, const Vector<double>& par,
                          const Matrix<double>& Cov);
    
    using TrackerBaseInterface<StorageType>::_HalfWinSize;
    using TrackerBaseInterface<StorageType>::_MaxIterations;
    using TrackerBaseInterface<StorageType>::_MaxError;
    using TrackerBaseInterface<StorageType>::_MaxResiduumMAD;
    using TrackerBaseInterface<StorageType>::_RejectionType;
    using TrackerBaseInterface<StorageType>::_maxx1;
    using TrackerBaseInterface<StorageType>::_maxy1;
    using TrackerBaseInterface<StorageType>::_minx1;
    using TrackerBaseInterface<StorageType>::_miny1;
    using TrackerBaseInterface<StorageType>::_maxx2;
    using TrackerBaseInterface<StorageType>::_maxy2;
    using TrackerBaseInterface<StorageType>::_minx2;
    using TrackerBaseInterface<StorageType>::_miny2;
    using TrackerBaseInterface<StorageType>::_LastHalfWinSize;
    using TrackerBaseInterface<StorageType>::_WinSize;
    using TrackerBaseInterface<StorageType>::_gx;
    using TrackerBaseInterface<StorageType>::_gy;
    using TrackerBaseInterface<StorageType>::_bl1;
    using TrackerBaseInterface<StorageType>::_bl2;
    using TrackerBaseInterface<StorageType>::_gx1;
    using TrackerBaseInterface<StorageType>::_gy1;
    using TrackerBaseInterface<StorageType>::_gx2;
    using TrackerBaseInterface<StorageType>::_gy2;
    using TrackerBaseInterface<StorageType>::_gsx;
    using TrackerBaseInterface<StorageType>::_gsy;
    using TrackerBaseInterface<StorageType>::_gxx;
    using TrackerBaseInterface<StorageType>::_gxy;
    using TrackerBaseInterface<StorageType>::_gyy;
    using TrackerBaseInterface<StorageType>::_idet;
    using TrackerBaseInterface<StorageType>::BilinearRegion1_;
    using TrackerBaseInterface<StorageType>::BilinearRegion2_;
    using TrackerBaseInterface<StorageType>::_im1;
    using TrackerBaseInterface<StorageType>::_im2;
    using TrackerBaseInterface<StorageType>::_ComputeFilteredImages;
    using TrackerBaseInterface<StorageType>::_gradim2x;
    using TrackerBaseInterface<StorageType>::_gradim2y;
    using TrackerBaseInterface<StorageType>::_AffineBrightnessInvariance;
    using TrackerBaseInterface<StorageType>::mean1_;
    using TrackerBaseInterface<StorageType>::mean2_;
    using TrackerBaseInterface<StorageType>::dev1_;
    using TrackerBaseInterface<StorageType>::dev2_;
  };
}

#endif // __TrackerBaseAffine2_hh__