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 <cvd/image_ref.h>
#include <cvd/image.h>
#include <cvd/byte.h>
#include <cvd/rgb.h>
#include <cvd/byte.h>
#include <cvd/rgb8.h>
#include <cvd/rgba.h>
#include <cvd/config.h>
#ifdef WIN32
#include <windows.h>
#endif
#include <GL/gl.h>
#include <GL/glu.h>
#include <cvd/internal/gl_types.h>

#ifdef CVD_HAVE_TOON
#include <TooN/TooN.h>
#include <cvd/se3.h>
#include <cvd/so3.h>
#include <cvd/se2.h>
#include <cvd/so2.h>
#endif

namespace CVD
{

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

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

#ifdef GL_GLEXT_PROTOTYPES




        inline void glMultiTexCoord(GLenum unit, const ImageRef& i)
        {
                glMultiTexCoord2i(unit,  i.x, i.y);
        }
#endif



        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);
        }

        #ifdef CVD_HAVE_TOON



        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;
                }
        }
        #endif

        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

---

libcvd
Author(s): Edward Rosten, Paul Smith, Tom Drummond, Gerhard Reitmayr, Ethan Eade, Timothy Gan, Chris Kemp, Georg Klein
autogenerated on Fri Jan 11 09:13:09 2013