chapter 9

Computer Graphics using OpenGL, 3rd Edition

F. S. Hill, Jr. and S. Kelley

Chapter 9Tools for Raster Displays

S. M. LeaUniversity of North Carolina at Greensboro

© 2007, Prentice Hall

Raster Displays

• Images are composed of arrays of pixels displayed on a raster device.

• Two main ways to create images:– Scan and digitize an existing image.– Compute a value for each pixel procedurally.

• The result may be stored as a pixmap, a rectangular array of color values.

Scan Conversion (Rasterization)

• Determines individual pixel values.• Rasterization in the GL graphics pipeline:

Scan Conversion (2)

• Graphics pipeline actually produces fragments: a color, a depth, and a texture coordinate pair for each vertex.– A number of processing steps and tests are

performed on the fragments before they are written to the screen.

• We can also perform operations on images on the screen using the fragment operations portion of the pipeline.

Manipulating Pixmaps

• Pixmaps may be stored in regular memory or in the frame buffer (off-screen or on-screen).

• Rendering operations that draw into the frame buffer change the particular pixmap that is visible on the display.

Pixmap Operations: Copying

Pixmap Operations: Copying

• glReadPixels () reads a portion of the frame buffer into memory.

• glCopyPixels() copies a region in one part of the frame buffer into another region of the frame buffer.

• glDrawPixels() draws a given pixmap into the frame buffer.

• We can also copy a pixmap from memory to memory.

Scaling Pixmaps

• glPixelZoom(float sx, float sy);– Sets scale factors in x and y – Any floating point values are allowed for sx

and sy, even negative ones. The default values are 1.0.

– The scaling takes place about the current raster position, pt.

• Scale factors are applied to the image drawn from a pixmap, not to the pixmap.

Scaling Pixmaps (2)

• Roughly, the pixel in row r and column c of the pixmap will be drawn as a rectangle of width sx and height sy screen pixels, with lower left corner at screen pixel (pt.x + sx * r, pt.y + sy * c).

• More precisely, any screen pixels whose centers lie in this rectangle are drawn in the color of this pixmap pixel.

Example• Six scaled versions of the mandrill (scale factors

sx = -1.5, -1.0, -0.5, 1.5, 1.0, 0.5.) • To produce each image the new value of sx was

set, and glPixelZoom(sx, 1); glutPostRedisplay(); was executed.

Pixmap Operations (3)

• We may rotate a pixmap.• We may compare two pixmaps – e.g., to

detect tumors• We can describe regions within a pixmap

as circles, squares, and so on.• We may fill the interior of a region with a

color.

Pixmap Data Types

• A pixmap has a certain number of rows and columns, and each pixel in the array has its color stored according to certain rules.– Bitmap: pixel = bit, 0 or 1 (black or white)– Gray-scale bitmap: pixel = byte, representing

gray levels from 0 (black) through 255 (white)– Pixel contains an index into a lookup table

(LUT); usually index is a byte

Pixmap Data Types (2)

– RGB pixmap contains 3 bytes, one each for red, green, and blue

– RGBA pixmap contains 4 bytes, one each for red, green, blue, and alpha (transparency)

• Code: start by defining a color:struct RGB { public: unsigned char r, g, b; };// Holds one color triple


• OpenGL represents a pixmap as an array pixel of pixel values stored row by row from bottom to top and across each row from left to right.

• RGBpixmap class uses this storage mechanism as well (code in Fig. 9.3).

• Code uses GL functions to implement class functions.


• Default RGBpixmap constructor: make empty pixmap.

• Constructor creates a pixmap with r rows and c columns.

• setPixel() sets a specific pixel value.• getPixel() reads a specific pixel value.• draw() copies pixmap to frame buffer, placing

lower left corner at current raster position.– set current raster position using glRasterPos2i (x, y);


• read() copies from frame buffer to memory– Lower left corner is at (x,y), and wid and ht

specify the size to be read.• copy() does a read followed by a draw,

without creating an intermediate pixmap– The region with lower left corner at (x,y), wid

by ht in size, is copied to the region whose lower left corner is at the current raster position.


• readBMPFile() reads an image stored as a (24-bit) BMP file into the pixmap, allocating storage as necessary.

• writeBMPFile() creates a (24-bit) BMP file that contains the pixmap. – Code for both of these functions is given

online at the book’s companion website.

Pixmap Application

• Fig. 9.4 shows code for an application to use pixmaps controlled by mouse and keyboard.– BMP files are copied into 2 pixmaps.– One image is displayed at the initial raster

position; a left mouse click draws it again at the current mouse position.

Pixmap Application (2)

– Pressing s toggles between the 2 images.– Pressing r reads a 200 x 200 area of the

screen and replaces the first pixmap by these values.

– Right mouse click clears screen.• The SDL can use RGBpixmaps. See the

companion website for code.

Examples

• Writing and scaling BMP text to the screen: 4 x 6, 6 x 8, 8 x 12, 12 x 16

Examples (2)

• Window scrolling: blank line replaces bottom, moving all lines up one.

Scaling Pixmaps

• Scale by s: output has s times as many pixels in x and in y as input; if s is an integer, scale with pixel replication to enlarge. 6 x 8 to 12 x 16

Scaling Images (2)

• To reduce by, for example, 1/3: take every third row and column of the pixmap.

• This method is usually not satisfactory.– Instead, we should average the values of the

9 pixels in each non-overlapping 3 x 3 array, and use that value for the pixel.

Rotating Images

• Pixmaps may rotated by any amount.• Rotating through 90o, 180o, 270o is simple:

create a new pixmap and copy pixels from the original to the appropriate spot in the new pixmap.

Rotating Images

• Other rotations are difficult. Simplest approach: pixel in transformed image is set to color of pixel it was transformed from in original.

• This usually leads to bad results. You really should average overall pixels which transform (in part) to this pixel.

Rotating Images (2)

chapter 9

Documents