OmniGCardConverter.cpp

Go to the documentation of this file.

/*
 *  Copyright (C) Massimo Cora' 2006 <maxcvs@gmail.com>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#ifdef WIN32
#include <windows.h>
#endif

// opencv
#include <cv.h>
#include <cxtypes.h>
#include <highgui.h>
#include <cvaux.h>


#include "OmniGCardConverter.hh"


void OmniGCardConverter::angle_type_conversion( const OmniAngle<double> &angle_in, 
                                                        OmniAngle<int> &angle_out )
{
        int theta, steps;
        double rad_angle_start, rad_angle_end;

        rad_angle_start = angle_in.angle_start;
        rad_angle_end = angle_in.angle_end;
    
        // check whether the class was initialized correctly
        if ( !is_initialized () )
                return;

        // we need a positive interval.
        // So check for a negative angle
        if ( rad_angle_start < 0 )
                rad_angle_start = 2 * CV_PI + rad_angle_start;
        
        if ( rad_angle_end < 0 )
                rad_angle_end = 2 * CV_PI + rad_angle_end;

        // case in which we want to take an angle for example from 3/2pi to pi/2.
        if ( rad_angle_end < rad_angle_start ) {
                theta = (int)ceil( rad_angle_start * (_max_radius - _min_radius) );

                // rad_angle_start + (2 pi angle - rad_angle_end)
                steps = (int)ceil( rad_angle_end *(_max_radius - _min_radius) ) +
                        (_pano_width - theta);
        }
        else if ( rad_angle_end > rad_angle_start ) {
                theta = (int)ceil( rad_angle_start * (_max_radius - _min_radius) );
                steps = (int)ceil( rad_angle_end * (_max_radius - _min_radius) ) - theta;
        }
        else {                  // normal case
                steps = _pano_width;
                theta = 0;
        }

        // now fill in the struct
        angle_out.range = steps;
        angle_out.angle_start = theta;
        angle_out.angle_end = (theta + steps) % _pano_width;
}


IplImage* OmniGCardConverter::omni2pano( IplImage *omni_frame, const OmniAngle<int> &IN_interval )
{
        assert( omni_frame->width == _video_width );
        assert( omni_frame->height == _video_height );

        // update the texture 
        glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, omni_frame->width, omni_frame->height,
                        GL_BGR_EXT, GL_UNSIGNED_BYTE, omni_frame->imageData);


        float slide_par = (float)IN_interval.angle_start / (float)_pano_width;

        // go with painting procedure
        gl_paint ( slide_par );

        //
        // adjust the width size to the next 32 divisor: this is for image alignment correctness
        // and mainly if you want to stream that image with ffmpeg, that has problems and incompatibility
        // against OpenCv and IplImages.
        //
        int adjusted_range = IN_interval.range;
        int tmp_val = IN_interval.range % 32;

        if ( tmp_val != 0 )
                adjusted_range -= tmp_val;

        // FIXME: probably with some cyclic buffer we can avoid to alloc everytime a new frame
        IplImage *res_image;
        res_image = cvCreateImage( cvSize( adjusted_range, _pano_height ), IPL_DEPTH_8U, 3 );

        glReadPixels ( 0, 0, adjusted_range,
                        res_image->height, GL_BGR_EXT, GL_UNSIGNED_BYTE, res_image->imageData );

        // FIXME: remove this for perfomance...
        if ( _flipped_mode )
                cvFlip( res_image, res_image, 0);
        return res_image;
}


OmniGCardConverter::OmniGCardConverter( double min_radius,
                                                                                double max_radius,
                                                                                double omni_center_x,
                                                                                double omni_center_y,
                                                                                unsigned int video_width,
                                                                                unsigned int video_height,
                                                                                char *program_name /*= "benchmark_hardware"*/,
                                                                                char *vertex_program_file_name /*= "vertex_shader.cg"*/,
                                                                                char *vertex_program_name /*= "vertex_shader_main"*/,
                                                                                char *fragment_program_file_name /*= "pixel_shader.cg"*/,
                                                                                char *fragment_program_name /*= "pixel_shader_main"*/,
                                                                            bool flipped_mode /* = false */ ) :
                                                                _min_radius( min_radius ),
                                                                _max_radius( max_radius ),
                                                                _omni_center_x( omni_center_x ),
                                                                _omni_center_y( omni_center_y ),
                                                                _video_width( video_width ),
                                _video_height( video_height ),
                                                                _flipped_mode( flipped_mode )
{
        GLuint texture;

        _initialized = false;

        // be sure to have max_radius and min_radius even
        if ( (int)_max_radius % 2 != 0 )
                _max_radius++;
        if ( (int)_min_radius % 2 != 0 )
                _min_radius++;
        
        // calculate the final pano width and height
        _pano_width = (int)ceil( (_max_radius - _min_radius ) * 2 * CV_PI );
        _pano_height = (int)ceil( _max_radius - _min_radius );

#ifdef WIN32
        wgl_init( &_g_window, &_g_application, &_g_keys, _pano_width, _pano_height );
#else   // LINUX
        _dpy = XOpenDisplay(NULL);
        if ( !_dpy ) {
                DEBUG_PRINT ("Error: XOpenDisplay failed\n");
        return;
        }

        if ( _pano_width == 0 || _pano_height == 0 ) {
                DEBUG_PRINT("WARNING: _pano_width == 0 || _pano_height == 0\n");
        }
        
        _win = glx_init( _dpy, _pano_width, _pano_height );
        if ( _win == 0 ) {
                DEBUG_PRINT ("Error making window\n");
                return;
        }
#endif

        _hw_video_height = _hw_video_width = get_texturized_video_size( _video_width, _video_height );

        // strdup some strings
        _program_name = strdup( program_name );

        _vertex_program_file_name = strdup( vertex_program_file_name );
        _vertex_program_name = strdup ( vertex_program_name );

        _fragment_program_file_name = strdup( fragment_program_file_name );
        _fragment_program_name = strdup( fragment_program_name );       
        
    glGenTextures(1, &texture);
        glBindTexture (GL_TEXTURE_2D, texture);

        // Start Of User Initialization
        glClearColor (0.0f, 0.0f, 0.0f, 0.0f);

#ifdef WIN32
        setVSync(0);
#endif

        // Enable Texture Mapping
        glEnable( GL_TEXTURE_2D );

        glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
        glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );

        _cg_context = cgCreateContext();
        if ( _cg_context == NULL || check_for_cg_error( "creating context", _program_name, _cg_context) < 0 )
                return;

        //
        // vertex shader part
        //

        _cg_vertex_profile = cgGLGetLatestProfile( CG_GL_VERTEX );
        cgGLSetOptimalOptions( _cg_vertex_profile );
        if ( check_for_cg_error("selecting vertex profile", _program_name, _cg_context) < 0 )
                return;

        _cg_vertex_program =
                cgCreateProgramFromFile(
                        _cg_context,              /* Cg runtime context */
                        CG_SOURCE,                /* Program in human-readable form */
                        _vertex_program_file_name,  /* Name of file containing program */
                        _cg_vertex_profile,        /* Profile: OpenGL ARB vertex program */
                        _vertex_program_name,      /* Entry function name */
                        NULL );                    /* No extra compiler options */

        if ( check_for_cg_error("creating vertex program from file", _program_name, _cg_context) < 0)
                return;

        cgGLLoadProgram( _cg_vertex_program );
        if ( check_for_cg_error("loading vertex program", _program_name, _cg_context) < 0 )
                return;


        // setup the min radius to skip from conversion. Namely min_radius_on_max_radius
        // e.g. 40 / 220 = 0.18, where 40 and 220 are respectively the min and max madius
        _cg_vertex_param_min_radius_on_max_radius = cgGetNamedParameter( _cg_vertex_program, "min_radius_on_max_radius" );
        cgGLSetParameter1f( _cg_vertex_param_min_radius_on_max_radius, (float)(_min_radius / _max_radius) );

        //
        // fragment/pixel shader part
        //

        _cg_fragment_profile = cgGLGetLatestProfile( CG_GL_FRAGMENT );
        cgGLSetOptimalOptions( _cg_fragment_profile );
        if ( check_for_cg_error("selecting fragment profile", _program_name, _cg_context) < 0 )
                return;

        _cg_fragment_program =
                cgCreateProgramFromFile(
                        _cg_context,                                    /* Cg runtime context */
                        CG_SOURCE,                                              /* Program in human-readable form */
                        _fragment_program_file_name,    /* Name of file containing program */
                        _cg_fragment_profile,                   /* Profile: OpenGL ARB vertex program */
                        _fragment_program_name,                 /* Entry function name */
                        NULL);                                                  /* No extra compiler options */

        if ( check_for_cg_error("creating fragment program from file", _program_name, _cg_context) < 0 )
                return;
        
        cgGLLoadProgram( _cg_fragment_program );
        if ( check_for_cg_error("loading fragment program", _program_name, _cg_context) < 0 )
                return;

        _cg_fragment_param_omni_tex = cgGetNamedParameter( _cg_fragment_program, "omni_tex" );
        _cg_fragment_param_center_x = cgGetNamedParameter( _cg_fragment_program, "center_x" );
        _cg_fragment_param_center_y = cgGetNamedParameter( _cg_fragment_program, "center_y" );
        _cg_fragment_param_width_on_height = cgGetNamedParameter( _cg_fragment_program, "width_on_height" );
        _cg_fragment_param_slide = cgGetNamedParameter( _cg_fragment_program, "slide" );

        unsigned char *empty_texture = new unsigned char[_hw_video_height * _hw_video_width * 3];

        // Create The Texture
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, _hw_video_width, _hw_video_height, 
                0, GL_RGB, GL_UNSIGNED_BYTE, empty_texture );
        delete empty_texture;

        cgGLSetTextureParameter( _cg_fragment_param_omni_tex, texture );
        cgGLSetParameter1f( _cg_fragment_param_center_x, (float)_omni_center_x / (float)_hw_video_width );
        cgGLSetParameter1f( _cg_fragment_param_center_y, (float)_omni_center_y / (float)_hw_video_height );
        cgGLSetParameter1f( _cg_fragment_param_width_on_height, (float)_video_width / (float)_video_height );
        cgGLSetParameter1f( _cg_fragment_param_slide, 0.0f );

        _initialized = true;
}

OmniGCardConverter::~OmniGCardConverter() 
{
        if ( _program_name )
                free( _program_name );
        if ( _vertex_program_file_name )
                free( _vertex_program_file_name );
        if ( _vertex_program_name )
                free( _vertex_program_name );
        if ( _fragment_program_file_name )
                free( _fragment_program_file_name );
        if ( _fragment_program_name )
                free( _fragment_program_name ); 
                
#ifdef WIN32
        wgl_deinit (&_g_window, &_g_application, &_g_keys);
#else
        glx_deinit( _dpy );
#endif
                
}

#ifdef WIN32
void OmniGCardConverter::setVSync( int interval /* = 1 */) 
{
        const char *extensions = (const char*)glGetString( GL_EXTENSIONS );

        if( strstr( extensions, "WGL_EXT_swap_control" ) == 0 )
                return; // Error: WGL_EXT_swap_control extension not supported on your computer.\n");
        else {
                _wglSwapIntervalEXT = (PFNWGLSWAPINTERVALFARPROC)wglGetProcAddress( "wglSwapIntervalEXT" );

                if( _wglSwapIntervalEXT )
                        _wglSwapIntervalEXT( interval );
        }
}
#endif

int OmniGCardConverter::check_for_cg_error( const char *situation, char *prg_name, CGcontext cg_ctx )
{
        CGerror error;
        const char *string = cgGetLastErrorString(&error);

        if (error != CG_NO_ERROR) {
                DEBUG_PRINT("%s: %s: %s\n",
                        prg_name, situation, string);

                if (error == CG_COMPILER_ERROR) {
                        DEBUG_PRINT("%s\n", cgGetLastListing( cg_ctx ));
                }
                return -1;
        }

        return 0;
}

int OmniGCardConverter::get_texturized_video_size( int video_width, int video_height ) 
{
        int mask=0;
        int value;

        value = (video_width >= video_height ? video_width : video_height);
        
    while( (mask & value) != value ) {
                mask = ( mask << 1 ) +1;
        }

        return mask +1;
}

double OmniGCardConverter::get_min_radius () 
{
        return _min_radius;
}

double OmniGCardConverter::get_max_radius ()
{
        return _max_radius;
}

double OmniGCardConverter::get_omni_center_y ()
{
        return _omni_center_y;
}

double OmniGCardConverter::get_omni_center_x () 
{
        return _omni_center_x;
}

bool OmniGCardConverter::is_initialized () 
{
        return _initialized;
}

void OmniGCardConverter::gl_paint ( float slide /*= 0.0f*/ )
{
        glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);            // Clear Screen And Depth Buffer

        cgGLBindProgram( _cg_vertex_program );
        cgGLEnableProfile( _cg_vertex_profile );
        
        cgGLBindProgram( _cg_fragment_program );
        cgGLEnableProfile( _cg_fragment_profile );

        cgGLSetParameter1f( _cg_fragment_param_slide, slide);

        cgGLEnableTextureParameter( _cg_fragment_param_omni_tex );
        cgGLEnableClientState ( _cg_fragment_param_center_x );
        cgGLEnableClientState ( _cg_fragment_param_center_y );
        cgGLEnableClientState ( _cg_fragment_param_slide );

        // Begin Drawing The Background (One Quad)
        glBegin(GL_QUADS);                                                                              

        glTexCoord2f(0, 0);
        glVertex2f(-1, -1);

        glTexCoord2f(1, 0);
        glVertex2f(1, -1);

        glTexCoord2f(1, 1);
        glVertex2f(1, 1);
        
        glTexCoord2f(0, 1);
        glVertex2f(-1, 1);

        // Done Drawing 
        glEnd();                                                                                                

    // disable hardware acceleration
        cgGLDisableProfile( _cg_vertex_profile );
        cgGLDisableProfile( _cg_fragment_profile );
        cgGLDisableTextureParameter( _cg_fragment_param_omni_tex );

        // flush rendering pipeline
        glFlush();
}

/* unsed yet */
IplImage* OmniGCardConverter::omni2pano( IplImage *omni_frame, const OmniAngle<double> &IN_interval )
{
        DEBUG_PRINT ("unused function omni2pano with double angle\n");
        return NULL;
}


void OmniGCardConverter::pano2omni_xy( CvPoint *pano_point, double theta_start, 
                                                                          CvPoint *omni_point )
{
        omni_point->x = (int)((pano_point->y  + _min_radius ) * 
                cos((theta_start + pano_point->x) / _max_radius ));  

        omni_point->y = (int)((pano_point->y + _min_radius ) * 
                sin((theta_start + pano_point->x) / _max_radius ));  

        omni_point->x += (int)_omni_center_x;
        omni_point->y += (int)_omni_center_y;
}



bool OmniGCardConverter::check_for_3d_gcard_availability ()
{


#ifdef WIN32    
        Application     g_application;
        GL_Window       g_window;
        Keys            g_keys;

        wgl_init( &g_window, &g_application, &g_keys, 0, 0 );
#else
    Display *dpy_tmp;
    Window win_tmp;

        dpy_tmp = XOpenDisplay (NULL);
        if ( !dpy_tmp ) {
                DEBUG_PRINT ("Error: XOpenDisplay failed\n");
        return false;
        }

        win_tmp = glx_init( dpy_tmp, 1, 1 );

        if ( win_tmp == 0 ) {
                DEBUG_PRINT ("Error making window\n");
                return false;
        }

#endif

        // ok, instead of doing the cg* tests below, we can also check the GL_EXTENSIONS 
        // stuff in a way like this.
/*
        // Make sure the card supports fragment programs at all, by searching for the extension string
        const char *extensions = reinterpret_cast<const char *>( glGetString( GL_EXTENSIONS ) );
        const bool cardSupportsARB = ( strstr( extensions, "GL_ARB_fragment_program" ) != NULL );
*/


        CGcontext   cg_context_tmp;
        CGprofile   cg_vertex_profile_tmp, cg_fragment_profile_tmp;

        cg_context_tmp = cgCreateContext();
        if ( cg_context_tmp == NULL || check_for_cg_error("creating context", NULL, cg_context_tmp) < 0 ) {
#ifdef WIN32
                wgl_deinit( &g_window, &g_application, &g_keys);
#else
                glx_deinit( dpy_tmp );
#endif
                return false;
        }

        // vertex shader check

        cg_vertex_profile_tmp = cgGLGetLatestProfile( CG_GL_VERTEX );
        cgGLSetOptimalOptions( cg_vertex_profile_tmp );
        if ( check_for_cg_error("selecting vertex profile", NULL, cg_context_tmp) < 0 ) {
#ifdef WIN32    
                wgl_deinit( &g_window, &g_application, &g_keys);
#else
                glx_deinit( dpy_tmp );
#endif
                return false;
        }

        // fragment/pixel shader check
        cg_fragment_profile_tmp = cgGLGetLatestProfile( CG_GL_FRAGMENT );
        cgGLSetOptimalOptions( cg_fragment_profile_tmp );
        if ( check_for_cg_error("selecting fragment profile", NULL, cg_context_tmp) < 0 ) {
#ifdef WIN32
                wgl_deinit( &g_window, &g_application, &g_keys);
#else
        glx_deinit( dpy_tmp );
#endif

                return false;
        }

#ifdef WIN32
        wgl_deinit( &g_window, &g_application, &g_keys);
#else
        glx_deinit( dpy_tmp );
#endif

        return true;
}

---