Creating and Viewing Anaglyphs

Written by Paul Bourke
June 2000

Quartz Composer composition: red_cyan.qtz.zip.
Creates a red-cyan image from any stereo pair, image or movie.

There are many different ways of creating and viewing stereoscopic 3D images but they all rely on independently presenting different images to the left and right eye. The following briefly describes and gives examples of what are known as anaglyphs. For more information on how to correctly create stereo pairs, how to use rendering programs to create stereo pairs, and how to use two cameras to film in stereo, see other articles on this page. While there are many problems/issues with anaglyphs they do have the one big advantage that they can be transmitted/presented using traditional single channel media such as print, film, television, etc.

Rfinal = Rleft
Gfinal = 0
Bfinal = Bright

Red on left, blue on right.

Anaglyphs are a straightforward way of presenting stereo pair images to the appropriate eye. The glasses have two different colour filters, for example, red on the right eye and blue on the left eye. The image that is destined for the left eye is coloured in shades of blue while the image destined for the right eye is coloured in shades of red. Note: if the glasses have the filters around the other way simply reverse them to view the images on this page.

There are three types of anaglyph glasses in common use, red-blue, red-cyan, and red-green. Click on any of the images on this page for the full size version.

The main advantage of anaglyphs is they can viewed with a minimum of hardware and expense. Cardboard glasses are cheap enough for anyone to own and it is easy to distribute them in magazines or or other media (cereal boxes) for promotional exercises. There have also been a number of successful television shows broadcast using this method. A number of movies were made using anaglyphs, their popularity faded when colour filming became possible, audiences would rather see non-stereo colour movies instead of stereoscopic black and white movies. The main drawback with this form of stereo 3D imagery is that it the images have colour distortion.

Rfinal = Greyleft
Gfinal = (Greyleft + Greyright)/2
Bfinal = Greyright

Red on left, blue on right.

Photoshop

Given two stereo pair images, they can readily be combined with PhotoShop by turning each image into greyscale and pasting it into the appropriate "channel" (r,g,b) of a third image. For an optimal effect the colours used should be matched to the exact colour of the display/glasses. Simple calibration charts can be created that allow tuning of television or computer monitors to the colours used in the glasses.

OpenGL

Rendering anaglyphs in OpenGL is straightforward with the help of the routine glColorMask(). The basic idea is to create the scene with all the surfaces coloured pure white. Render the scene twice, once for each eye. If designing for glasses with the red filter on the right eye and the blue filter on the left eye then before rendering the right eye, call glColorMask(GL_TRUE,GL_FALSE,GL_FALSE,GL_FALSE); and before rendering the left eye, call glColorMask(GL_FALSE,GL_FALSE,GL_TRUE,GL_FALSE); If your OpenGL hardware supports stereo buffers then the above can be implemented directly, if not then one needs to render the scene twice and use the accumulation buffer to merge them, see later.


Red on left, blue on right.

Red on left, blue on right.

There is no reason why animations can't be created as illustrated below for a simple mathematical knot. This is a further illustration of how suited this method is to the WWW, there are only a few colours required to render the red and blue (or green) images which is suited to the maximum 256 colour table using animated gifs. Of course any other animation format can be used in general, such as AVI, MPEG, QuickTime, etc.


Red on right, blue on left.

Colour

Strictly speaking it is possible to have colours in the anaglyph. In particular, the object in the scene that are at or about the focal depth can be in colour since they are seen by both eyes. While calour can be added by carefully designing the image, it is hard to include colour automatically. One algorithm that adds colour and also makes the images "look better" when viewed without glasses involves averaging the non-filter primary. For example for red/blue glasses the left eye contributes the red in the final image, the right eye contributes the right eye of the final image, the green component of the final image is the average of the green channel from the left and right eye image.

Rfinal = Rleft
Gfinal = (Gleft + Gright) / 2
Bfinal = Bright


Red on left, blue on right.

Red on left, blue on right.

Red/Cyan

Increasingly the standard glasses being used are red/cyan. The mapping commonly used is to take the red channel from the left image and the green/blue channel from the left eye.

Rfinal = Rleft
Gfinal = Gright
Bfinal = Bright


PLACE-Hampi: Sarah Kenderdine, Jeffrey Shaw & John Gollings. ICinema, UNSW

The same can be accomplished but on a grey scale image.

Rfinal = Greyleft
Gfinal = Greyright
Bfinal = Greyright




Creating Anaglyphs using OpenGL

or

A simple example using the OpenGL accumulation buffer

Written by Paul Bourke
August 2000

Introduction
Would you like to experiment with interactive stereographics but your graphics card doesn't support stereographics or even left and right buffers? Have you lost or never had a pair of LCD shutter glasses and don't want to pay for a pair? The following shows how to create anaglyphs using OpenGL and the accumulation buffer. It supports all the major filter colours and illustrates how to correctly form stereo pairs. A number of simple geometric forms are supplied to illustrate the principle, it should be a very simple task to add other models and provide more sophisticated interaction. While anaglyphs are somewhat the "old fashioned" way of creating stereographic images, they are still effective, even if they are limited to monochromatic images.

Approach

Stereographics primarily requires that two images (one for each eye) are presented independently to our two eyes. If these two views of a 3D model are computed correctly the human brain will fuse them and give us a stronger depth perception than we normally get with a single image There are a number of ways this can be achieved, this document deals with anaglyphs in which the left and right eye images are made up of two independent colours. By wearing glasses with matching filters, the left eye image is delivered to the left eye and the right eye image to the right eye.

Whatever technique is used, the scene needs to be rendered twice, once for each eye position. The two resulting images need to be filtered and combined before being presented to the user. The two images are most conveniently added together by using the accumulation buffer. There are only a small number of things that need to be changed to an existing OpenGL program in order for it to support anaglyphs, these are outlined below.

  • Initialise the accumulation buffer in glut, for example:
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_ACCUM | GLUT_RGB | GLUT_DEPTH);

  • Set the clear colour for the accumulation buffer (black as used here is the default), for example:
    glClearAccum(0.0,0.0,0.0,0.0);

  • Clear the accumulation buffer when necessary
    glClear(GL_ACCUM_BUFFER_BIT);

  • Copy the current drawing buffer to the accumulation buffer. This would normally be done after the left eye image has been drawn. Note: strictly speaking if GL_LOAD is used then it isn't necessary to clear the accumulation buffer beforehand.
    glAccum(GL_LOAD,1.0);

  • Add the current drawing buffer to the accumulation buffer. This would normally done after the right eye image has been drawn.
    glAccum(GL_ACCUM,1.0);

  • Copy the accumulation buffer to the current drawing buffer. After this the current drawing buffer (back buffer say) would be swapped to the front buffer.
    glAccum(GL_RETURN,1.0);

  • The glAccum() functions act upon the current read and write buffers, for example these might be set as follows:
    glDrawBuffer(GL_BACK);
    glReadBuffer(GL_BACK);

In order to draw the left and right eye scene in the appropriate colour for the filters in the glasses, one could specify one colour when drawing the left eye image and another for the right eye image. This is a bit clumsy, a much easier way is to only specify colours in the scene as different shades of grey and apply glColorMask() to do the filtering automatically. For more details on the whole process see the source code.

Source code
anaglyph.c and anaglyph.h

Example models
The window shots on the right show the different 3D models available in the demo application (right mouse button for menus). For examples using different colour filters you will need to get and compile the software. The software as it is provided supports the three most common types of anaglyph glasses, that is, red-blue, red-green, and red-cyan. The last type has the extra advantage that where the objects intersect they form a greyscale image which is easier to look at and appreciate without glasses a well as resulting in less ghosting with glasses.

Feedback from Michael Callahan

If you're rendering with the hardware red and blue (for example, using color masks), then the colors do not overlap at all. So if you aren't already using the blend function for something else, the accumulation buffer is unnecessary:

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    glColorMask(GL_TRUE, GL_FALSE, GL_FALSE, GL_TRUE);
    
    // set camera for blue eye, red will be filtered.
    
    // draw scene
    
    glClear(GL_DEPTH_BUFFER_BIT);
    glEnable(GL_BLEND);
    glBlendFunc(GL_ONE, GL_ONE);
    
    glColorMask(GL_FALSE, GL_FALSE, GL_TRUE, GL_TRUE);
    
    // set camera for red eye, blue will be filtered.
    
    // draw scene

Feedback from Daniel van Vugt

Daniel van Vugt pointed out that the accumulation buffer isn't actually needed resulting in a much faster implementation.

"Because the two images do not overlap in colour space, no kind of blending or accumulation is actually doing anything. Just remember to clear the depth buffer for each image, but don't clear the colour buffer between the two images."

New, faster, source code