OmniFastLookupTable.cpp

Go to the documentation of this file.

/*
 *  Copyright (C) Massimo Cora' 2005 <maxcvs@email.it>
 *
 *  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.
 */



#include "OmniFastLookupTable.hh"


//-------------------------------------------------------------------------
//

OmniFastLookupTable::OmniFastLookupTable( int min_radius,
                                                                                  int max_radius,
                                                                                  int omni_center_x_pixel,
                                                                                  int omni_center_y_pixel,
                                                                                  double theta_step, /* = 0 */
                                                                                  bool flipped_mode /* = false */ ) :
                                                                _min_radius( min_radius ),
                                                                _max_radius( max_radius ),
                                                                _omni_center_x_rgb( omni_center_x_pixel*3 ),
                                                                _omni_center_y_rgb( omni_center_y_pixel ),
                                                                _omni_center_x( omni_center_x_pixel ),
                                                                _omni_center_y( omni_center_y_pixel ),
                                                                _flipped_mode( flipped_mode )
{
        _is_valid = false;

        if ( theta_step == 0 ) {
                if ( max_radius == 0 || min_radius == 0 )
                        return;
                
                // let's calculate it
                _theta_step = 1 / (double)max_radius;
        }

        // be sure to have max_radius and min_radius even
        if ( _max_radius % 2 != 0 )
                _max_radius++;
        if ( _min_radius % 2 != 0 )
                _min_radius++;

        _min_to_max_radius_range = _max_radius - _min_radius;
        _theta_max = (int)ceil( 2 * CV_PI * (double)_max_radius );
        
        // computes values
        _is_valid = omnipano_lookup_table_make();
        
}

//-------------------------------------------------------------------------
// free up the allocated memory and tables.

OmniFastLookupTable::~OmniFastLookupTable() {

        int i;

        // free the omni_data pointers
        for ( i=0; i < omni_bounds.theta_length; i++ ) {
                        free( omni_bounds.omni_data[i] );
        }
        // and the omni_data theta array
        free( omni_bounds.omni_data );

        // now it's the turn of pano_data
        for ( i=0; i < pano_bounds.width; i++ ) {
                free( pano_bounds.pano_data[i] );
        }
        free( pano_bounds.pano_data );

}


//-------------------------------------------------------------------------
// return whether he lookup table has been correctly initialized or not

bool OmniFastLookupTable::is_initialized () {
        return _is_valid;
}


//-------------------------------------------------------------------------
//

void OmniFastLookupTable::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 lookup table 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 * (double)_max_radius );

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

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

//-------------------------------------------------------------------------
// transform an omnidirectional frame into a panorama frame. Can receive also
// a slice of angles: it will convert only the part of the omnidirectional
// image between the two angles.

IplImage* OmniFastLookupTable::omni2pano( IplImage *frame, 
                                                                                  const OmniAngle<int>& IN_interval ) {

        IplImage *image;
        IplImage *result ;
        int radius, theta;
        int steps, step_count;
        
        // check whether the lookup table was initialized correctly
        if ( !is_initialized () ) {
                DEBUG_PRINT ("lookup table not initialized\n");
                return NULL;
        }

        image = frame;
        theta = IN_interval.angle_start;
        steps = IN_interval.range;

        int pano_coord_tmp = (PANO_COORD( steps-1, _max_radius-_min_radius -1 ).x_rgb)/3;

        //
        // 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.
        // The worst thing that can happen is to have a black line on the right of the resulting pano image
        //
        int adjusted_pano_coord = pano_coord_tmp;
        int tmp_val = pano_coord_tmp % 32;
        if ( tmp_val != 0 )
                adjusted_pano_coord += 32 - tmp_val;

        result = cvCreateImage( cvSize( adjusted_pano_coord, _max_radius - _min_radius ),
                                                        IPL_DEPTH_8U, 3 );


        // Note: 231 steps are about 60 degrees

        // go on with a O(2) algorithm... is there something better to do?
        for ( theta, step_count = 0; 
                step_count < steps; 
                step_count++, theta = (++theta % _theta_max) ) {

                if ( theta == _theta_max )
                        continue;

                for ( radius = 0; radius < (_max_radius - _min_radius); radius++ ) { 
                        unsigned char* tmp_ptr;
                        int original_r;
            int original_g;
            int original_b;
                        int omni_x, omni_y, pano_x, pano_y;

                        omni_x = OMNI_COORD( theta, radius ).x_rgb;
            omni_y = OMNI_COORD( theta, radius ).y_rgb;

                        // take the three rgb 3 values from source image
                        tmp_ptr = &(CV_IMAGE_ELEM (image, unsigned char, omni_y, omni_x));
            original_r = tmp_ptr[0];
            original_g = tmp_ptr[1];
            original_b = tmp_ptr[2];

            pano_x = PANO_COORD( step_count, radius ).x_rgb;
                        if ( _flipped_mode )
                                pano_y = PANO_COORD( step_count, (_min_to_max_radius_range -1) - radius ).y_rgb;
                        else 
                                pano_y = PANO_COORD( step_count, radius ).y_rgb;
                        
            // and then put them in the result image
                        tmp_ptr = &(CV_IMAGE_ELEM (result, unsigned char, pano_y, pano_x));
                        tmp_ptr[0] = original_r;
                        tmp_ptr[1] = original_g;
                        tmp_ptr[2] = original_b;
                }
        }

        return result;
}



//-------------------------------------------------------------------------
// pre-computes values for conversion pano->omni and vice-versa.
// With this method we can increase the computing performances up to 50%

bool OmniFastLookupTable::omnipano_lookup_table_make( ) {
        int i, j;

        if ( _max_radius <= _min_radius ) {
                DEBUG_PRINT("returning false from OmniFastLookupTable::omnipano_lookup_table_make,"
                                        "_max_radius %d <= _min_radius %d\n", _max_radius, _min_radius);
                return false;
        }
        // let's calculate the number of theta steps to store
        int steps = (int)ceil( 2 * CV_PI / _theta_step );
        
        omni_bounds.theta_length = steps;
        omni_bounds.radius_length = _max_radius - _min_radius;

        // create the omni_data matrix
        omni_bounds.omni_data = (omni_coord_xy**)calloc( steps, sizeof(omni_coord_xy*));
        for ( i=0; i < steps; i++ ) {
                omni_bounds.omni_data[i] = 
                        (omni_coord_xy*)calloc( omni_bounds.radius_length, sizeof(omni_coord_xy));
        }

        // and the pano_data's matrix
        pano_bounds.width = (int)ceil(2 * CV_PI * _max_radius);
        pano_bounds.height = _max_radius - _min_radius;

        pano_bounds.pano_data = 
                (pano_coord_xy**)calloc( pano_bounds.width*3, sizeof(pano_coord_xy*) * pano_bounds.width );
        for ( i=0; i < pano_bounds.width*3; i++ ) {
                pano_bounds.pano_data[i] = 
                        (pano_coord_xy*)calloc( pano_bounds.height, sizeof(pano_coord_xy));
        }

        // compute the omni data
        for ( i=0; i < steps; i++ ) {           // theta
                for ( j=_min_radius; j < _max_radius; j++ ) {           // radius
                        double curr_theta = i * _theta_step;
                        omni_bounds.omni_data[i][j - _min_radius].x_rgb = 
                                (int)(j * cos(curr_theta) + _omni_center_x_rgb)*3;
                        omni_bounds.omni_data[i][j - _min_radius].y_rgb = 
                                (int)(j * sin(curr_theta) + _omni_center_y_rgb);
                }
        }

        // compute the pano data
        int tmp_pano_x = 0;
        for ( i=0; i < pano_bounds.width; i++ ) {                       // theta
                for ( j=0; j < pano_bounds.height; j++ ) {                      // radius
                        int curr_pano_x = (int)(i * _theta_step *j);
                        tmp_pano_x = MAX( curr_pano_x, tmp_pano_x );
                        pano_bounds.pano_data[i][j].x_rgb = tmp_pano_x*3;

            pano_bounds.pano_data[i][j].y_rgb = j;
                }
        }

        return true;
}


//------------------------------------------------------------------
// converts a panoimage xy coord to a omniimage xy coord.
// This function is useful if you want to pass from a omni2pano's image point with 
// a start_angle theta back to the point of the original omni image.
// Output: omni_point.
// note: perhaps this function does not return the *exact* point. 
// Should be revised and tested more.

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

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

        omni_point->x +=  _omni_center_x;
        omni_point->y +=  _omni_center_y;
}


//------------------------------------------------------------------
//

int OmniFastLookupTable::get_min_radius() {
        return _min_radius;
}

//------------------------------------------------------------------
//

int OmniFastLookupTable::get_max_radius() {
        return _max_radius;
}

//------------------------------------------------------------------
//

int OmniFastLookupTable::get_omni_center_x() {
        return _omni_center_x;
}

//------------------------------------------------------------------
//

int OmniFastLookupTable::get_omni_center_y() {
        return _omni_center_y;
}

---