Rectifying Points Example

This example builds on Textured Quad Example. Instead of texturing the quad with the uncorrected mage data, this example rectifies the image data to a second texture buffer and uses the result. You will notice that the image no longer fills the entire rectangular area. This is because rays of light that would have filled in the border areas were actually outside the field of view of the camera.

The main changes to this example occur in the display() function. For each pixel in the target texture, the function generates the slopes of the camera ray intersecting that point and looks up the correct brightness value in the uncorrected image buffer (as described in Rectifying Image Points). The result is the a texture containing the rectified image.

//display the textured quad
static void display(void)
{
  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
  glTranslatef(-32, -24, -50); //"Camera" viewpoint
  glClear(GL_COLOR_BUFFER_BIT);
  if(imageReady){
    //Left image
    for( float row = 0; row < TEX_HEIGHT; row++ ) {
      for( float col = 0; col < TEX_WIDTH; col++ ) {

            //Normalize from pixel xy to range [0..1]
            LEAP_VECTOR input;
            input.x = col/TEX_WIDTH;
            input.y = row/TEX_HEIGHT;

            //Convert from normalized [0..1] to ray slopes
            input.x = (input.x - .5) * MAX_FOV;
            input.y = (input.y - .5) * MAX_FOV;

            LEAP_VECTOR pixel = LeapRectilinearToPixel(*connection,
                                                       eLeapPerspectiveType_stereo_left,
                                                       input);
            int dindex = (int)floor(row * TEX_WIDTH + col);
            int pindex = (int)roundf(pixel.y) * image_width + (int)roundf(pixel.x);
            if(pixel.x >= 0 && pixel.x < image_width && pixel.y >=0 && pixel.y < image_height){
              undistorted_image_left[dindex] = ((char*)image_buffer)[pindex];
            } else {
              undistorted_image_left[dindex] = 128;
            }
        }
    }
    // right image
    for( float row = 0; row < TEX_HEIGHT; row++ ) {
        for( float col = 0; col < TEX_WIDTH; col++ ) {

            //Normalize from pixel xy to range [0..1]
            LEAP_VECTOR input;
            input.x = col/TEX_WIDTH;
            input.y = row/TEX_HEIGHT;

            //Convert from normalized [0..1] to ray slopes
            input.x = (input.x - .5) * MAX_FOV;
            input.y = (input.y - .5) * MAX_FOV;

            LEAP_VECTOR pixel = LeapRectilinearToPixel(*connection,
                                                       eLeapPerspectiveType_stereo_right,
                                                       input);
            int dindex = (int)floor(row * TEX_WIDTH + col);
            int pindex = (int)roundf(pixel.y + image_height) * image_width + (int)roundf(pixel.x);

            if(pixel.x >= 0 && pixel.x < image_width && pixel.y >=0 && pixel.y < image_height){
              undistorted_image_right[dindex] = ((char*)image_buffer)[pindex];
            } else {
              undistorted_image_right[dindex] = 200;
            }
        }
    }

    DrawImageQuad(0, 0, 64, 24, TEX_WIDTH, TEX_HEIGHT, undistorted_image_left);
    DrawImageQuad(0, 26, 64, 50, TEX_WIDTH, TEX_HEIGHT, undistorted_image_right);
    imageReady = false;
  }
  glFlush();
  glPopMatrix();
  glutSwapBuffers();
}
//end of display

To rectify an image while taking advantage of a GPU, see Rectifying with a Shader Example.

This example is only supported on platforms for which a working version of GLUT exists. It should not be overly difficult to port the example to a different OpenGL-based context, however.