Primitives.hh

/*
 This file is part of the BIAS library (Basic ImageAlgorithmS).

 Copyright (C)  2008, 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 __Primitives_hh__
#define __Primitives_hh__

#include <OpenGLFramework/Base/glfBatch.hh>
#include <OpenGLFramework/Base/glfVertexBuffer.hh>
#include <OpenGLFramework/Base/glfElementBuffer.hh>
#include <Geometry/ProjectionParametersPerspective.hh>
#include <bias_config.h>

#include <OpenGLFramework/Base/glfVertexArrayObject.hh>


namespace BIAS {

  /** Helper class for creating primitives.
   * \ingroup g_openglframework 
   * \author bartczak 04/2008
   **/
  class BIASOpenGLFramework_EXPORT Primitives {
  public:
    /** 
     *  Vertex Order:\n
     *   3--2 \n
     *   |  | \n
     *   0--1 \n
     *
     *  Vertex Coordinates:\n
     *   (-1, 1) -- (1, 1) \n
     *      |         |    \n
     *      |         |    \n
     *      |         |    \n
     *   (-1,-1) -- (1, -1)\n
     *
     *  unflipped texture coordinates:     \n
     *   (0,1) -- (1,1) \n
     *     |        |   \n
     *     |        |   \n
     *   (0,0) -- (1,0) \n
     *  
     * Generates the quad.      
     * 
     **/
    static void PlainQuad2DWithTexture2D(BIAS::glfVertexBuffer& vb, BIAS::glfElementBuffer& eb, bool flip=false);

    /** 
     *  Vertex Order:\n
     *   3--2 \n
     *   |  | \n
     *   0--1 \n
     *
     *  Vertex Coordinates:\n
     *   (-1, 1) -- (1, 1) \n
     *      |         |    \n
     *      |         |    \n
     *      |         |    \n
     *   (-1,-1) -- (1, -1)\n
     *
     * \attention memory space must be allocated properly!
     */
    static void AddPlain2DQuadVertices(float* supplementedArray, 
                                       unsigned int offset, unsigned int stride);

    /** 
     *  Vertex Order: \n
     *   3--2 \n
     *   |  | \n
     *   0--1 \n
     *
     *  unflipped texture coordinates:    \n 
     *   (0,1) -- (1,1) \n
     *     |        |   \n
     *     |        |   \n
     *   (0,0) -- (1,0) \n
     * 
     * \attention memory space must be allocated properly!
     */
    static void AddPlain2DTextureCoordinates(float* supplementedArray, 
                                             unsigned int offset, unsigned int stride, bool flip=false);

    static void LocalPerspectiveQuad(const BIAS::ProjectionParametersPerspective& ppp, 
                                     BIAS::glfVertexBuffer& vb, BIAS::glfElementBuffer& eb);

    static void LocalPerspectivePatches(const BIAS::ProjectionParametersPerspective& ppp, 
                                        const std::vector<unsigned int>& posX,
                                        const std::vector<unsigned int>& posY,
                                        const unsigned int hw,
                                        glfVertexBuffer& vb, glfElementBuffer& eb);

    /** Patch encloses a region around a complete image line.
      * \author bartczak
      * \date 08/2010
      */
    static void LocalPerspectivePatchOverLine(const BIAS::ProjectionParametersPerspective& ppp,
                                                const unsigned int posY,
                                                const unsigned int hw,
                                                glfVertexBuffer& vb, glfElementBuffer& eb);

    /** Generates a vertex list of textured 3d vertices. 
        Their vertex coordinates can be interpreted as the optical ray directions belonging to 
        their respective pixel centers in camera coordinates. The vertex array is constructed 
        row wise starting with the top pixel row. */
    static void LocalNormalizedVertexCloud(const BIAS::ProjectionParametersPerspective& ppp, 
                                           BIAS::glfVertexBuffer& vb, bool normalizeZ, bool invertS);

    static void LocalNormalizedPointCloud(const BIAS::ProjectionParametersPerspective& ppp, 
                                          BIAS::glfVertexBuffer& vb, BIAS::glfElementBuffer& eb, bool normalizeZ, bool invertS);

    static void LocalNormalizedTriangleStrip(const BIAS::ProjectionParametersPerspective& pppSource,
                                             BIAS::glfVertexBuffer& vb, BIAS::glfElementBuffer& eb,
                                             bool normalizeZ=false);

    static void LocalNormalizedTriangleMesh(const BIAS::ProjectionParametersPerspective& pppSource,
                                            BIAS::glfVertexBuffer& vb, BIAS::glfElementBuffer& eb,
                                            bool normalizeZ, bool invertS);

#ifdef GL_VERSION_3_0
    /**
       Calculates 3D optical ray in the local coordinate frame of ppb. 
       Moreover the corresponding texture coordinates for accessing an input image can be calculated.
       The results are assigned to the passed glfVertexArrayObject, which is assumed to already be created (Create()).
       \param ppb the intirinsics of this parameters are used.
       \param vao is the object modified by this method. 
       \param count is the number of returned attributes.
       \param normalizeZ decides upon the normalization of the rays, if this param is false the rays will be set to have an eucledean length of one otherwise 
       they are scaled so that the z-component will be one
       \param VertexCoordSlot determines the VertexAttributeSlot which is used to assigne the calculated vertex coordinates to, if this is set to -1 no vertex coordinates will be generated.
       \param TexCoordSlot determines the VertexAttributeSlot which is used to assigne the calculated texture coordinates to, if this is set to -1 no texture coordinates will be generated.
       <b> TexCoordSlot </b> contains two versions of texture coordinates are calculated. The first set assignes texture coordinates (s = (x+0.5)/width, t = (y+0.5)/height*y) to a vertex 
       corresponding to pixel coordinates (x,y). The second set flips the direction of the t-component, i.e (s = (x+0.5)/width, t = 1-(y+0.5)/height*y). This sets are packed together, so 
       that the first component of the vertex attribute contains the s component (which is the same for both sets), the second component contains the increasing values version and the 
       third is the decreasing values version.

       E.g. one could use the following GLSL vertex shader source to access the texture coordinates:
       \code 
       #version 130 //will not work with previous versions!

       in vec3 packedTexCoords;//bound to appropriate slotindex

       vec2 incTexCoord() {
       return vec2(packedTexCoords[0], packedTexCoords[1]);
       }
       vec2 decTexCoord() {
       return vec2(packedTexCoords[0], packedTexCoords[2]);
       }
       \endcode

       \attention it is not allowed to assign vertex coordinates and texture coordinates to the same slot!
       \attention  normalizeZ is not applicable with cameras of fov of 180Deg and larger (Fisheye)!
    **/
    static void CalculateLocalRayField(const ProjectionParametersBase& ppb, glfVertexArrayObject& vao, 
                                       GLsizei& count, 
                                       GLint VertexCoordSlot=0, GLint TexCoordSlot=1, bool normalizeZ=false);
#endif

    /** Calculates 2D patches in the image plane suited for rendering with identity rendering parameters,
     * patches are valid for a reference resolution and symmetrically centered around a pixel position.
     **/
    static void AddRelativeQuadPatches(const unsigned int referenceWidth, 
                                       const unsigned int referenceHeight,
                                       const std::vector<unsigned int>& posX,
                                       const std::vector<unsigned int>& posY,
                                       const unsigned int hw,                        
                                       BIAS::glfVertexBuffer& vb, BIAS::glfElementBuffer& eb,
                                       const bool flip);

    /** Adds a patch suited for rendering with identity rendering parameters that exactly fits over an image line in the image plane.
      */
    static void AddRelativeQuadPatchOverImageLine(const unsigned int referenceWidth,
                                                    const unsigned int referenceHeight,
                                                    const unsigned int linePos,
                                                    const unsigned int hw,
                                                    BIAS::glfVertexBuffer& vb, BIAS::glfElementBuffer& eb,
                                                    const bool flip);

  private:

    /** Slave of AddRelativeQuadPatches().
     **/
    static void AddRelativeQuadPatch_(const float scaleToSpace[2],
                                      const float shiftToSpace[2],
                                      const float scaleToTex[2],
                                      const float shiftToTex[2],
                                      const float scaleToTexFlipped[2],
                                      const float shiftToTexFlipped[2],
                                      const int ul[2],
                                      const int lr[2],
                                      float* supplementedArray,
                                      unsigned int& offset,
                                      const bool flip);

  };
}



#endif