MultipleDepthWarp.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 __MULTIPLE_DEPTH_WARP_HH__
#define __MULTIPLE_DEPTH_WARP_HH__

#include <Geometry/Projection.hh>
#include <Geometry/ProjectionParametersPerspectiveDepth.hh>
#include <Geometry/ProjectionParametersPerspective.hh>

#include <OpenGLFramework/Base/glfTexture2D.hh>
#include <OpenGLFramework/Base/glfBatch.hh>
#include <OpenGLFramework/Base/glfFramebufferObject.hh>

#include <bias_config.h>

namespace BIAS {

    class BIASOpenGLFramework_EXPORT MultipleDepthWarp {
    public:

    enum DEPTH_COR_TYPE {
            NONE = 0, POLYNOM = 1, LINEAR = 2
                                        };

    enum WARPING_TYPE {
            DISPARITY = 0, DEPTH = 1
                               };

    MultipleDepthWarp();
    ~MultipleDepthWarp();

    /**
     * @brief
   * \param targetCam must be a perspective camera
   * \param sourceCameras must be a vector of cameras
   * \param createDepthMaps determines whether the depth map textures, which are used for generating the triangle meshes are generated by this object or if you pass pointers to already existent depth maps, in the later case UploadDepthMap will use the specified textures.
     */
    int
                Init(const ProjectionParametersPerspective& targetCam, std::vector<
                     Projection>& sourceCameras, bool createDepthMaps = true);

    void ChangeTargetCam(const ProjectionParametersPerspective& targetCam);
        /**
         * @brief
         * sets the parameters for the camera for projective texturing
         * this camera will be used to project the texture on the scene
         * textureCam must be a perspective camera
         */
        int SetProjectiveTextureCam(const ProjectionParametersPerspective& textureCam);

        /**
         * @brief
         * uploads the image which will be used for projective texturing of the scene
         * to the corresponding texture
         * projectiveTexture image for projective texturing
         */
        void UploadProjectiveTexture(const Image<unsigned char>& projectiveTexture);

        /**
          * enable or disables use of projective texturing
          */
        void UseProjectiveTexturing(bool enable) {
            useProjectiveTexturing_ = enable;
        }

    /**
     * @brief
     * uploads the given depthMap to the gpu as texture
     * depthMap is a depth map from source camera i
     */
    int UploadDepthMap(Image<float>& depthMap, unsigned int index);

    /**
     * @brief
     * sets a texture for depthMap
   * \attention can only be used if createDepthMaps = false by calling Init
     */
    int SetDepthMap(glfTexture2D* depthMap, unsigned int index);

    /**
     * @brief
         * warps the depths maps for all sourceCameras to the target camera
         * view as disparity / depth map
     */
    int Warp();

    /**
     * @brief
     * warps the depths maps for all sourceCameras to the target camera view as disparity map
     */
    int Warp(unsigned int index);

        int SetupNViewsWarp(const double& distToScreen,
                            const double& zoom, const double& shift,
                            unsigned int numberOfViews, unsigned int centralViewIndex, bool separate = true);

        int WarpNViews();

    /**
     * @brief
         * gives the warped disparity / depth map as a bias image
     */
    int GetWarpedDisparity(Image<float>& dispMap);

    /**
     * @brief
     * gives the warped zbuffer as bias image
     */
    int GetWarpedZBuffer(Image<float>& zbuffer);

        int GetProjectedTexture(Image<unsigned char>& texture);

    /**
     * @brief
     * if disparity output is required, then points with the distance
     * (dist_from_cam) will get disparity (disp)
     */
    void SetDispForDistance(const float& dist_from_cam, const float& disp);

  /** Determines the baseline of the virtual standard stereo setup used for disparity calculation.
    */
  void SetBaseline(const float& baseline);

    /**
     * @brief
     * this function sets near and far clipping planes for the target camera
     * default parameters defined in the constructor are zNear = 100, zFar = 8000
     */
    void SetZNearAndZFar(const float& zNear, const float& zFar);

    void SetDiscardAngle(float degree);

    void SetDepthScaleBeforeWarping(float scale);

    void FlopTextureCoordinates(bool flop) {
            flop_ = flop;
        }

        void FlipTextureCoordinates(bool flip) {
            flip_ = flip;
        }

    glfTexture2D* GetWarpedDispTexture() {
            return resultDispTextures_[current_index_];
    }

    int GetTextureAsImage(Image<float>& dispMap, unsigned int index) {
            if (index < resultDispTextures_.size()) {
                resultDispTextures_[index]->CopyToImage(dispMap);
                return 0;
            } else {
                return -1;
            }
    }

    glfTexture2D* GetTexture(unsigned int index) {
            if (index < resultDispTextures_.size()) {
                return resultDispTextures_[index];
            } else {
                return NULL;
            }
    }

    glfFramebufferObject* GetFrameBufferObject() {
            return &renderTarget_;
    }

    void SetDepthCorType(DEPTH_COR_TYPE type) {
            depthCorType_ = type;
    }

    void SetWarpType(WARPING_TYPE type) {
            warpType_ = type;
    }

        std::vector<glfTexture2D*>* GetResultTexturesFromNViewWarp() {
            return &resultTexturesForNViews_;
        }

        std::vector<glfTexture2D*>* GetResultDepthMapsFromNViewWarp() {
            return &resultDepthMapsForNViews_;
        }

        void SwithToMultiStereoModus(bool stereo) {
            multiStereoModus_ = stereo;
        }

    private:

    DEPTH_COR_TYPE depthCorType_;
    WARPING_TYPE warpType_;

        bool multiStereoModus_, initCalled_, flop_, flip_, createDepthMaps_, useProjectiveTexturing_, separate_, clearColorBuffer_;

        float zNear_, zFar_, thr_, depthScaleBeforeWarping_;
        //float dist_from_cam_, disp_; //this is now covered by baseline_ and focallengthContained_
        /** defines the baseline of the virtual stereo setup used to calculated disprities.
          this baseline can already contain focallength information.
          If so focallengthContained will be true.
          Formula used to calculate the disaprity is:
          d=targetParam.f * baseline_/z. In the case where baseline information are contrained
          this becomes d=baseline_/z.
         */
        float baseline_;
        /** Tells whether baseline_ is already containing focallength information.
          */
        bool focallengthContained_;

        float minDepth_, maxDepth_, depthRange_;

        unsigned numberOfSampForDepthCorr_;

        double nViewsWarpDistToScreen_, nViewsWarpEyeDist_, nViewsWarpSceneScale_, nViewsWarpShift_;

        unsigned int current_index_;

        unsigned int numberOfViews_;

        Image<float> depthCorrImageLUT_;
        glfTexture2D* depthCorrTexLUTP_;

    std::vector<glfTexture2D*> depthMaps_;
        std::vector<glfTexture2D*> resultDepthMapsForNViews_;
        std::vector<glfTexture2D*> resultTexturesForNViews_;
    glfTexture2D resultDispTexture_;
    std::vector<glfTexture2D*> resultDispTextures_;
        std::vector<glfTexture2D*> resultColorTextures_;
    glfTexture2D resultZBufferTexture_;
        glfTexture2D projectiveTexture_;

    ProjectionParametersPerspective targetParams_;
    std::vector<Projection> sourceParams_;
    std::vector<Vector3<double> > cameraCenters_;

    glfBatch batch_;

    glfMatrix modelViewMatrix_;
    glfMatrix projectionMatrix_;
        glfMatrix textureMatrix_;

        std::vector<glfMatrix> modelViewMatricesForNViewWarp_;
        std::vector<glfMatrix> projectionMatricesForNViewWarp_;

    glfViewport viewport_;

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

    glfDepthBufferMode depthBufferMode_;

    glfFramebufferObject renderTarget_;

    BIAS::glfShaderProgram shaderProgram_;
    BIAS::glfShader vertexShader_;
    BIAS::glfShader fragmentShader_;
    BIAS::glfShader geometryShader_;

    void SetupPrimitiveRendering_();
        void SetupShaders_(int shaderType);

        void CreateDepthCorrectionLUT_(ProjectionParametersPerspectiveDepth& pppd);

    };
}

#endif /* __MULTIPLE_DEPTH_WARP_HH__ */