Randi Rost
Hewlett-Packard
970-229-2447
rost@tortola.fc.hp.com

-----------------------------------------------------------------------------


OpenGL RGBA Image Rendering Pipeline (destination is an RGBA visual)

1.  Image data exist in main memory (as either RGBA or color index values)
2.  Extract subimage, performing byte swapping if necessary
3.  If pixels are RGBA pixels, convert all components to floats (logically,
    but not always necessary in practice)
4.  If pixels are RGBA pixels, convert all component groups to full RGBA
    (again, logically, but not necessary in practice)
5a. If pixels are RGBA pixels, perform ax+b operation on each component
5b. If pixels are color index pixels, perform index shift and offset on
    each index value
6a. If pixels are RGBA values, go through lookup table (OpenGL RGBA to RGBA
    lookup, controlled by GL_MAP_COLOR)
6b. If pixels are color index values, go through lookup table (OpenGL color
    index to RGBA lookup, controlled by GL_MAP_COLOR)
7.  LUT (COLOR_TABLE_SGI from the SGI_color_table extension)
8.  Convolve (including post-convolution scale and bias)
9.  LUT (POST_CONVOLUTION_COLOR_TABLE_SGI, from SGI_color_table extension)
10. Color matrix (including post-color matrix scale and bias)
11. LUT (POST_COLOR_MATRIX_COLOR_TABLE_SGI, from SGI_color_table extension)
12. Histogram, min/max
13. Zoom
14. Write fragments to the display (includes normal per-fragment operations:
    texture, fog, blend, etc.)

Notes:

Steps #1-6 and #13-14 are in core OpenGL.  The rest come from the imaging
extensions. Steps #7, 9, 11 come from the SGI_color_table extension.
Step #8 comes from the EXT_convolution extension.  Step #10 comes from
the SGI_color_matrix extension.  Step #12 comes from the EXT_histogram
extension.

You may notice there is nothing to support image rotation.  I would propose
that we add an affine transformation stage after step #9 in order to support
image scale, rotate, and translate with proper resampling controls.  To follow
the example set for the convolve and color matrix extensions, we may want
to follow this with a LUT that would be the means for accomplishing
window-level mapping.

The zoom function defined by core OpenGL seems insufficient and occurs at the
wrong point in the pipeline.

How are the typical imaging scale/rotate/resample operations performed in
the SGI model?  Steps 1-9 are performed on an image that is being loaded into
texture memory.  A rectangle is drawn with the geometry, texture coordinates,
and texturing controls to provide the proper scaling/rotation/resampling
behavior.  This approach seems to have several drawbacks:

	1) The programming model is not simple
	2) On many architectures, traffic on the graphics bus may be
	   doubled (write to texture memory, followed by a read from
	   texture memory and write into the framebuffer)
	3) Requires texture mapping hardware to have reasonable performance

The attached extension specification proposes adding an image transformation
step that occurs immediately after step #9.  This image transformation step
supports image scale/rotate/translate operations, followed by proper
resampling, followed by another color lookup table that can be used for
window level mapping.