Introduction

Last week, we finished talking about creating projects in SDL.
We then discussed creating surfaces using Bezier techniques
We now return to the problem of texturing surfaces and in particular problems which can arise from the graininess of the texture and how to solve them.

Aliasing

One non-naturalistic artifact that can sometimes appear in computer graphics images is jagged patterns at triangle boundaries.
Such effects go by the name of aliasing artifacts.
These can occur when there is too much visual complexity to fit into a single pixel.
When we try to determine the pixel's color value, we might look at a single point location in the image domain, and get a less than optimal result.
Instead, we can mitigate this effect by averaging together the colors over many sample locations within the pixels square.
This process is known as anti-aliasing.

A continuous image, `I(x_w, y_w)` is a bivariate function. We will assume the domain is the region `Omega = [-0.5 ... W - 0.5] times [-0.5 ... H-0.5]`, used for window's coordinates.
The 0.5's in the above come from imagining each pixel extends 0.5 pixels in the negative and positive direction from its center.
The range of the function is a color space, for which we will use an RGB (linear) color space.
A discrete image `I[i][j]` is a 2D array of color values. Each such array entry is called a pixel.
The array's size is `W` in width and `H` in height, so `i in {0,1 .. W-1}`, and `j in {0, 1, ... H-1}`.
To each pair `(i, j)` we associate a continuous image coordinate `(i,j) = (x_w, y_w)`, that is real coordinates that happen to have integer values.
Each color value is a triple of scalars representing a color in color space. We again use an RGB color space. Each coordinate of this is represented in some numerical format.

In OpenGL, we describe a scene using shaded triangles in 3D.
These are then projected to a continuous 2D image domain, so one has a continuous image.
On the other hand, we wish to display this image on a monitor or save it in an image file.
So we need to be able to convert it to a discrete image.

Which of the following statements is true?

The IMG_load function can be used to load an image in png format and get an SDL_Surface pointer back.
Bessel-Overhauser splines must have knots at integer values.
The recursive subdivision technique cannot be made to work for Bezier Patches.

The easiest way to go from a continuous to a discrete image is by point sampling: To obtain the value of a pixel `(i,j)`, we sample the continuous image at a single domain location:
`I[i][j] leftarrow I(i,j)`.
This can cause problem as illustrated by the top image in the scene above which is composed of black and white triangles.
The image has a staircase pattern, jagged edge, which is caused by whether rounding meant sampling from a white or a black location in the continuous image.
If the scene were animated pixel values might suddenly change from white to black and vice versa, and the jagged edge will appear to crawl. This is sometimes called "the crawling jaggies".
Another problem can arise, when we have a high resolution texture that we are trying to apply to an object so far in the distance that it's size is only one pixel.
It is unclear which value we should sample from the texture to determine this pixel's value -- if it is left to round off, the value will tend to be sampled randomly.
This can cause a moire pattern. A moire pattern is where two identical patterns are drawn at slight rotations to each other causing weird looking banding or shapes in an image.
This "moire pattern" can also be seen in the top image above for tiles in the distance.
When such objects are animated they randomly change in color value in what's known as flickering.

One solution to the aliasing problem is to take some kind of average over samples in some appropriate region and use this for a color value.
This amounts to setting the pixel value according to some rule like:
`I[i][j] leftarrow int int_Omega dx dy I(x,y) F_(i,j)(x,y).`
Here `F_(i,j)(x,y)` is some function that tells us how strongly the continuous image value at `[x,y ]^t` should influence the pixel value at `(i,j)`. It is called a filter function.
The use of the above equation to create a discrete image is referred to as anti-aliasing.

We generally want to choose a filter that gives decent results and is fast to compute.
One very simple filter is the box filter, where `F_(i,j)(x,y)` is zero everywhere except over the `1 times 1` square centered at `x=i, y=j`. Calling this square `Omega_(i,j)`, we then need to carry out the integral
`I[i][j] leftarrow int int_(Omega_(i,j)) dx dy I(x,y) F_(i,j)(x,y).`
The above integral as it stands is still hard to compute exactly, so instead we do an approximation like:
`I[i][j] leftarrow 1/n sum_(k=1)^nI(x_k,y_k)`
where `k` indexes over some set of locations `(x_k, y_k)` called sample locations within the pixel.
This approach is called oversampling.

To do oversampling, the renderer first produces a "high resolution" color and z-buffer "image".
We use the term sample to refer to the pixels in this high-res image.
Once rasterization is complete, groups of these samples are averaged togeher, using the equation of the last slide, to create the final, lower resolution image.
If the sample locations from the high-res image come from a regular, high resolution grid, then this process is called super-sampling.
The bottom image in the checkerboard pattern a few slides back was created using this kind of sampling.
It is also possible to use an irregular pattern for sampling within a pixel to avoid systematic errors. This is waht is illustrated by the sampling in the pixel in the image above.

In OpenGL, the details of the sampling patterns are hardware dependent.
They can be changed by API calls or, more easily, by changing settings for the hardware driver in an interactive control panel.
In OpenGL it is also possible to do multsampling.
In this case, OpenGL draws to a "high resolution" color and z-buffer as in oversampling.
During rasterization of a triangle, "coverage" (how much of the triangle is in the final res pixel size) and z-values are computed at this sample level.
The fragment shader, for efficiency, is only called once per final resolution pixel.
These color data are shared among all the samples hit by the triangle in a single in a single pixel.
Once rasterization is complete, groups of these high res samples are averaged together to create the final lower res image.