Antialiasing

1. CAP4730: Computational Structures in Computer Graphics Antialiasing

2. Outline • What is antialiasing? • How do we see the affects of antialiasing? • What can we do about it? • Math behind antialiasing • Antialiasing in modern day graphics cards • Advanced stuff on AA

3. Let’s Revisit a pixel • A pixel is which of these things (theoretically)? • point • circle/disk • square/rectangle • has area • has a location • sample

4. White Picket Fence • What happens when we back away? • 1: with a camera /eye • 2: with OpenGL • 3: with ray-tracing • What’s the cause of the difference? • A pixel could be too BIG!

5. A New Thought about Images • Images are really a 2D function • Here’s an image plotted as a height field • Now we store this image as an “array” of points. What does that mean?

6. We Sample the Image Function • Here is the sampling function. It is called the delta function

7. Thus we are “sampling” a continuous image function • We call these samples at this regular grid of points, pixels. • Pixels are a sampling of the function that describes the image. • We store these pixels into memory as an array of colors. • How densely should we sample? • What would govern this?

8. Samples • Continuous - function with values at any input. Most things in the world. Ex. sine and cosine • Discrete - function with values only at specific inputs. Computers are discrete. • What is a 1D example? a 2D example? • To convert from a continuous function to a discrete one, we discretize or sample • To convert form a continuous variable to a discrete one, we quantize • When we render an image (which is a continuous function, why?), we sample and quantize

9. Let’s get grounded with an example

10. Similar examples? • High frequency information, low sampling. • Examples? • Train comes every 2 hours. You go every 2:15. How long do you wait? • Audio. 44/48 Khz signal. 11 Khz Sample • What is the result? • Images • 8 MP vs 4 MP vs 640 x 480

11. A quick footnote into frequency analysis • A way to understand the sampling question is to convert the function into a different “space” or domain. • We use the Fourier Transform to convert the function (in our case the image) into the frequency domain.

12. What does sampling mean? • What happens if we don’t sample enough?

13. Aliasing • If we sample at too low a rate, the high frequencies in the image appear as lower frequencies. • How do we fix it? • Increase sampling • Remove high frequencies

14. Aliasing Manifestations • Pixels approximating a signal • Pixels aren’t small enough and MISS information

15. Aliasing • Aliasing manifests itself as “jaggies” in graphics. Thus we don’t have enough pixels to accurately represent the underlying function. Check out what happens when we increase our sampling.

16. Aliasing • Aliasing also manifests itself in repeating patterns • Car wheels • Big picture: • Continuous signal • Discrete sampling (pixels, frames, etc.) • Aliasing represents misrepresentation (hence the name) involved • How do we fix it?

17. Fixing Aliasing • Increase Resolution • What’s wrong with this approach? • Filtering is another possibility • We want to remove the high frequency areas • How would we do that? • Let’s re-examine what a pixel is in reality.

18. Pixels are points • But when we display the points, what happens? • Each pixel is actually a “blob” on the CRT. This blob has energy that falls off close to a Gaussian. • Thus the CRT has a built in “blurring” system. Think about how this works with resolution of your monitor.

19. Let’s recall (4,2) 2 1 (0,0) (4,0) 0 0 1 2 3 4

20. Point Sampling • Thus for each pixel, we are “sampling” a specific point. In the frequency domain we get: • To convert from frequency to spatial domains, we do an integration. • To get around point sampling we should come up with another sampling technique

21. BiLinear Sampling • What we will do is use a bilinear filter. • This reduces the high frequencies (which cause aliasing) • Interpolate between samples.

22. BiLinear Sampling

23. What are we doing? (4,2) 2 1 (0,0) (4,0) 0 0 1 2 3 4

24. Blurring • Remember, blurring removes high frequencies, which cause aliasing. • We can do other filtering besides bilinear, and we would like to to avoid artifacts. • http://graphics.lcs.mit.edu/classes/6.837/F98/Lecture11/Slide27.html • How would we blur using our traditional graphics pipeline?

25. Two ways to Antialias • Increase resolution (increase sampling) • or • Supersampling

26. Increase Rendering Resolution • Render the image at a higher resolution and downsample. • Really, you are letting your eye do some filtering for you.

27. Supersampling • For each pixel, we would like to figure out what “percentage” is covered. 1 (0,0) (4,0) 0 0 1 2 3 4

28. Supersampling • For each pixel, sample at multiple points. • What is the distribution of these points? • Uniform Grid • Random • Psuedo-random • How many? • How far away from center should I try? • How would I program this?

29. Line Antialiasing

30. Full Screen Antialiasing • Another way to do the supersampling is to do full screen antialiasing • We want to draw the image with several camera jitter positions and average the answers • Can you see why this would give us near similar answers? • That’s what they mean by 2-tap, 4-tap antialiasing • What does this require? • Memory-wise • Computation-wise • How would you implement this?

31. Full Screen Antialiasing Example (Exaggerated)

32. Antialiasing in OpenGL • To do this in OpenGL, use the Accumulation buffer • glAccum(GL_ACCUM, FRAMES_TO_AVERAGE); • glAccum(GL_LOAD, 1); • glAccum(GL_RETURN); • VERY SLOW! What does this mean memory wise? • Other approahces: graphics cards, quincux

33. Aliasing Examples • From: http://www.os2ezine.com/v1n7/colorwks.html

35. Hardware Antialiasing • Don’t just generate 1 answer to write to a pixel • nVidia Quincunx AA (2000 – GeForce3) • Result

36. Results from http://www.techreport.com/etc/2005q3/sli-aa/index.x?pg=4

37. Difference

38. OpenGL Antialiasing • Points and Lines • glEnable(GL_POINT_SMOOTH); • glEnable(GL_LINE_SMOOTH); • Triangles • glEnable(GL_POLYGON_SMOOTH); • Provides blend alpha at edges of a triangle