Discrete Techniques

1. Discrete Techniques Chapter 8

2. Introduction: • Texture mapping, antialiasing, compositing, and alpha blending are only a few of the techniques that become possible when the API allows us to work with discrete buffers. • This chapter introduces these techniques, focusing on those that are supported by OpenGL and by similar APIs. Chapter 8 -- Discrete Techniques

3. Introduction: (cont) • We start by looking at the frame buffer in more detail and how we can read and write to it. • We learn to work with arrays of pixels that form digital images. • We then consider mapping methods. • We will then look at some of the other buffers that are supported by the OpenGL API Chapter 8 -- Discrete Techniques

4. 1. Buffers • We have already used two types of buffers: Color buffers and Depth buffers. Later we will introduce others. • What all buffers have in common is that they are inherently discrete. • They have limited resolution, both spatially and in depth. Chapter 8 -- Discrete Techniques

5. Define a buffer by its spatial resolution (n x m) and its depth k, the number of bits/pixel pixel Chapter 8 -- Discrete Techniques

6. OpenGL defines the frame buffer as consisting of a variety of buffers Chapter 8 -- Discrete Techniques

7. OpenGL buffers • Color buffers can be displayed • Front • Back • Auxiliary • Overlay • Depth • Accumulation • High resolution buffer • Stencil • Holds masks • The depth of these buffers combined can exceed a few hundred bits. Chapter 8 -- Discrete Techniques

8. 2. Digital Images • Before we look at how the graphics system can work with digital images through pixel and bit operations, let’s examine what we mean by a digital image. • Within our programs, we generally work with images that are arrays of pixels. • These images can be of a variety of sizes and data types, depending upon the type of image with which we are working. Chapter 8 -- Discrete Techniques

9. Image Formats • We often work with images in a standard format (JPEG, TIFF, GIF) • How do we read/write such images with OpenGL? • No support in OpenGL • OpenGL knows nothing of image formats • Some code available on Web • Can write readers/writers for some simple formats in OpenGL Chapter 8 -- Discrete Techniques

10. Displaying a PPM Image • PPM is a very simple format • Each image file consists of a header followed by all the pixel data • Header P3 # comment 1 # comment 2 . #comment n rows columns maxvalue pixels Chapter 8 -- Discrete Techniques

11. Reading the Header FILE *fd; int k, nm; char c; int i; char b[100]; float s; int red, green, blue; printf("enter file name\n"); scanf("%s", b); fd = fopen(b, "r"); fscanf(fd,"%[^\n] ",b); if(b[0]!='P'|| b[1] != '3'){ printf("%s is not a PPM file!\n", b); exit(0); } printf("%s is a PPM file\n",b); check for “P3” in first line Chapter 8 -- Discrete Techniques

12. Reading the Header (cont) fscanf(fd, "%c",&c); while(c == '#') { fscanf(fd, "%[^\n] ", b); printf("%s\n",b); fscanf(fd, "%c",&c); } ungetc(c,fd); • skip over comments by looking for # in first column Chapter 8 -- Discrete Techniques

13. Reading the Data fscanf(fd, "%d %d %d", &n, &m, &k); printf("%d rows %d columns max value= %d\n",n,m,k); nm = n*m; image=malloc(3*sizeof(GLuint)*nm); s=255./k; for(i=0;i<nm;i++) { fscanf(fd,"%d %d %d",&red, &green, &blue ); image[3*nm-3*i-3]=red; image[3*nm-3*i-2]=green; image[3*nm-3*i-1]=blue; } Chapter 8 -- Discrete Techniques

14. Scaling the Image Data • We can scale the image in the pipeline glPixelTransferf(GL_RED_SCALE, s); glPixelTransferf(GL_GREEN_SCALE, s); glPixelTransferf(GL_BLUE_SCALE, s); • We may have to swap bytes when we go from processor memory to the frame buffer depending on the processor. If so, we can use glPixelStorei(GL_UNPACK_SWAP_BYTES,GL_TRUE); Chapter 8 -- Discrete Techniques

15. The display callback void display() { glClear(GL_COLOR_BUFFER_BIT); glRasterPos2i(0,0); glDrawPixels(n,m,GL_RGB, GL_UNSIGNED_INT, image); glFlush(); } Chapter 8 -- Discrete Techniques

16. 3. Writing into Buffers • Conceptually, we can consider all of memory as a large two-dimensional array of pixels • We read and write rectangular block of pixels • Bit block transfer (bitblt) operations • The frame buffer is part of this memory memory source frame buffer (destination) writing into frame buffer Chapter 8 -- Discrete Techniques

17. Note that, from the hardware perspective, the type of processing involved has none of the characteristics of the processing of geometric objects. • Consequently the hardware that optimizes bitblt operations has a completely different architecture from the pipeline hardware that we used for geometric operations. • Thus, the OpenGL architecture contains both a geometric pipeline and a pixel pipeline, each of which is usually implemented separately Chapter 8 -- Discrete Techniques

18. 3.1 Writing Modes • Read destination pixel before writing source Chapter 8 -- Discrete Techniques

19. Writing Modes • Source and destination bits are combined bitwise • 16 possible functions (one per column in table) XOR replace OR Chapter 8 -- Discrete Techniques

20. 3.2 Writing with XOR • Recall from Chapter 3 that we can use XOR by enabling logic operations and selecting the XOR write mode • XOR is especially useful for swapping blocks of memory such as menus that are stored off screen • If S represents screen and M represents a menu • the sequence • S  S  M • M  S  M • S  S  M • swaps the S and M Chapter 8 -- Discrete Techniques

21. 4. Bit and Pixel Operations in OpenGL • Not only does OpenGL support a separate pixel pipeline and a variety of buffers, but also data can be moved among these buffers and between buffers and the processor memory. • The plethora of formats and types can make writing efficient code for dealing with bits and pixels a difficult task. We shall not discuss what the details are, but instead shall look at what capabilities are supported. Chapter 8 -- Discrete Techniques

22. 4.1 OpenGL Buffers and the Pixel Pipeline • OpenGL has a separate pipeline for pixels • Writing pixels involves • Moving pixels from processor memory to the frame buffer • Format conversions • Mapping, Lookups, Tests • Reading pixels • Format conversion Chapter 8 -- Discrete Techniques

23. Raster Position • OpenGL maintains a raster position as part of the state • Set by glRasterPos*() • glRasterPos3f(x, y, z); • The raster position is a geometric entity • Passes through geometric pipeline • Eventually yields a 2D position in screen coordinates • This position in the frame buffer is where the next raster primitive is drawn Chapter 8 -- Discrete Techniques

24. Buffer Selection • OpenGL can draw into or read from any of the color buffers (front, back, auxiliary) • Default to the back buffer • Change withglDrawBuffer andglReadBuffer • Note that format of the pixels in the frame buffer is different from that of processor memory and these two types of memory reside in different places • Need packing and unpacking • Drawing and reading can be slow Chapter 8 -- Discrete Techniques

25. Bitmaps • OpenGL treats 1-bit pixels (bitmaps) differently from multi-bit pixels (pixelmaps) • Bitmaps are masks that determine if the corresponding pixel in the frame buffer is drawn with the present raster color • 0  color unchanged • 1  color changed based on writing mode • Bitmaps are useful for raster text • GLUT font:GLUT_BIT_MAP_8_BY_13 Chapter 8 -- Discrete Techniques

26. Raster Color • Same as drawing color set by glColor*() • Fixed by last call to glRasterPos*() • glColor3f(1.0, 0.0, 0.0); • glRasterPos3f(x, y, z); • glColor3f(0.0, 0.0, 1.0); • glBitmap(……. • glBegin(GL_LINES); • glVertex3f(…..) • Geometry drawn in blue • Ones in bitmap use a drawing color of red Chapter 8 -- Discrete Techniques

27. 4.2 Bitmaps • OpenGL treats arrays of one-bit pixels (bitmaps) differently from multibit pixels (pixelmaps) and provides different programming interfaces for the two cases. • Bitmaps are used for fonts and for displaying the cursor, often making use of the XOR writing mode. Chapter 8 -- Discrete Techniques

28. offset from raster position glBitmap(width, height, x0, y0, xi, yi, bitmap) increments in raster position after bitmap drawn first raster position second raster position Chapter 8 -- Discrete Techniques

29. Example: Checker Board GLubyte wb[2] = {0 x 00, 0 x ff}; GLubyte check[512]; int i, j; for(i=0; i<64; i++) for (j=0; j<64, j++) check[i*8+j] = wb[(i/8+j)%2]; glBitmap( 64, 64, 0.0, 0.0, 0.0, 0.0, check); Chapter 8 -- Discrete Techniques

30. 4.4 Pixels and Images • OpenGL works with rectangular arrays of pixels called pixel maps or images • Pixels are in one byte ( 8 bit) chunks • Luminance (gray scale) images 1 byte/pixel • RGB 3 bytes/pixel • Three functions • Draw pixels: processor memory to frame buffer • Read pixels: frame buffer to processor memory • Copy pixels: frame buffer to frame buffer Chapter 8 -- Discrete Techniques

31. OpenGL Pixel Functions glReadPixels(x,y,width,height,format,type,myimage) size type of pixels start pixel in frame buffer type of image GLubyte myimage[512][512][3]; glReadPixels(0,0, 512, 512, GL_RGB, GL_UNSIGNED_BYTE, myimage); glDrawPixels(width,height,format,type,myimage) starts at raster position Chapter 8 -- Discrete Techniques

32. 4.5 Lookup Tables • In OpenGL, all colors can be modified by lookup tables as they are placed into buffers. • These maps are essentially the same as the color lookup tables that we introduced in Chapter 2 Chapter 8 -- Discrete Techniques

33. 5. Examples • This section considers three examples of writing pixels. • Maxwell Triangle – Chromacity of color coordinates • Pseudo Color Buffer • Picking Chapter 8 -- Discrete Techniques

34. 6. Mapping Methods • Although graphics cards can render over 10 million polygons per second, that number is insufficient for many phenomena • Clouds • Grass • Terrain • Skin Chapter 8 -- Discrete Techniques

35. Modeling an Orange • Consider the problem of modeling an orange (the fruit) • Start with an orange-colored sphere • Too simple • Replace sphere with a more complex shape • Does not capture surface characteristics (small dimples) • Takes too many polygons to model all the dimples Chapter 8 -- Discrete Techniques

36. Modeling an Orange (2) • Take a picture of a real orange, scan it, and “paste” onto simple geometric model • This process is known as texture mapping • Still might not be sufficient because resulting surface will be smooth • Need to change local shape • Bump mapping Chapter 8 -- Discrete Techniques

37. Three Types of Mapping • Texture Mapping • Uses images to fill inside of polygons • Environmental (reflection mapping) • Uses a picture of the environment for texture maps • Allows simulation of highly specular surfaces • Bump mapping • Emulates altering normal vectors during the rendering process Chapter 8 -- Discrete Techniques

38. Texture Mapping geometric model texture mapped Chapter 8 -- Discrete Techniques

39. Environment Mapping Chapter 8 -- Discrete Techniques

40. Bump Mapping Chapter 8 -- Discrete Techniques

41. 7. Texture Mapping • Textures are patterns. • They can range from regular patterns, such as stripes and checkerboards, to the complex patterns that characterize natural materials. • Textures can be 1, 2, 3, and 4 dimensional • 1D – used to create a pattern for a curve. • 3D – a block of material used to sculpt an object. • 2D is by far the most common. Chapter 8 -- Discrete Techniques

42. Where does mapping take place? • Mapping techniques are implemented at the end of the rendering pipeline • Very efficient because few polygons make it past the clipper Chapter 8 -- Discrete Techniques

43. Is it simple? • Although the idea is simple---map an image to a surface---there are 3 or 4 coordinate systems involved 2D image 3D surface Chapter 8 -- Discrete Techniques

44. Coordinate Systems • Parametric coordinates • May be used to model curved surfaces • Texture coordinates • Used to identify points in the image to be mapped • World Coordinates • Conceptually, where the mapping takes place • Screen Coordinates • Where the final image is really produced Chapter 8 -- Discrete Techniques

45. 6.1 Two-Dimensional Texture Mapping Chapter 8 -- Discrete Techniques

46. Mapping Functions • Basic problem is how to find the maps • Consider mapping from texture coordinates to a point a surface • Appear to need three functions x = x(s,t) y = y(s,t) z = z(s,t) • But we really want to go the other way (x,y,z) t s Chapter 8 -- Discrete Techniques

47. Backward Mapping • We really want to go backwards • Given a pixel, we want to know to which point on an object it corresponds • Given a point on an object, we want to know to which point in the texture it corresponds • Need a map of the form s = s(x,y,z) t = t(x,y,z) • Such functions are difficult to find in general Chapter 8 -- Discrete Techniques

48. Two-part mapping • One solution to the mapping problem is to first map the texture to a simple intermediate surface • Example: map to cylinder Chapter 8 -- Discrete Techniques

49. parametric cylinder • Cylindrical Mapping x = r cos 2p u y = r sin 2pu z = v/h maps rectangle in u,v space to cylinder of radius r and height h in world coordinates s = u t = v maps from texture space Chapter 8 -- Discrete Techniques

50. We can use a parametric sphere • Spherical Map x = r cos 2pu y = r sin 2pu cos 2pv z = r sin 2pu sin 2pv in a similar manner to the cylinder but have to decide where to put the distortion Spheres are used in environmental maps Chapter 8 -- Discrete Techniques