ProjectionParametersBufferedRay.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 __BIAS_ProjectionParametersBufferedRay_hh__
#define __BIAS_ProjectionParametersBufferedRay_hh__
#include "bias_config.h"

#include <Base/Common/BIASpragmaStart.hh>
#include <Geometry/ProjectionParametersBase.hh>
#include <Geometry/ProjectionParametersPerspective.hh>
#include <MathAlgo/Interpolator.hh>

namespace BIAS
{
 /** @class ProjectionParametersBufferedRay
  *  @ingroup g_geometry
     @brief This class maps image coords to rays which are buffered for fast lookup.
     Buffering is only implemented for unProject, yet.

     The intended usage is:<br>
     1. set up a projection that should be buffered with fixed intrinsics<br>
     2. create an instance of PPRay class passing the projection in the constructor

     Every method that is not buffered is mapped to the genuine projection method.

     Todo:<br>
     1. buffer Project<br>
     2. linear interpolation between image positions (now: nearest)
     @author djung
 */
  class BIASGeometry_EXPORT ProjectionParametersBufferedRay
    : public ProjectionParametersBase
  {
    public:

      ProjectionParametersBufferedRay(const ProjectionParametersBase *ppb);
    
      ProjectionParametersBufferedRay(const ProjectionParametersBufferedRay &ppbr);

      virtual ~ProjectionParametersBufferedRay()
      {
        if (ppb_) delete ppb_;
        if (unprojectMappingIgnoreDistortion_)
          delete[] unprojectMappingIgnoreDistortion_;
        if (unprojectMappingDistortion_)
          delete[] unprojectMappingDistortion_;
      };

      virtual const bool DoIntrinsicsDiffer(const ProjectionParametersBase* p) const;

      virtual bool Distort(BIAS::HomgPoint2D& point2d) const;

      virtual bool Undistort(BIAS::HomgPoint2D& point2d) const;

      virtual HomgPoint2D ProjectLocal(const Vector3<double>& point,
                                       bool IgnoreDistortion = false) const;

      virtual int ProjectLocal(const Vector3<double>& point,
                               HomgPoint2D &p2d, bool IgnoreDistortion = false) const;

      virtual HomgPoint3D UnProjectToImagePlane(const HomgPoint2D& pos,
                                                const double& depth = 1.0,
                                                bool IgnoreDistortion = false) const;

      virtual void UnProjectLocal(const HomgPoint2D& pos, Vector3<double>& origin,
                                  Vector3<double>& direction,
                                  bool IgnoreDistortion = false) const;
      
      virtual ProjectionParametersBufferedRay* Clone() const
      {
        return new ProjectionParametersBufferedRay(*this);       
      };
      
      virtual Vector3<double> UnProjectToPointLocal(const HomgPoint2D& pos,
                                                    const double& depth,
                                                    bool IgnoreDistortion = false) const;
      
#ifdef BIAS_HAVE_XML2
      /** @brief specialization of XML block name function */
      virtual int XMLGetClassName(std::string& TopLevelTag, double& Version) const;
      
      /** @brief specialization of XML write function */
      virtual int XMLOut(const xmlNodePtr Node, XMLIO& XMLObject) const;
      
      /** @brief specialization of XML read function */
      virtual int XMLIn(const xmlNodePtr Node, XMLIO& XMLObject);
#endif
      
      friend std::ostream& operator<<(std::ostream &os,
                                      const ProjectionParametersBufferedRay& p);
      
      /** @brief Set mask flag and update buffered rays from wrapped
          projection parameters. */
      inline void SetMask(bool mask) { mask_ = mask; UpdateProjection_(); };
      
      /** @brief Set attributes of wrapped projection from attributes of this
          ProjectionParametersBufferedRay instance.
          @note Must be called explicitely when intrinsic parameters of
          this projection have been modified! */
      const inline bool UpdateProjection() { return UpdateProjection_(); };

  private:
      
      // due to const interface both options are buffered
      Vector3<double> *unprojectMappingIgnoreDistortion_;
      Vector3<double> *unprojectMappingDistortion_;
      ProjectionParametersBase *ppb_;
      bool mask_;
      
      /** @brief Set attributes of wrapped projection from attributes of this
          ProjectionParametersBufferedRay instance. */
      const bool UpdateProjection_();

      /** @brief Set attributes of this ProjectionParametersBufferedRay
          instance from attributes of wrapped projection (initialization). */
      const bool UpdateFromProjection_();

      /** @brief Update buffered rays using wrapped projection parameters. */
      const bool UpdateBuffer_();
      
  };
  
  inline std::ostream& operator<<(std::ostream &os,
                                  const ProjectionParametersBufferedRay& p)
  {
    os<<"ProjectionParametersRay:"<<std::endl;
    return os;
  }
  
} // end namespace

#include <Base/Common/BIASpragmaEnd.hh>

#endif