GLProjectionParametersBase.hh

#ifndef __GLPROJECTIONPARAMSBASE_HH__
#define __GLPROJECTIONPARAMSBASE_HH__

#include <bias_config.h>

#if !(defined(BIAS_HAVE_OPENGL)&&defined(BIAS_HAVE_GLEW))
#error You need BIAS with OpenGL and Glew. Please recompile BIAS
#endif //!(defined(BIAS_HAVE_OPENGL)&&defined(BIAS_HAVE_GLEW))

#include <Gui/biasgl.h>
#include <Geometry/ProjectionParametersBase.hh>
#include <Base/Image/Image.hh>
#include <Base/Geometry/Quaternion.hh>
#include <Base/Debug/Debug.hh>
#include <GLviewer/GLProjectionParametersInterface.hh>
#include <GLviewer/OffscreenRendering.hh>
#include <GLviewer/Scenes/SceneBase.hh>
#include <GLviewer/OutputAttachments/GLProjectionOutputAttachment.hh>
#include <deque>

#define GetMyselfAsProjectionParameterBase GetMyselfAsProjectionParametersBase

namespace BIAS {

  class BIASGLviewer_EXPORT SceneBGImage;

  /** @class GLProjectionParametersBase
      @brief GLPPB encapsulates the opengl rendering interface for the
      projectionparameter classes.
      GLPPB replaces the glprojection. In constrast to the good old glprojection
      every projection type (e.g. perspective or fisheye) implements its own
      class based on the GLPPB interface. This hopefully reduces the code
      complextity and the need for gigantic case differentiations.
      Unlike the glprojection it does not inherit anything from the
      related projection class. the specific implementations
      (e.g. GLprojectionsparametersperspective ) are derived from GLPPB and
      a projectionparameter class (e.g. projectionparametersperspective).
      the GLPPbase class should stay generic and must not contain methods
      or members only related to a specific projection type. (e.g. distortion)
      \ingroup g_glviewer
      \author MIP
  */

  class BIASGLviewer_EXPORT GLProjectionParametersBase
    :public GLProjectionParametersInterface, public BIAS::Debug
  {
  public:
    // standard constructor without parameter object
    GLProjectionParametersBase(  );
    virtual ~GLProjectionParametersBase( );

    virtual void SetDebugLevel(const long int lv);
    virtual void AddDebugLevel(const long int lv);

    /**
       the pure virtual GetMyselfAsProjectionParameterBase() forces the child
       classes to inherit from a projectionparameterbase class and
       allows to access the projectionparams in cases where only a GLPPB* is
       available. this avoids the undesired need to derive GLPPB from PPB.
    */
    virtual BIAS::ProjectionParametersBase* GetMyselfAsProjectionParametersBase() const{
      BIASERR("Base class called, should be overloaded!");
      return NULL;
    };

    /* Implement functions from GLProjectionParametersInterface*/
    virtual int SetExtrinsics(const BIAS::HomgPoint3D& C, const BIAS::RMatrix& R);
    virtual int SetExtrinsics(const BIAS::Vector3<double>& C, const BIAS::RMatrix& R);
    virtual int SetExtrinsics(const BIAS::HomgPoint3D& C,const BIAS::Quaternion<double>& Q);
    virtual int SetExtrinsics(const BIAS::Vector3<double>& C,const BIAS::Quaternion<double>& Q);


    /** Set extrinsic similar to GL's gluLookAt.
     * Defines the camera coordinate base through specified scenepoint
     * that is observed from given position (the eye point). And the up
     * direction in the image (which is the -y axis of image cooridinates).
     * Assuming orthonormal base, extrinsics are calculated.
     * Orthonormality is assured.
     * @{  */
    virtual int SetExtrinsics(float eyex, float eyey, float eyez,
                              float scenex, float sceney, float scenez,
                              float upx, float upy, float upz);  /** @} */
    virtual int SetExtrinsics(const BIAS::Vector3<double>& C,
                              const BIAS::Vector3<double>& scenePoint,
                              const BIAS::Vector3<double>& up);

    virtual void SetIntrinsics(BIAS::ProjectionParametersBase *p);
    virtual void Set(BIAS::ProjectionParametersBase *p);

    virtual int GetExtrinsics(BIAS::Vector3<double>& C,
                              BIAS::Vector3<double>& up) const;

    virtual int GetExtrinsics(BIAS::Vector3<double>& C,
                              BIAS::RMatrix& R) const;

    void SwitchToOffscreenRendering(bool offscreen = true);

    void AppendOutputAttachment(int type, std::vector<int> args=std::vector<int>());
    
    // workaround for underwater needing to change parameters from outside, fkellner
    GLProjectionOutputAttachment *GetAttachmentByType(int type);


    virtual bool PoseValid(){ return(GetMyselfAsProjectionParameterBase()->PoseValid()); }

    BIAS::HomgPoint3D UnProject(const unsigned int x, const unsigned int y);
    BIAS::HomgPoint3D UnProject(const BIAS::HomgPoint2D& p);
    BIAS::HomgPoint3D UnProject(BIAS::HomgPoint2D& point2D, double depth);
    BIAS::HomgPoint2D Project(BIAS::HomgPoint3D &point);

    /**
        Renders scenes passed as argument beginning with the smallest index.
        <b>Depth test is enabled per default with depth func set to GL_LESS<\b>.
        Therfore scenes rendered first will also appear in front if competing
        with other scenes over depth-values.
        If different behaviour is wanted change this within specific scene code!
        The background image scene must be passed through a special parameter
        and should not be contained in the 'scenes' vector.
    */
    virtual int Draw(std::vector<BIAS::SceneBase *>& scenes,
                     BIAS::SceneBGImage* backgroundImageScene = NULL,
                     BIAS::glfFramebufferObject* theTarget=NULL);
#ifdef BIAS_HAVE_XML2
    virtual int XMLRead (const std::string &Filename)=0;
    virtual int XMLWrite(const std::string &Filename) const =0;
    virtual int Load    (const std::string& filename)=0;
    virtual int Save    (const std::string& filename) const =0;
#endif
    //virtual void Assign(BIAS::GLProjectionParametersBase& p);
    virtual void Assign(BIAS::ProjectionParametersBase& p);

    /** Returns the absolute world coordinate frame position of camera */


    void Rescale(float ratio);

    /** Setting the near and far z-Clipping planes.
     * @{ */
    void SetZClippingPlanes(float n, float f);
    void SetNearClippingPlane(float n);
    void SetFarClippingPlane(float f);
    float GetNearClippingPlane() const { return (float)zNear_; }
    float GetFarClippingPlane() const { return (float)zFar_; }
    /** @} */


    /** evaluate depth.
        Point is given in pixel coords relative to upper left image corner
        with positive x axis directed to the right and the positive y-axis
        pointing down. Result is the depth on optical ray.
        \attention Point coordinates passed to this method must lie within
        used viewport and at the same time have the origin in the upper left
        corner with the y-axis pointing down the viewport side.
        \attention Result is only valid if rendering is up to date
        \attention make sure your rendering context is current
    */
    virtual double GetDepth(const unsigned int x, const unsigned int y);
    virtual double GetDepth(const BIAS::HomgPoint2D& p);

    /** Method loads the parameters into the projection and modelview Matrix.
     * \params forceUpdate do not check if camera state changed always
     *         recalculate.
     * \attention make sure your rendering context is current.
     * \attention Method is not equivalent to draw yet.
     */
    virtual int SetGLMatrices(bool forceUpdate = true) = 0;

    virtual int UpdateGLProjectionMatrix_(unsigned int x0, unsigned int y0,
                                          unsigned int width, unsigned int height)=0;

    /** Sets gl's Modelview matrix for rendering
     * relative to camera coordinate system (ignoring camera pose).
     * \attention changes gl state, take care of resets yourself.
     * \attention make sure your rendering context ist current
     */
    virtual void SetGLCameraToLocal();

    /**  Calculates depth map from current z-Buffer state. */
    int GetDepthMap(BIAS::Image<float>& depthMap, const float invalid=0.0);
    /** @brief helper function which converts a z map obtained with the last
        camera into a depth map for the last camera */
    virtual void TranslateZToDepth(BIAS::Image<float>& ztodepth,
                                   const float invalid = 0.0,
                                   const bool flip = true) const;
    /** @brief helper function which converts a z map obtained with the last
        camera into a depth map for the last camera */
    virtual void TranslateDepthToZ(BIAS::Image<float>& depthtoz,
                                   const float invalid = 0.0,
                                   const bool flip = true) const;
virtual void TranslateZToMetricZ(BIAS::Image<float>& depthMap,
                                     const float invalid = 0.0,
                                     const bool flip = true) const;

    int GetZBuffer(BIAS::Image<float>& zBuffer);
    int GetMetricZMap(BIAS::Image<float>& metricZMap,
                      const float invalid = 0.0);
    void GetImage(BIAS::Image<unsigned char>& image);
    void GetGreyImage(BIAS::Image<unsigned char>& image);

    /** Rendering will call UpdateCameraRelatedState() on scenes. */
    void ForceSceneUpdate();

    /** Is true if in multipass rendering procedure is rendering
        for second or subsequent time. In single pass rendering
        it never should return true.
    */
    bool FirstRenderingPassFinished() {return FirstRenderingPassFinished_;}

    void SubtractFromBackgroundImage(bool subtract = true) {
      subtractFromBackgroundImage_ = subtract;
    }

    void SetAutoReshapeBehaviour(BIAS::GLProjectionParametersInterface::ViewingReshapeBehaviour newBehaviour) {
      if(offscreenRenderingEnabled_) {
        AutoViewingMatchBehaviour_ = Deny;
      }
      else
        AutoViewingMatchBehaviour_ = newBehaviour;
    }

    static int instanceCounter;

    /**
       \brief Takes x, y as window coordinates, checks whether the coordinates
       lie in the rendered image (in the viewrange of projection). If so
       \return the coordinates relative to the upper left image corner of the used
       viewport and true. else coordintes are unchanged and return value is
       false.
    */
    bool GetViewportCoordinates(int& x, int& y);

    BIAS::Matrix4x4<double> GetGLProjectionMatrixTransposed() {
      return GLProjectionMatrix_.Transpose();
    }
    BIAS::Matrix4x4<double> GetGLModelViewMatrixTransposed() {
      return GLModelViewMatrix_.Transpose();
    }


  /**
     setclearcolor is pure virtual.
     in some cases like for example distortion rendering
     the lower render layers (offscreen surfaces) must informed about changes of
     the clear color thus the child classes have to deal with the clear color on
     their own.
    */
    virtual void SetClearColor(const BIAS::Vector4<float>& cc) = 0;

    /** @brief set the clear depth for render targets  */
    void SetClearDepth(const float d){
        ClearDepth_=d;
    };

    virtual BIAS::Vector4<float> GetClearColor(){
      return ClearColor_;
    };

    virtual float GetClearDepth(){
      return ClearDepth_;
    };

    virtual void SetRenderTarget(BIAS::glfRenderTarget* RT);
    virtual BIAS::glfRenderTarget* GetRenderTarget();


  protected:
    
    int GetGLViewport_(int &lowerleftx,int &lowerlefty,
          int &sizex,int &sizey);
    int SetGLViewport_(int lowerleftx,int lowerlefty,
          int sizex,int sizey);
        
    virtual int BeginDraw_(BIAS::glfFramebufferObject* theTarget=NULL);
    virtual int EndDraw_(BIAS::glfFramebufferObject* theTarget=NULL);
    /** Implement in deriving classes */
    virtual int Draw_(std::vector<SceneBase *>& scenes,
                      BIAS::glfFramebufferObject* theTarget = NULL)=0;

    virtual void Rescale_(float scale) = 0;
    int          UpdateGLModelViewMatrix_();
    void         SetToUnknownState_();
    void         InitBeforeDraw_();
    void         InitRaw_();

    virtual double Z2Depth_(const int x,const  int y, const double z) const =0;

    /** used by GetDepthMap() which writes the current zbuffer in depthMap.
        AdjustRawZBuffer_ computes the distance from the camera to every pixel  */
    virtual void ZBufferToDepthMap_(BIAS::Image<float>& depthMap);

    /** Takes care of adapting internal parameters and gl viewport
        by specified behaviour scheme. External parameters update
        is not performed here.  */
    virtual int DrawWithMatchedParamsAndViewport_(int viewport[4],
                                                  int imageWidth, int imageHeight,
                                                  std::vector<SceneBase*>& scenes);

    /** Renders a rectangular part of actual image.
        Use if not full resolution is available for example with scrollbars.
        Does not update external parameter forces internal parameter update
        upon next call to Draw().
        \attention make sure your rendering context ist current
    */
    int DrawPartOfImage_(const unsigned int ulX,
                         const unsigned int ulY,
                         const unsigned int width,
                         const unsigned int height,
                         std::vector<SceneBase *> scenes);


    void ReadDepthBufferToTexture_(int texID, int width, int height);
    
    void PrepareOutputAttachments_();

  protected:
    unsigned int instanceNum_;
    BIAS::GLProjectionParametersInterface::ViewingReshapeBehaviour AutoViewingMatchBehaviour_;

    bool subtractFromBackgroundImage_;
    bool FirstRenderingPassFinished_;
    BIAS::SceneBGImage * backgroundImageScene_;

    /**Keeping track which part of image was drawn last time Draw() was called
       and where it was drawn.
       Set by Draw_();  */
    BIAS::Vector4<int> lastUsedGLViewport_;

    /** Remembering the last full viewport prevent unecessary calculations in
        AutoRescaleParams behaviour  */
    BIAS::Vector4<int> lastFullGLViewport_;

    /** When cutting the image this field is telling the projection
        the upper left corner of the drawn image part.  */
    BIAS::Vector2<unsigned int>  drawingUpperLeft_;

    /** Keeping track which image part was drawn last time Draw() was called.
        The width and height of the drawn image is contained in
        lastUsedGLViewport  */
    BIAS::Vector2<unsigned int>  lastDrawingUpperLeft_;

    double lastAutoRescaleRatio_;

    /** Changes to the parameters or GL state that lead to new calculation of
        GL_MODELVIEW matrix.  */
    bool ExtrinsicStateChanged_;

    /** Changes to the parameters or GL state that lead to new calculation of
        GL_PROJECTION matrix.   */
    bool IntrinsicStateChanged_;

    /** Abstract projection params have changed, scenes have to be informed
        about this.  */
    bool informScenesOfChange_;
    double zNear_, zFar_;

    /**
     * \attention BIAS::Matrix4x4 stores the matrix in row major order
     * where GL expects a matrix in column major order!
     * Since we want to use those matrices for rendering they are stored
     * the way they can directly be used in GL. Before operating on those
     * matrices and other Matrix4x4 objects some transpositions might
     * be neccessary! @{*/
    BIAS::Matrix4x4<double> GLProjectionMatrix_;
    BIAS::Matrix4x4<double> GLModelViewMatrix_;
    /**}@*/

    bool callInitBeforeDraw_;

    BIAS::Vector4<float> ClearColor_;
    float ClearDepth_;

#ifdef BIAS_HAVE_CLASS_OFFSCREENRENDERING
    OffscreenRendering offscreenRendering_;
#endif


    bool useStencilBuffer_;

    int cubeSideResolution_;

    bool distort_;

    BIAS::glfRenderTarget* currentRenderTarget_;
    
    std::deque<BIAS::GLProjectionOutputAttachment *> outputAttachments_;
    std::deque<std::vector<int> > outputAttachmentOptions_;
    std::deque<int> outputAttachmentIdentifiers_;
  };
}
#endif