gl_helpers.h

Go to the documentation of this file.

/*
    This file is part of the CVD Library.

    Copyright (C) 2005 The Authors

    This library 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.

    This library 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 this library; if not, write to the Free Software
    Foundation, Inc.,
    51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/
#ifndef CVD_GL_HELPERS_H
#define CVD_GL_HELPERS_H

#include <iostream>
#include <map>

#include "image_ref.h"
#include "image.h"
#include "byte.h"
#include "rgb.h"
#include "byte.h"
#include "rgb8.h"
#include "rgba.h"
#import <OpenGLES/ES1/gl.h>
#import <OpenGLES/ES1/glext.h>
#include "gl_types.h"

#include "TooN.h"
#include "se3.h"
#include "so3.h"
#include "se2.h"
#include "so2.h"

namespace CVD
{

    inline void glVertex(const ImageRef& i)
    {
        glVertex2i(i.x, i.y);
    }

    inline void glTexCoord(const ImageRef& i)
    {
        glTexCoord2i(i.x, i.y);
    }

    inline void glRasterPos(const ImageRef& i)
    {
        glRasterPos2i(i.x, i.y);
    }

    inline void glRect( const ImageRef & p, const ImageRef & q)
    {
        glRecti(p.x, p.y, q.x, q.y);
    }

    inline void glVertex(const TooN::Vector<2>& v)
    {
        glVertex2d(v[0], v[1]);
    }

    inline void glVertex(const TooN::Vector<3>& v)
    {
        glVertex3d(v[0], v[1], v[2]);
    }

    inline void glVertex(const TooN::Vector<4>& v)
    {
        glVertex4d(v[0], v[1], v[2], v[3]);
    }

    inline void glTexCoord(const TooN::Vector<2>& v)
    {
        glTexCoord2d(v[0], v[1]);
    }

    inline void glTexCoord(const TooN::Vector<3>& v)
    {
        glTexCoord3d(v[0], v[1], v[2]);
    }

    inline void glTexCoord(const TooN::Vector<4>& v)
    {
        glTexCoord4d(v[0], v[1], v[2], v[3]);
    }
    
    inline void glRect( const TooN::Vector<2> & p, const TooN::Vector<2> & q)
    {
        glRectd(p[0], p[1], q[0], q[1]);
    }

#ifdef GL_GLEXT_PROTOTYPES
    inline void glMultiTexCoord(GLenum unit, const TooN::Vector<2>& v)
    {
            glMultiTexCoord2d(unit, v[0], v[1]);
    }

    inline void glMultiTexCoord(GLenum unit, const TooN::Vector<3>& v)
    {
            glMultiTexCoord3d(unit, v[0], v[1], v[2]);
    }

    inline void glMultiTexCoord(GLenum unit, const TooN::Vector<4>& v)
    {
            glMultiTexCoord4d(unit, v[0], v[1], v[2], v[3]);
    }
#endif

    inline void glRasterPos(const TooN::Vector<2>& v)
    {
        glRasterPos2d(v[0], v[1]);
    }

    inline void glRasterPos(const TooN::Vector<3>& v)
    {
        glRasterPos3d(v[0], v[1], v[2]);
    }

    inline void glRasterPos(const TooN::Vector<4>& v)
    {
        glRasterPos4d(v[0], v[1], v[2], v[3]);
    }

    inline void glNormal(const TooN::Vector<3>& n)
    {
            glNormal3d(n[0], n[1], n[2]);
    }

    inline void glTranslate( const ImageRef & v )
    {
        glTranslatef( static_cast<GLfloat>(v.x), static_cast<GLfloat>(v.y), 0);
    }

    template <int N> inline void glTranslate( const TooN::Vector<N> & v)
    {
        glTranslated(v[0], v[1], v[2]);
    }

    template <> inline void glTranslate( const TooN::Vector<2> & v)
    {
        glTranslated(v[0], v[1], 0);
    }

    template <> inline void glTranslate( const TooN::Vector<1> & v)
    {
        glTranslated(v[0], 0, 0);
    }

    template <int N, class P, class A> inline void glMultMatrix( const TooN::Matrix<N,N,P,A> & m )
    {
        GLdouble glm[16];
        glm[0] = m[0][0]; glm[1] = m[1][0]; glm[2] = m[2][0]; glm[3] = m[3][0];
        glm[4] = m[0][1]; glm[5] = m[1][1]; glm[6] = m[2][1]; glm[7] = m[3][1];
        glm[8] = m[0][2]; glm[9] = m[1][2]; glm[10] = m[2][2]; glm[11] = m[3][2];
        glm[12] = m[0][3]; glm[13] = m[1][3]; glm[14] = m[2][3]; glm[15] = m[3][3];
        glMultMatrixd(glm);
    }

    template <class P, class A> inline void glMultMatrix( const TooN::Matrix<3,3,P,A> & m )
    {
        GLdouble glm[16];
        glm[0] = m[0][0]; glm[1] = m[1][0]; glm[2] = m[2][0]; glm[3] = 0;
        glm[4] = m[0][1]; glm[5] = m[1][1]; glm[6] = m[2][1]; glm[7] = 0;
        glm[8] = m[0][2]; glm[9] = m[1][2]; glm[10] = m[2][2]; glm[11] = 0;
        glm[12] = 0; glm[13] = 0; glm[14] = 0; glm[15] = 1;
        glMultMatrixd(glm);
    }

    template <class P, class A> inline void glMultMatrix( const TooN::Matrix<2,2,P,A> & m )
    {
        GLdouble glm[16];
        glm[0] = m[0][0]; glm[1] = m[1][0]; glm[2] = 0; glm[3] = 0;
        glm[4] = m[0][1]; glm[5] = m[1][1]; glm[6] = 0; glm[7] = 0;
        glm[8] = 0; glm[9] = 0; glm[10] = 1; glm[11] = 0;
        glm[12] = 0; glm[13] = 0; glm[14] = 0; glm[15] = 1;
        glMultMatrixd(glm);
    }

    template <typename P>
    inline void glMultMatrix( const TooN::SO3<P> & so3 )
    {
        glMultMatrix( so3.get_matrix());
    }

    template <typename P>
    inline void glMultMatrix( const TooN::SE3<P> & se3 )
    {
        glTranslate( se3.get_translation());
        glMultMatrix( se3.get_rotation());
    }

    template <typename P>
    inline void glMultMatrix( const TooN::SO2<P> & so2 )
    {
        glMultMatrix( so2.get_matrix());
    }

    template <typename P>
    inline void glMultMatrix( const TooN::SE2<P> & se2 )
    {
        glTranslate( se2.get_translation());
        glMultMatrix( se2.get_rotation());
    }

    inline void glOrtho( const CVD::ImageRef & size, const double nearPlane = -1.0, const double farPlane = 1.0)
    {
        ::glOrtho( -0.375, size.x - 0.375, size.y - 0.375, -0.375, nearPlane, farPlane );
    }

    inline void glOrtho( const TooN::Vector<6> & param)
    {
        ::glOrtho( param[0], param[1], param[2], param[3], param[4], param[5]);
    }

    template <typename P, typename A>
    inline void glFrustum( const TooN::Vector<4,P,A> & params, double width, double height, double nearPlane = 0.1, double farPlane = 100)
    {
        GLdouble left, right, bottom, top;
        left = -nearPlane * params[2] / params[0];
        top = nearPlane * params[3] / params[1];
        right = nearPlane * ( width - params[2] ) / params[0];
        bottom = - nearPlane * ( height - params[3] ) / params[1];
        ::glFrustum( left, right, bottom, top, nearPlane, farPlane );
    }

    template <class CAMERA> inline void glFrustum( const CAMERA & camera, double width, double height, double nearPlane = 0.1, double farPlane = 100)
    {
        glFrustum( camera.get_parameters().template slice<0,4>(), width, height, nearPlane, farPlane);
    }

    inline void glFrustum( const TooN::Vector<6> & param)
    {
        ::glFrustum( param[0], param[1], param[2], param[3], param[4], param[5]);
    }

    inline void glColor(const TooN::Vector<3>& v)
    {
        glColor3d(v[0], v[1], v[2]);
    }

    inline void glColor(const TooN::Vector<4>& v)
    {
        glColor4d(v[0], v[1], v[2], v[3]);
    }

    inline void glClearColor(const TooN::Vector<4>& v)
    {
        ::glClearColor((GLclampf)v[0], (GLclampf)v[1], (GLclampf)v[2], (GLclampf)v[3]);
    }

    inline void glClearColor(const TooN::Vector<3>& v)
    {
        ::glClearColor((GLclampf)v[0], (GLclampf)v[1], (GLclampf)v[2], 0);
    }



    inline void glColor(const TooN::Vector<-1> & v)
    {
        switch(v.size()){
        case 3: glColor3d(v[0], v[1], v[2]);
            break;
        case 4: glColor4d(v[0], v[1], v[2], v[3]);
            break;
        }
    }


    template <class P1, class P2> inline void glLine(const P1& x1, const P2& x2) {
        glBegin(GL_LINES);
        glVertex(x1);
        glVertex(x2);
        glEnd();
    }

    template<class C> inline void glVertex( const C & list )
    {
        for(typename C::const_iterator v = list.begin(); v != list.end(); ++v)
            glVertex(*v);
    }

    inline void glColor(const CVD::Rgb<byte>& c)
    {
        glColor3ub(c.red, c.green, c.blue);
    }

    inline void glColor(const CVD::Rgb<float>& c)
    {
        glColor3f(c.red, c.green, c.blue);
    }

    inline void glColor3(const CVD::Rgb8& c)
    {
        glColor3ub(c.red, c.green, c.blue);
    }

    inline void glColor4(const CVD::Rgb8& c)
    {
        glColor4ub(c.red, c.green, c.blue, c.dummy);
    }

    inline void glColor(const CVD::Rgba<unsigned char>& c)
    {
        glColor4ub(c.red, c.green, c.blue, c.alpha);
    }

    inline void glColor(const CVD::Rgba<float>& c)
    {
        glColor4f(c.red, c.green, c.blue, c.alpha);
    }

    template<class C> inline void glDrawPixels(const SubImage<C>& i)
    {
        ::glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
        ::glPixelStorei(GL_UNPACK_ROW_LENGTH, i.row_stride());
        ::glDrawPixels(i.size().x, i.size().y, gl::data<C>::format, gl::data<C>::type, i.data());
        ::glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
    }

    template<class C> inline void glReadPixels(BasicImage<C>& i, ImageRef origin=ImageRef(0,0))
    {
        ::glReadPixels(origin.x, origin.y, i.size().x, i.size().y, gl::data<C>::format, gl::data<C>::type, i.data());
    }

    template<class C> inline Image<C> glReadPixels(ImageRef size, ImageRef origin=ImageRef(0,0))
    {
        Image<C> i(size);
        ::glReadPixels(origin.x, origin.y, i.size().x, i.size().y, gl::data<C>::format, gl::data<C>::type, i.data());
        return i;
    }

    template<class C> inline void glTexSubImage2D( const SubImage<C> &i, GLint xoffset = 0, GLint yoffset = 0, GLenum target = GL_TEXTURE_2D, GLint level = 0)
    {
        ::glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
        ::glPixelStorei(GL_UNPACK_ROW_LENGTH, i.row_stride());
        ::glTexSubImage2D(target, level, xoffset, yoffset, i.size().x, i.size().y, gl::data<C>::format, gl::data<C>::type, i.data());
        ::glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
    }

    template<class C> inline void glTexImage2D( const SubImage<C> &i, GLint border = 0, GLenum target = GL_TEXTURE_2D, GLint level = 0)
    {
        ::glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
        ::glPixelStorei(GL_UNPACK_ROW_LENGTH, i.row_stride());
        ::glTexImage2D(target, level, gl::data<C>::format, i.size().x, i.size().y, border, gl::data<C>::format, gl::data<C>::type, i.data());
        ::glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
    }

    inline void glPrintErrors(void){
        GLenum code;
        while((code = glGetError()) != GL_NO_ERROR){
            std::cout << "GL:" << code << ":" << gluGetString(code) << std::endl;
        }
    }


    void glSetFont( const std::string & fontname );

    const std::string & glGetFont();

    enum TEXT_STYLE {
        FILL = 0,       
        OUTLINE = 1,    
        NICE = 2        
    };

    std::pair<double, double> glDrawText(const std::string & text, enum TEXT_STYLE style = NICE, double spacing = 1.5, double kerning = 0.1);

    std::pair<double, double> glGetExtends(const std::string & text, double spacing = 1.5, double kerning = 0.1);


};

#endif