Recap

I am writing a ray tracer with ABAP by studying the book “Ray Tracing from the Ground Up“.
A ray tracer is able to create computer generated imagery.
If you like to know more about my motivation behind this endeavour, check out my first blog.

In my fourth blog I improved my ray tracer to render any number of objects and studied how C++ method parameters translate to the ABAP world.

The project can be found on gitHub.

 

Objectives

In this fifth blog I am updating my ray tracer to use different sampling algorithms to tackle the problem of aliasing(1).

I will demonstrate the aliasing effect by showing images created by my ray tracer and allow you to compare different sampling algorithms to minimize the aliasing effect.

 

Aliasing & Antialiasing

The aliasing effect, in the context of computer generated images, describes artefacts, which are often unpleasant to look at.

Aliasing is an inherent problem of ray tracing, which can never be fully overcome.

This problem results from the fact, that the mathematical definition of the objects allows for infinite detail.
But to make these details visible to our eyes, we have to map them to the finite area of a pixel.

We are squeezing more information into a pixel, which only can hold a single color, this in return leads to a loss of details/information and creates patterns/artifacts in the rendered image.

 

The following image shows my very first rendering.

 

Sphere with one ray per pixel.

Magnified border of the sphere

 

The jagged border line is a very common artefact caused by aliasing.

When shooting a ray from the center of each pixel, it either hits the object surface or misses it. In the end the pixel gets the full opaque color of the object or the background.

 

Suffern, (2007). Figure04.01. [EPS image]
Available at: raytracegroundup.com (2) [Accessed 28. Jan. 2018]

 

One solution to this problem is to cast more than one ray for a single pixel and to average the colors to define the visible pixel color. This is called sampling. So, one could also say, using more than one sample helps to have a better approximation of the world being rendered.

The following figure 04.03 shows the top left pixel from the figure 04.01.
25 samples are cast (left) and each returns either yellow or grey (center). The color values are then averaged so that the final color is a desaturated yellow. (right)

 

Suffern, (2007). Figure04.03. [EPS image]
Available at: raytracegroundup.com (2) [Accessed 28. Jan. 2018]

 

Subdividing a pixel evenly and shooting rays from the center of each individual subpixel is also called uniform or regular sampling.

The following images have regular sampling applied to perform antialiasing on the sphere’s edge. Each pixel is determined by using 16 samples.

Sphere with regular sampling (16 samples)

Magnified border of the sphere, which got antialiased.

 

Another example to illustrate the problem of aliasing is the sinusoid function (3), which is a mathematical representation describing continuously shrinking waves.

The following image got rendered in the range (x,y) = [0, 3.79]². The smallest wave gets represented by around 5 pixel. No artifacts are present.

 

Sinusoid function

 

If the same resolution is used to display a larger range ((x,y) = [0, 10.83]²), a pattern unfolds, which is also known as moiré (4), which results from the waves getting so small that they cannot be represented by a single pixel.

 

Moiré pattern

 

Now I am applying regular sampling with 16 samples per pixel, as a result the strength of the pattern decreases, but it’s still visible. In fact, if the contrast of this image would be highly increased the same pattern unfolds again, as you can also see in the following picture.
This pattern results from the fact that the samples are all evenly and uniformly spaced from each other, which shifts the problem, but doesn’t solve it.

 

Regular sampling applied (16 samples)

 

As you can see in the next image: An alternative solution is to implement another sampling algorithm, where the samples are randomly distributed within the area a pixel spans. This will create a noise pattern to which the human eye is much more forgiving compared to a distinct pattern.

 

Random sampling applied (16 samples)

 

But random sampling can result in sample gaps or clusters, which cause under- or oversampling. Another algorithm called Jittered sampling randomizes the rays only inside the area of each subpixel, which causes more evenly spaced samples.

 

Suffern, (2007). Figure04.07. [EPS image]
Available at: raytracegroundup.com (2) [Accessed 28. Jan. 2018]

(left) 25 random samples
(center) 25 Jittered samples
(right) Like the center, but with subpixels displayed

 

The following rendering has Jittered sampling applied.

 

Jittered Sampling (16 samples)

 

There are many more sampling algorithms, like Multi-Jittered, Hammersley, N-Rooks, which are covered in the book but not covered in my blog as this would again make the length of the article awfully long and I try to learn from my mistakes ;).

Bottom line: Sampling helps to get a better approximation, like finer details, smoother edges, sharper textures at the cost of performance. Various algorithms exist which have different characteristics.

Sampling will be used in several occasions during ray tracing, not only when I fight jagged edges, but also when area lights and soft shadows are going to be implemented in later chapters.

 

Language Differences

Integer division

What caused me some serious headaches during the conversion of the C++ sampling algorithms to ABAP is the difference how both languages handle integer division. Look for yourself:

// C++
int val = 1;
val = val / 2; 
// val is zero

"ABAP
DATA val TYPE int4 VALUE 1.
val = val / 2.
"val is one

I ended up using trunc and a float value:

"ABAP
DATA val TYPE int4 VALUE 1.
val = trunc( val / '2.0' ).
"val is zero

 

Conclusion

This blog concludes chapter 4 and 5 of the book.

By casting additional samples per pixel, my ray tracer can solve alias effects like jagged edges or moiré patterns.
I implemented several sampling algorithms to study their characteristics.

And I also learned that integer division is handled differently by ABAP compared to C++, which I solved by using trunc and float division.

 

What’s Next

The implementation of perspective viewing to my ray tracer will be the follow-up topic to this blog.

 

Thanks,
André

 

Resource

1. https://en.wikipedia.org/wiki/Aliasing
2. http://www.raytracegroundup.com/downloads/IllustratorDiagrams.zip
3. https://en.wikipedia.org/wiki/Sine_wave
4. https://en.wikipedia.org/wiki/Moir%C3%A9_pattern