ProjectionMapping.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 __ProjectionMapping_hh__
#define __ProjectionMapping_hh__

#include <Image/BackwardMapping.hh>
#include <Geometry/HMatrix.hh>
#include <Geometry/Projection.hh>
#include <Base/Geometry/HomgPlane3D.hh>


namespace BIAS {

  /** @class ProjectionMapping
      @ingroup g_filter
      @brief  Maps source pixel to sink pixel of given projections.

      This class uses backward mapping to convert an image taken by a certain
      camera src (specified as BIAS::Projection) into an image that another
      camera sink would have seen at the same time. The original idea was that
      the two camera share the same pose and that this class handles
      tasks like fisheye to perspective or radial (un-)distortion. However,
      meanwhile you can as well change the orientation (e.g. to get a certain
      perspective cutout of a very wide field of view fisheye). Since all rays
      still intersect at the same camera center, no scene information is
      required.

      If however, your sink has a different camera center than the source you
      can either assume that all pixels have infinite depth (which actually
      means that the distance of your cameras can be ignored in comparison to
      the distance to the scene), which leads to a mapping via the plane at
      infinity (infinite homography for perspective cameras).
      Or, you can specify your scene by providing depth information. In that
      case your scene is assumed to be a textured 2.5D mesh (fully connected),
      i.e. a single continuous surface in 3D space. You may as well specify
      that your scene is a single plane in space.

      This class is an example of the need for adaptive trilinear or even
      anisotropic filtering, because typically, the local sampling frequency
      varies and aliasing will occur.
      Unfortunately, the unproject/project calls within the most inner loop
      make the whole mapping quite slow. If your mapping is constant (e.g. you
      want to radial-undistort 1000 images with the same parameters),
      consider using the prepared lookup table mapping interface
      (see BackwardMapping).


      @author Oliver Niemann, koeser
      @date   2006
  */
  template <class InputStorageType, class OutputStorageType>
  class BIASImage_EXPORT ProjectionMapping
    : public  BackwardMapping<InputStorageType, OutputStorageType> {

  public:

    virtual ~ProjectionMapping();

    ProjectionMapping();

    /**  required because assignment is
         @author Jan Woetzel */
    ProjectionMapping(const ProjectionMapping & src);

    /**  required because of const members
         @author Jan Woetzel */
    ProjectionMapping<InputStorageType, OutputStorageType> &
      operator=(const ProjectionMapping & src);

    /** @brief Set your source projection before calling Map() */
    inline void SetSourceCam(const Projection& P) {
      SourceP_ = P;
      calcRelativeRSinkToSource_();
    }

    /** @brief Set your sink projection before calling Map(),

    optional: if your sink has a different camera center it may make sense
    to pass a depth map for your sink image which is used during mapping.
    Otherwise infinite depth is assumed for every pixel.

        @param sinkdepth    only pointer is stored, must be valid all time !
    */
    inline void SetSinkCam(const Projection& P,
                           const Image<float>* sinkdepth = NULL) {
      SinkP_ = P;
      calcRelativeRSinkToSource_();
      depthMapSink_ = sinkdepth;
      if (depthMapSink_!=NULL) accountForDifferentCameraCenters_ = true;
    }

    /** @brief sets the scene to be a plane */
    inline void SetPlane(const BIAS::HomgPlane3D& plane) {
      mappingPlane_ = plane;
      depthMapSink_ = NULL;
      accountForDifferentCameraCenters_ = true;
    }

    /** @brief uses forward mapping to calculate the bounding box in sink image,
        where to actually do the backward mapping (only needed for speed up).

        The resulting coordinates can be negative !
        The br position is the first pixel outside the region(as for a ROI).
        @author koeser
    */
    virtual int GetBoundingBox(unsigned int srcwidth,
                               unsigned int srcheight,
                               unsigned int sinkwidth,
                               unsigned int sinkheight,
                               int &tlx, int &tly,
                               int &brx, int &bry);


  protected:

    RMatrix relativeRSinkToSource_;

    inline void calcRelativeRSinkToSource_() {
      if (SourceP_.PoseValid() && SinkP_.PoseValid())
        relativeRSinkToSource_ = SourceP_.GetR().Transpose()*SinkP_.GetR();
    }

    /** @brief Reimplementation for Pixel transformation,
               takes sink and computes coordinates in source.
     */
    virtual int GetSourceCoordinates_(const HomgPoint2D& sink,
                                      HomgPoint2D& source) const;

    inline BIAS::Projection GetSourceCam(){
      return SourceP_;
    };

    inline BIAS::Projection GetSinkCam(){
      return SinkP_;
    };

    /// Projections for backward mapping: Run over sink and compute source
    Projection SourceP_, SinkP_;

    /// depth map used for sink if camera centers differ
    const Image<float> *depthMapSink_;

    /// map via this plane
    HomgPlane3D mappingPlane_;

    /// dont map across plane at infinity
    bool accountForDifferentCameraCenters_;

  };

} // namespace

#endif

#include <Base/Common/BIASpragmaEnd.hh>