AffineMapping.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
 */

#include <Base/Common/BIASpragmaStart.hh>

#ifndef __AffineMapping_hh__
#define __AffineMapping_hh__

#include <Image/BackwardMapping.hh>

namespace BIAS
{

  /** @class AffineMapping
   @ingroup g_filter
   @brief  Maps image src to image sink with affine transformation

   MapDirect takes care of correct filtering and texture preservation for
   grey images (efficient anisotropic filtering)
   @author koeser 01/2007
   */
  template<class InputStorageType, class OutputStorageType>
    class BIASImage_EXPORT AffineMapping : public BackwardMapping<
        InputStorageType, OutputStorageType>
    {
    public:

      virtual
      ~AffineMapping();

      AffineMapping();

      /**  required because assignment is
       @author Jan Woetzel */
      AffineMapping(const AffineMapping & src)
      {
        (*this) = src;
      }

      /**  required because of const members
       @author Jan Woetzel */
      AffineMapping<InputStorageType, OutputStorageType> &
      operator=(const AffineMapping & src)
      {
          BIASERR ( "dont copy me - not implemented." );
          BIASABORT;
        return *this;
      }

      /** @brief set A  (source = A * sink) before calling Map()*/
      inline void
      SetAffineTransformation(const double&a11, const double&a12,
          const double&a21, const double&a22, const double& dx,
          const double& dy)
      {
        a11_ = a11;
        a12_ = a12;
        a21_ = a21;
        a22_ = a22;
        dx_ = dx;
        dy_ = dy;
      }
      ;

      /** @brief direct, fast implementation of affine backward mapping with
       anisotropic filtering, one channel grey only */
      int
      MapDirect(const Image<InputStorageType>& src,
          Image<OutputStorageType>& sink);

      /** @brief after first MapDirect, call this function to reuse last pyramid*/
      int
      MapDirectAgain(Image<OutputStorageType>& sink);

      /** @brief direct, fast implementation of affine backward mapping with
       bilinear filtering, one channel grey only */
      int
      BilinearGrey(const Image<InputStorageType>& src,
          Image<OutputStorageType>& sink);

      /** @brief direct, fast implementation of affine backward mapping with
       bilinear filtering, one channel grey only */
      int
      TrilinearGrey(const Image<InputStorageType>& src,
          Image<OutputStorageType>& sink, double scale = -1.0);
      /** @brief after first TrilinearGrey, call this function to reuse
       last pyramid*/
      int
      TrilinearGreyAgain(Image<OutputStorageType>& sink, double scale = -1.0);

      /** @brief computes local stretching factors, large >> 1 means that the
       sink image can contain significant aliasing when using bilinear
       @param cosphi cosine of angle between x-axis and largest scale
       @param costheta upper bound on rotation after scaling, cf HMatrix
       */
      int
      ComputeScales(double& large, double& smallN, double& cosphi,
          double& costheta) const;

      /** calculates the bounding box in sink image,
       where to do the backward mapping.
       The resulting coordinates must be valid in sink, and the resulting
       br position should be outside the region.
       @author grest, Nov. 2005
       */
      virtual int
      GetBoundingBox(unsigned int srcwidth, unsigned int srcheight,
          unsigned int sinkwidth, unsigned int sinkheight, int &tlx, int &tly,
          int &brx, int &bry);

    protected:
      /** @brief reimplementation for homography, takes sink and computes
       coords in source */
      virtual int
      GetSourceCoordinates_(const HomgPoint2D& sink, HomgPoint2D& source) const;

      /** @brief analytic jacobian */
      virtual int
      GetJacobian_(const HomgPoint2D& sink, Matrix2x2<double>& Jacobian) const;

      /// the homography for backward mapping: run over sink and compute
      /// source = A * sink + d
      double a11_;
      double a12_;
      double a21_;
      double a22_;
      double dx_;
      double dy_;

      using BackwardMapping<InputStorageType, OutputStorageType>::offsetX_;
      using BackwardMapping<InputStorageType, OutputStorageType>::offsetY_;

    };

} // namespace

#endif

#include <Base/Common/BIASpragmaEnd.hh>