Display Technologies: CRTs Raster Displays

Transcription

1 Rasterization

2 Display Technologies: CRTs Raster Displays Raster: A rectangular array of points or dots Pixel: One dot or picture element of the raster Scanline: A row of pixels Rasterize: find the set of pixels corresponding to a 2D shape (line, circle, polygon)

3 Display Technologies: CRTs Raster Displays Frame must be refreshed to draw new images As new pixels are struck by electron beam, others are decaying Electron beam must hit all pixels frequently to eliminate flicker Critical fusion frequency Typically 60 times/sec Varies with intensity, individuals, phosphor persistence, lighting...

4 Display Technologies: CRTs Raster CRT pros: Allows solids, not just wireframes Leverages low-cost CRT technology (i.e., TVs) Bright! Display emits light Cons: Requires screen-size memory array Discrete sampling (pixels) Practical limit on size (call it 40 inches) Bulky Finicky (convergence, warp, etc)

5 Framebuffers So far we ve talked about the physical display device How does the interface between the device and the computer s notion of an image look? Framebuffer: A memory array in which the computer stores an image On most computers, separate memory bank from main memory (why?) Many different variations, motivated by cost of memory

6 Rasterization Rasterization is the process by which a primitive is converted to a two-dimensional image Each point of this image contains such information as color and depth Rasterizing a primitive consists of two parts. 1. Determine which squares of an integer grid in window coordinates are occupied by the primitive 2. Assigning a color and a depth value to each such square Slide based on OpenGL documentation

7 Rasterization The results of this process are passed on to the next stage of the GL pipeline, which uses the information to update the appropriate locations in the framebuffer

8 Line-Drawing Algorithms Our first adventure into Rasterization aka scan conversion Due to the scanning nature of raster displays Algorithms are fundamental to both 2-D and 3-D computer graphics Transforming the continuous into this discrete (sampling) Most incremental line-drawing algorithms were first developed for pen-plotters

9 Line-Drawing Algorithms Most of the early scan-conversion algorithms developed for plotters can be attributed to one man, Jack Bresenham.

10 Quest for the Ideal Line The best we can do is a discrete approximation of an ideal line. Important line qualities Continuous appearance Uniform thickness and brightness Turn on the pixels nearest the ideal line How fast is the line generated

11 Simple Line Based on the simple slope-intercept algorithm from algebra ( y = m x + b ) public void linesimple(int x0, int y0, int x1, int y1, Color color) { int pix = color.getrgb(); int dx = x1 - x0; int dy = y1 - y0; } raster.setpixel(pix, x0, y0); if (dx!= 0) { float m = (float) dy / (float) dx; float b = y0 - m*x0; dx = (x1 > x0)? 1 : -1; while (x0!= x1) { x0 += dx; y0 = Math.round(m*x0 + b); raster.setpixel(pix, x0, y0); } }

12 linesimple() Demo The Demo Does it work?? Try various slopes? What happens for slopes greater than 1? This algorithm works well when the desired line's slope is less than 1, but the lines become more and more discontinuous as the slope increases beyond one Since this algorithm iterates over values of x between x 0 and x 1 there is a pixel drawn in each column Slope is greater than 1 = Often more than one pixel drawn in each column for the line to appear continuous

13 Lets Improve linesimple() Problem: linesimple() does not give satisfactory results for slopes > 1 Solution: Symmetry

14 lineimproved() Demo

15 Optimize Inner Loops Optimize those code fragments where the algorithm spends most of its time Often these fragments are inside loops Overall code organization

16 Optimizations Remove unnecessary method invocations Use incremental calculations

17 Modified Algorithm This line drawing algorithm is called a Digital Differential Analyzer or DDA for short

18 linedda() Demo You should not see any difference in the lines generated by this method and the lineimproved( ) method mentioned previously The main difference should only be speed When optimizing, it is important to verify at each step that the algorithm remains intact

19 Benchmarking Many modern optimizing compilers will automatically find the sorts of optimizations that we applied here (inlining function calls within loops and converting functions to incremental calculation). Raises the question: Is it better to retain readable code, and depend a compiler to do the optimization implicitly, or code the optimization explicitly with some loss in readability? The answer is not clear cut. In general, you should make your code as readable as possible.

20 Optimizing On the other hand, you should also seldom trade-off portability for elegance. Thus, if your application depends on a fast algorithm, you are better off coding directly rather than depending on a compiler to do your work Compiler versions and platforms change more frequently than your code!

21 Low-level optimizations Low-level optimizations are dubious, because they depend on specific machine details. However, a set of general rules that are more-or-less consistent across machines include: Addition and Subtraction are generally faster than Multiplication. Multiplication is generally faster than Division. Using tables to evaluate discrete functions is faster than computing them Integer calculations are faster than floating-point calculations. Avoid unnecessary computation by testing for various special cases. The intrinsic tests available to most machines are greater than, less than, greater than or equal, and less than or equal to zero (not an arbitrary value).

22 Applications of Low-level Optimizations Notice that the slope is always rational (a ratio of 2 integers) Note that the incremental part of the algorithm never generates a new y that is more than one unit away from the old one (slope is always less than one)

23 Applications of Low-level Optimizations If we maintained only the fraction part of y we could still draw a line by noting when this fraction exceeded one. If we initialize the fraction with 0.5, then we will also handle the rounding correctly as in our DDA routine

24 More Low-level Optimizations

25 More Low-level Optimizations

26 Bresenham s Algorithm

27 linebresenham() Demonstration Does it work? Was it worth all the trouble? Lets check Benchmarking Applet:

28 Question Infrastructure There is still a hidden multiply inside of our inner loop Our next optimization of Bresenham s algorithm eliminates even this multiply

29 Faster Bresenham Algorithm

30 Benchmarking How fast is Fast Bresenham Algorithm?

31 Life After Bresenham Most books would have you believe that the development of line drawing algorithms ended with Bresenham's famous algorithm. But there has been some significant work since then. The following 2-step algorithm, developed by Xiaolin Wu, is a good example. The interesting story of this algorithm's development is discussed in an article that appears in Graphics Gems I by Brian Wyvill.

32 The Two-Step algorithm The two-step algorithm takes the interesting approach of treating line drawing as a automaton, or finite state machine. If one looks at the possible configurations that the next two pixels of a line, it is easy to see that only a finite set of possibilities exist. The two-step algorithm also exploits the symmetry of line-drawing by simultaneously drawn from both ends towards the midpoint. Code snippet

33 Benchmarking Was the 2-step algorithm faster?

34 Many more important issues Outstanding issues Non-integer endpoints (occurs frequently with 3D lines) Can we make the lines appear less jaggy? (Antialiasing coming soon) What if a line endpoint lies outside the viewing area? How do you handle thick lines? Optimizations for connected line segments

35 Circle Drawing Algorithm Come up with an algorithm to draw a circle? 2/2/2 Refer to the provided midpoint circle algorithm What about filling the circle with a particular color? Flood fill algorithm

36 Trivia Graphics Gems series of books This series focuses on short to medium length pieces of code which perform a wide variety of computer graphics related tasks.