PMDWarp.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 __PMDWARP_HH__
#define __PMDWARP_HH__

#include <Base/Image/Image.hh>
#include <Geometry/ProjectionParametersPerspectiveDepth.hh>
#include <Geometry/ProjectionParametersPerspective.hh>

#include <OpenGLFramework/Base/glfTexture2D.hh>
#include <OpenGLFramework/Base/glfBatch.hh>
#include <OpenGLFramework/Passive/glfPassiveMatrix.hh>
#include <OpenGLFramework/Passive/glfPassiveViewport.hh>
#include <OpenGLFramework/Passive/glfPassiveDepthBufferMode.hh>

#include <bias_config.h>

namespace BIAS  {

/**
* class can be used to warp sequences of pmd depth images into
* a second view with different parameters, including a different camera center.
*
* \attention this a specialized implementation, mind the usage.
*
* usage:
*  - establish OpenGL context to be used! Let it be current and valid!
*  - Call Init()
*  - if projective texturing has to be used call UseProjectiveTexturing()
*  for each warping call :
*  - upload images using Upload* methods.
*  - set virtual camera params via SetTargetCameraParameters();
*  - call Draw()
*
*  deliverence of output can be controlled using the SetRenderTarget() method.
*
* \author bartczak 02/2008
**/
class BIASOpenGLFramework_EXPORT PMDWarp {
public:
  /** 
  * Initializes all neccessary data in order to render using a batch
   * \param parametersHaveDistortion is a flag the toggles the use of distortion parameters, if this is
   * set to false then a shader using idealy perspective camera parameters is used, otherwise vertices are
   * displaced so that they form a distorted image, uniform params are derived from target parameters 
   * (see SetTargetCameraParameters)!
  * \attention call this method only if the gl-context
  * that has to be used is active and valid.
  **/
  void Init(const BIAS::ProjectionParametersPerspective& pppd, 
            bool targetParametersHaveDistortion=false);

  /** Upload the pmd depth image to the graphics card. Do not flip the image!
  **/
  void UploadDepthMap(const BIAS::Image<float>& pmdDepthImage);

  /** Upload the pmd depth image to the graphics card. Do not flip the image!
  **/
  void UploadDepthMap(const BIAS::ImageBase& pmdDepthImage);

  /** ppp extrinsicis have to be in global coordinates of pppd of Init call!
   * \Attention projective texturing cannot deal with distortion!
   **/
  void UseProjectiveTexturing(const BIAS::ProjectionParametersPerspective& ppp);
  
  /** Upload the color image to the graphics card. Do not flip the image!
   * \Attention projective texturing cannot deal with distortion!
  **/
  void UploadProjectiveTexture(const BIAS::Image<unsigned char>& projectiveTexture);

  void SetRenderTarget(const BIAS::glfRenderTarget* renderTarget);
  
  /** is also used to determine viewport
   * \attention relativePpp means extrinsics relative to the pppd param passed
   *  to Init(). 
   **/
  void SetTargetCameraParameters(const BIAS::ProjectionParametersPerspective& relativePpp,
                                 double zNear, double zFar);

  /** 
   * \attention This method should not be used if distortion is used, if distortion parameters are required
   * and you use this method the result is undefined. 
   */
  void SetTargetCameraParameters(BIAS::Matrix4x4<double> modelViewMatrix,
                                 BIAS::Matrix4x4<double> projectionMatrix,
                                 unsigned int width, unsigned int height);

  void SetTargetCameraParametersToGlobal(bool global);

  void SetViewportSize(unsigned int width, unsigned int height);

  /* Use this method to use the viewport currently set in the global opengl state of current context,
     i.e. that no viewport is set by class!
   */
  void SetViewportToGlobal(bool global);

  void ChangeZClipping(double zNear, double zFar);
  
  /** Function is used to assign a hypotheses to the warped depth map.
  * The result will be pushed to the MRT target identified by output.
  * The result is a 3D image the first two channels coding the two representants
  * the warped depth is lying in between, if an exact representant is found, both will be the same.
  * The third channels is holding the relative distance of the depth to the two representants.
  * The range between zNear and zFar is equidistantly discretized into N intervalls.
  *
  * \attention call after init, use of SetTargetCameraParameters() is not required.
  **/
  void ExecuteLinearHypothesesAssignment(const BIAS::ProjectionParametersPerspective& relativePpp,
    double zNear, double zFar, float N, int output=0);  

  //renders the result into the forseen output
  void Draw();

  BIAS::glfBatch& GetBatch();
  BIAS::glfDepthBufferMode& GetDepthBufferMode();

  /**
   * if disparity output is required, then points with the distance
   * (dist_from_cam) will get disparity (disp)
   * all disparities will also be scaled with the given scale factor
   */
  void SetDispForDistanceAndScale(const float& dist_from_cam,
          const float& disp, const float& scale);


  ~PMDWarp();
  PMDWarp();

protected:
  
  BIAS::ProjectionParametersPerspective pmdParams_;
  BIAS::ProjectionParametersPerspective targetParams_;

  BIAS::glfMatrix modelView_;
  BIAS::glfMatrix Projection_;
  BIAS::glfPassiveRenderMatrix globalModelViewNProjection_;

  BIAS::glfViewport viewport_;
  BIAS::glfPassiveViewport globalViewport_;


  BIAS::glfVertexBuffer vertices_;//the placeholders for the mesh vertices
  BIAS::glfElementBuffer elements_;//indices forming the mesh

  BIAS::glfDepthBufferMode depthBufferMode_;

  BIAS::glfTexture2D pmdDepthImage_;
  BIAS::glfShaderProgram shaderProgram_;
  BIAS::glfShader vertexProgram_;
  BIAS::glfShader fragmentProgram_;
  BIAS::glfShader geometryProgram_;

  BIAS::glfTexture2D projectiveTexture_;
  BIAS::glfMatrix textureMatrix_;

  BIAS::glfBatch batch_;
  unsigned int depthImageWidth_;
  unsigned int depthImageHeight_;

  bool defaultRendering_;

  void SetupDefaultPrimitiveRendering_();
  void SetupShadersDefault_();
  void SetupShadersProjectiveTexturing_();

  bool targetParametersHaveDistortion_;//<!tells whether distortion on target image shall be used
  
  float maxSize_;
};

} //end of namespace MIP


#endif