puray on Arunrocks

Ray Tracer in Python (Part 6) - Show Notes of "Firing All Cores"

Mon, 17 Aug 2020 12:08:10 +0530

You are reading a post from a multi-part series of articles

Ray Tracer in Python (Part 1) - Show Notes of "Points in 3D Space"
Ray Tracer in Python (Part 2) - Show Notes of "Revealing the True Colors"
Ray Tracer in Python (Part 3) - Show Notes of "3D Balls in 2D Space"
Ray Tracer in Python (Part 4) - Show Notes of "Let there be light"
Ray Tracer in Python - Show Notes of "Ray Tracing a Coronavirus"
Ray Tracer in Python (Part 5) - Show Notes of "Some Light Reflections"
Ray Tracer in Python (Part 6) - Show Notes of "Firing All Cores"

When it comes to code optimization, there is an overused statement about Premature Optimization. Here is the rarely-shown full quote:

“Programmers waste enormous amounts of time thinking about, or worrying about, the speed of noncritical parts of their programs, and these attempts at efficiency actually have a strong negative impact when debugging and maintenance are considered. We should forget about small efficiencies, say about 97% of the time: premature optimization is the root of all evil. Yet we should not pass up our opportunities in that critical 3%.” – Donald Knuth

I understand this as not worrying about small optimizations all the time. It is best to focus on the areas which have the most return on (time) investment. Usually you need to do extensive performance measurements to find those areas but there are some natural places to look.

So far, we have been not too concerned about performance especially when it affected readability (else we wouldn’t be writing it in Python). However, in the previous part we got a huge speedup by switching to the PyPy interpreter.

To me the next big opportunity lies in using all the cores. As an experienced Python programmer, I know this means using the multiprocessing module. But I also need to explain why other options, notably Python threads, would not help.

To demonstrate this I wrote a multi-threaded C program, a multi-threaded Python program and a multi-processing Python program - all doing the same thing. What was most entertaining was to watch the GIL in action where it allows only one thread to execute at a time.

Race Conditions

Race conditions are often explained using a bank ATM example. I think it can be explained in a non technical way using many real life scenarios. I wanted to explain it using a cooking example. It’s weird how many asynchronous and parallel concepts can be taught using what we do in the kitchen. So much so that technical job interviews can be made more effective by simply checking your culinary skills (“Sorry we don’t have a whiteboard, just a cutting board for you.").

Ideally the entire explanation should be animated. My drawing skills are decent but I cannot animate even a bouncing ball. Don’t laugh, just try it. Firstly, there are several cues that any animated object gives which can be only be detected if you watch in slow motion. The Twelve Principles of Animation is a good start.

Secondly, it is a lot of work. A good animator will know how to give maximum expression with the minimum frames. Timing is also crucial in animation. Even a subtle timing error makes animations look janky or confusing. Mere mortals would need to spend days to eventually produce a 5 second clip.

Animating the Race Conditions

So I took the safe approach by showing a slideshow. I think it looks decent. I might post it as a separate clip on Race Conditions so that is doesn’t get lost in this video.

These are the topics we will cover in this episode:

Introduction
- An Embarrassingly Parallel Problems
- What’s a Thread?
- Threads in C
- Threads in Python
- Race Condition Animated
- Why Python has GIL
- Multi-processing in Python
Sub-problem: Firing All Cores
Coding the solution
- Command-line argument
- Diving pixels among processes
- Passing Data via Files
- Value for Progressbar
- Bug Hunting
Performance Comparison
Topics Not Covered
Learning More
Final Words

Here is the video:

Code for part six is tagged on the Puray Github project

Show Notes

Books and articles that can help understand this part:

The Art of Multiprocessor Programming book
The Ray Tracer Challenge book
Ray Tracing in One Weekend free books
NVIDIA Ray Tracing Essentials

Note: References may contain affiliate links

Wrapping up

This concludes the ray tracing series that I had conceived more than a year back. If you make your own ray tracer, please don’t forget to tag me.

Ray Tracer in Python (Part 5) - Show Notes of "Some Light Reflections"

Tue, 12 May 2020 22:08:10 +0530

You are reading a post from a multi-part series of articles

Ray Tracer in Python (Part 1) - Show Notes of "Points in 3D Space"
Ray Tracer in Python (Part 2) - Show Notes of "Revealing the True Colors"
Ray Tracer in Python (Part 3) - Show Notes of "3D Balls in 2D Space"
Ray Tracer in Python (Part 4) - Show Notes of "Let there be light"
Ray Tracer in Python - Show Notes of "Ray Tracing a Coronavirus"
Ray Tracer in Python (Part 5) - Show Notes of "Some Light Reflections"
Ray Tracer in Python (Part 6) - Show Notes of "Firing All Cores"

One of the fascinating ways to build a complex system like a computer is to build it from scratch using simple logic gates (a good book which shows how is The Elements of Computing Systems). Same goes for late John Conway’s Game of Life which starts with a simple set of rules but shows very life-like behaviour. This is called Emergent complexity. I guess the only way to understand something that seems complex is to understand its basic principles.

Look carefully at the, by now familiar, image that we will be rendering by the end of this part:

Render of the two balls scene

Notice within the pinkish-purple ball there is a reflection of the red ball reflecting the pink ball. This kind of detailing that unfolds on closer inspection is what gives realistic renders its beauty. Yet it is governed by the most basic laws of Physics like the laws of reflection.

Reflection

The law tells us that the angle of reflection is the same as the angle of incidence. But if we apply it to the world of vectors a rather different looking formula emerges that could be derived from the very same law. The reflected ray is again traced and the process continues.

If you have been following the series closely so far, then you might point out that we have already dealt with this earlier. Yes, diffuse and specular shading are special cases of a material reflecting light. But since we are now considering mirror-like reflecting surfaces it is time to look at the general formula for reflection.

The computation for each pixel will now increase many fold so the overall render time will increase proportional to the maximum depth of reflections we need.

Procedural Materials

A plainly colored object is not quite interesting so you would find even the earliest ray traced images containing a chessboard pattern:

The Compleat Angler (1978) by Turner Whitted

So I introduce a chessboard pattern generated procedurally into the scene. Procedural textures are fascinating and a lot of fun to make. Compared to image textures, they have almost infinite detail. Sort of like analog versus digital.

The chessboard pattern’s formula is easy to guess so it is an ideal introduction. Once you start playing around there is an entire universe of textures to explore with marble, Voronoi and Perlin noise patterns. Some even go to the extend of building entire scenes with only procedural textures. This is deeply satisfying but probably pointless.

Plugin Scenes

Most toy raytracers are happy generating their scene in the main program. But this quickly becomes frustrating when you want to render a couple of examples. The straightforward solution would be to define a scene as data say using JSON and import the scene given as an argument. This is how games like Doom load levels.

JSON, YAML and other configuration languages are deceptively simple to read but you could spend a lot of time writing them due to their tiny quirks with commas and whitespaces. It is also not suited for scenes generated procedurally which is happens quite a bit in ray tracers. You would soon wish if these languages were Turing complete. So I decided to ditch all that and use plain old Python instead.

To be honest, I was not comfortable in allowing a given Python file to describe a scene. But the power and flexibility it allows is really a great tradeoff for the security. I used importlib to import modules inspired by Django.

I can now define a new procedural texture material class inside a scene! This makes the ray tracer quite extensible like a plugin system. I love this approach and look forward to trying this in future projects.

Accelerating Python

Towards the end we see a dramatic 7X speedup of the ray tracer due to the use of PyPy. I also mention my rough rule of thumb to increase Python performance:

Processor Bound? Try Pypy.
IO Bound? Try AsyncIO.

If you are learning to improve the performance of your Python program, this would be pretty bad advice. In that case, make sure you first profile your program and identify the performance hotspots. Then try different ways to optimize those places. After you have tried all that and the performance is still bad, then you can use my rule of thumb for unconventional ways to get great results.

Ray tracing concepts

With this part, I would have covered all the basic ray tracing concepts that I had planned to cover. The next part would be about improving the performance of the ray tracer by using multiple cores.

Many have contacted me asking whether I would be covering topics like Dielectrics, Depth of Field, Anti-aliasing etc. I think there are enough books like Ray Tracing Gems and Ray Tracing in One Weekend which cover all that and much more. If you have followed this series then reading those books would be much easier and you would have a ready implementation to tinker with.

Nevertheless, I may work on a follow-up if people find that useful and time permits. So do let me know.

These are the topics we will cover in this episode:

Introduction
- Laws of Reflection
- Stack Overflow
- Scene Definition
Sub-problem: Some Light Reflections
Coding the solution
- Chessboard Material
- Ground Plane
- Config vs Code as Config
- Speedup

Here is the video:

Code for part five is tagged on the Puray Github project

Show Notes

Books and articles that can help understand this part:

Derive Vector Reflection Formula: Understand how the formula can be derived from the laws of reflection.

Ray Tracer in Python - Show Notes of "Ray Tracing a Coronavirus"

Fri, 10 Apr 2020 20:08:28 +0530

You are reading a post from a multi-part series of articles

Ray Tracer in Python (Part 1) - Show Notes of "Points in 3D Space"
Ray Tracer in Python (Part 2) - Show Notes of "Revealing the True Colors"
Ray Tracer in Python (Part 3) - Show Notes of "3D Balls in 2D Space"
Ray Tracer in Python (Part 4) - Show Notes of "Let there be light"
Ray Tracer in Python - Show Notes of "Ray Tracing a Coronavirus"
Ray Tracer in Python (Part 5) - Show Notes of "Some Light Reflections"
Ray Tracer in Python (Part 6) - Show Notes of "Firing All Cores"

The first ray-traced animation I had ever seen was in my first year of Engineering. My senior showed us a gold-plated logo of the institution slowly spinning and glinting in the light. It had an amazing level of detail - a triangular frame, a gear wheel on the left, a tower on the right and even a palm tree in the center. We were dying to know how he did it. When he showed us, it blew our minds - it was all code! Every shape was made by combining (or subtracting) primitive solids like spheres, cylinders and cubes. It featured on the masthead of the first edition of our online magazine (distributed on 3 1⁄2 inch floppies).

Of course, these days 3D modelling is mostly done by artists in a graphics program like 3ds Max or Maya. But not everything is tinkered by the hand of an artist. Procedural code is still used to create thousands of unique soldiers in an army scene or an infinite world in a multiplayer game. Computer generated art can often surprise or amuse you.

So when I had to design the model of the omnipresent SAR-Cov-2 virus for a poster, even though I was very tempted to use such tools, I opted to generate the model in code. My Python raytracer (currently in it’s fourth part of the video series) was decent enough to create 3D looking spheres. Having only spheres is a big constraint but you can be more creative under constraints.

Deconstruction

There is a process fundamental to artistically recreating any real world object – Deconstruction. When you learn to draw you are asked to “block out” the simple shapes you are trying to draw. So a face becomes an elongated sphere, a nose becomes a triangle etc. If your big shapes are correctly proportioned then it will be a lot easier to add in the details.

In good old days, the computer artists used graph paper. Like my senior who traced the logo from the college magazine, enlarged it on graph paper and wrote down all the coordinates. These days you could use a 2D drawing program like Inkscape to overlay a photograph and trace over it. But the idea is essentially the same - find all the large blocking shapes that make your image.

Graph paper sketch of Prince of Persia by Jordan Mechner in 1987

Reconstruction

Generating the model in the computer can be a process of trial and error. In the days of slower computers, rendering a simple object took nearly an hour. Even with today’s dramatically faster machines, rendering a complex scene could take hours. There is simply a ton of numbers to crunch.

In the case of the coronavirus, I needed to figure out how to make a crown. Essentially I needed to position points evenly around a circle. People say a lot of things about high school trigonometry and how much of a waste of time it was. But I found it quite useful not only to arrange the spikes of the crown but also give it a slight random shift. This would mean each time you render the virus would look sightly different. I had a lot of fun animating several renders to a beat in the video.

Presentation

I couldn’t stop playing with the model even after the poster was made. I tweaked it into various color combinations that I found online. Ironically, it looks distinctively charming in any avatar.

It shows that simple things are awesome than the most professionally done creations. Especially if you could make your own. Looking forward to seeing what others would create with this.

Here is the video:

Code for part four is the starting point of the video.

Final code is also tagged in the repository.

Show Notes

Links:

Puray Video Series playlist Watch the entire video tutorial to understand how this ray tracer was made from scratch.
SARS-CoV-2 Electron Microsocope Image This article has the reference image I used.

Ray Tracer in Python (Part 4) - Show Notes of "Let there be light"

Sat, 28 Mar 2020 18:39:36 +0530

You are reading a post from a multi-part series of articles

Ray Tracer in Python (Part 1) - Show Notes of "Points in 3D Space"
Ray Tracer in Python (Part 2) - Show Notes of "Revealing the True Colors"
Ray Tracer in Python (Part 3) - Show Notes of "3D Balls in 2D Space"
Ray Tracer in Python (Part 4) - Show Notes of "Let there be light"
Ray Tracer in Python - Show Notes of "Ray Tracing a Coronavirus"
Ray Tracer in Python (Part 5) - Show Notes of "Some Light Reflections"
Ray Tracer in Python (Part 6) - Show Notes of "Firing All Cores"

Probably a global lockdown is a good time to resume a series that demands a lot of your time. Not really if your kids are home too. But I’ve been getting enough reminders through comments and emails that I thought it’s time to tackle this challenging episode.

Yes, this is an episode with a lot of Physics and Mathematics. But you will observe it has a very gentle learning curve since there is enough background presented in the problem requirements and in previous episodes. The real challenge is in translating the math to code.

Computers are computing devices crunching numbers all the time. So you might think implementing math formulas should be straightforward. Unless you are a scientist or a mathematician, in which case, you would know the truth which is – it is not straightforward at all.

I remember before Doom came out, it was very hard to develop a 3D engine. Most of the available research involved understanding computer graphics text books with a lot of math theory. It’s a painful task to translate formulas into algorithms and later performant code. There are many ways you could get it wrong. But only one way to get it right. Even more frustrating is forgetting to account for edge conditions like a negative result or divide by zero and floating point errors.

I remember referring one of the most popular books at that time Numerical Recipes in C++ to understand how to implement some of the algorithms. But I had to abandon the project after a working prototype because making a game engine (alone) is a tonne of work!

In this part, I have used a lot of images and slides to make sure that I don’t skip any explanations (like how cosine and dot products are related). I know that these videos are being watched by all kinds people – students, experienced programmers and non-programmers. So I have not made any assumptions.

Hopefully you would enjoy this part without any challenges. Even if you do, it should be fun 😊

These are the topics we will cover in this episode:

Introduction
- Adding lights
- Phong reflection model
- Ambient, Diffuse and Specular Shading
Sub-problem: Let there be light
Coding the solution
- New classes
- Command-line arguments with argparse
- Progress Bar(?)

Here is the video:

Code for part four is tagged on the Puray Github project

Show Notes

Books and articles that can help understand this part:

Game Engine Architecture Great introduction to graphics concepts and techniques used in computer games. It might be different from raytracing since focus is on realtime rendering rather than realism.
Argparse Tutorial argparse is the new standard for Python argument parsing.

Note: References may contain affiliate links

Ray Tracer in Python (Part 3) - Show Notes of "3D Balls in 2D Space"

Wed, 04 Dec 2019 22:19:43 +0530

You are reading a post from a multi-part series of articles

Ray Tracer in Python (Part 1) - Show Notes of "Points in 3D Space"
Ray Tracer in Python (Part 2) - Show Notes of "Revealing the True Colors"
Ray Tracer in Python (Part 3) - Show Notes of "3D Balls in 2D Space"
Ray Tracer in Python (Part 4) - Show Notes of "Let there be light"
Ray Tracer in Python - Show Notes of "Ray Tracing a Coronavirus"
Ray Tracer in Python (Part 5) - Show Notes of "Some Light Reflections"
Ray Tracer in Python (Part 6) - Show Notes of "Firing All Cores"

Graphics is what made Mathematics enjoyable for me. I first heard of trigonometric functions like sine and cosine when I read GW-BASIC manual. Geometry was easy to visualize with the rudimentary graphics of LINE and CIRCLE statements. While I could see many struggle with Mathematics, I always found it interesting.

So my challenge was to make this math-heavy episode interesting so that you see how I see it. I needed to give personalities to Ray and Sphere before I could show their intersection formula. This needed a lot of illustration and animation work. But I believe the end result was worth it.

This time there is a lot of furious typing and less talking because of the number of lines entered in this part. I did not want to fast forward code writing segments because it doesn’t help the learners. In any case, YouTube can speed up videos if you choose to.

These are the topics we will cover in this episode:

Introduction
- Why meshes in movies and spheres in raytracers
- Simplified ray-tracing
- Ray-sphere intersection
- Aspect Ratio Corrections
First sub-problem: 3D Balls in 2D Space
Coding the solution
- Hex colors
- Classes for Engine, Ray, Sphere, etc.
- Rendering Algorithm

Here is the video:

Code for part three is tagged on the Puray Github project

Bonus (Traffic Lights) Code is available for download.

Show Notes

Books and articles that can help understand this part:

Real-Time Collision Detection Great introduction and overview of different intersection and collision algorithms
Line–sphere intersection - Wikipedia Wikipedia page with the mathematical derivation of the formula we have used.

Note: References may contain affiliate links

Ray Tracer in Python (Part 2) - Show Notes of "Revealing the True Colors"

Sun, 17 Nov 2019 12:41:50 +0530

You are reading a post from a multi-part series of articles

Ray Tracer in Python (Part 1) - Show Notes of "Points in 3D Space"
Ray Tracer in Python (Part 2) - Show Notes of "Revealing the True Colors"
Ray Tracer in Python (Part 3) - Show Notes of "3D Balls in 2D Space"
Ray Tracer in Python (Part 4) - Show Notes of "Let there be light"
Ray Tracer in Python - Show Notes of "Ray Tracing a Coronavirus"
Ray Tracer in Python (Part 5) - Show Notes of "Some Light Reflections"
Ray Tracer in Python (Part 6) - Show Notes of "Firing All Cores"

It is always a good idea to create a visible output at the start of a long project. If you are making a game, start with showing something moving on the screen. It keeps you motivated and gives you something cool to show your friends as progress. In the second part of our ray tracer tutorial, I will introduce you to PPM a very simple image format that will be used for our renders. You don’t need to install any image libraries and yet PPM files can be read by most image viewers.

The color class is a lot simpler than what I originally designed. Features like gamma correction and linear interpolation seemed like an overkill for a project like this. But I plan to add some convenience constructors later. Hopefully, this will be a good introduction to how colors are manipulated in computer graphics.

These are the topics we will cover in this episode:

Introduction
- Compressed Image are Hard
- What Images are Made of
- RGB triplets
First sub-problem: Revealing the True Colors
Coding the solution
- Use the shebang line
- Separate classes in separate files
- Why fileobj instead of filename?

Here is the video:

Code for part two is tagged on the Puray Github project

Bonus (Gradient) Code is available for download.

Show Notes

Books and articles that can help understand this part:

Understanding Compression by Colt McAnlis, Aleks Haecky A book covering image formats like JPG, PNG etc
Python Imaging Library PIL or Pillow Popular Python library for reading and writing different image formats
A Field Guide to Digital Color by Maureen Stone Understand color theory beyond RGB triplets into vision and various color systems.

Note: References may contain affiliate links

Ray Tracer in Python (Part 1) - Show Notes of "Points in 3D Space"

Fri, 01 Nov 2019 13:55:59 +0530

You are reading a post from a multi-part series of articles

Ray Tracer in Python (Part 1) - Show Notes of "Points in 3D Space"
Ray Tracer in Python (Part 2) - Show Notes of "Revealing the True Colors"
Ray Tracer in Python (Part 3) - Show Notes of "3D Balls in 2D Space"
Ray Tracer in Python (Part 4) - Show Notes of "Let there be light"
Ray Tracer in Python - Show Notes of "Ray Tracing a Coronavirus"
Ray Tracer in Python (Part 5) - Show Notes of "Some Light Reflections"
Ray Tracer in Python (Part 6) - Show Notes of "Firing All Cores"

I’m really excited to start a new video tutorial series on creating a ray tracer from scratch. This a set of intermediate-level Python tutorials. Recently realtime ray tracing became a hot topic in the gaming community after various Minecraft Ray tracing videos started popping up. Of course, you need a monster of a machine to get decent framerates. However, we will be making an non-realtime ray tracer entirely in Python.

These are the topics we will cover in this episode:

Introduction
Who should watch this tutorial?
What will you cover?
Ray tracing in a Nutshell
Getting Familiarized with my Emacs
First sub-problem: Points in 3D Space
Coding the solution
- TDD (Test Driven Development)
- Data Structures
- 3D Vectors

Here is the video:

Code for part one is tagged on the Puray Github project

Show Notes

Books I recommend for learning Python:

Learn Python 3 the Hard Way For a hands-on approach
Learning Python, 5th Edition More detailed intro
Official Python Tutorial A quick tutorial for programmers

Some links to learn the Vector math I cover, in more detail:

Vector Math for 3D Computer Graphics Excellent free tutorial
3D Math Primer For Graphics and Game Development
Khan Academy on Linear algebra

Note: References may contain affiliate links

A Dream Forever in Making

I have been forever interested in Computer Graphics since creating computer games is what really got me interested in programming (or “coding” as it is the fashionable term now). In early days, ray traced images used to blow my mind compared to the blocky graphics that 3D games generated.

But trying to learn the algorithms was frustrating for two reasons - the mathematics seemed too dense and it took a really long time for each render. In 2015, I spent a weekend playing with various algorithms to create a simple ray tracer in Python by heavily leveraging NumPy.

Wrote a toy raytracer over the weekend in Python and NumPy. ~200 lines. Render time about 10 mins. Shiny ✨😆 pic.twitter.com/ar0GDGXCWh
— Arun 'Rocks' Ravindran (@arocks) April 12, 2015

I felt the NumPy parts looked “un-pythonic”, so I reimplemented it without NumPy. It hit a sweet spot between functionality and readability. You needn’t be a math guru to figure out how it worked. I had to share what a learnt not because there was a lack of ray tracing tutorials but I wanted to make an accessible tutorial with gentle learning curve.

However the process of creating video tutorials have changed over the years. Gone are the days of a simple screen recording or screencasts. Now we have to have slick intros, animations and click-baity thumbnails with a face overlay having a shocked expression. But honestly I am in awe of how much time people spend on making each video (it is way, way more than you think) and how frequently they make them (“new video every week”).

The challenge is even harder when you need to break down all that math and physics behind computer graphics into simple concepts in a logical flow. That also takes way more time than you would expect. Sometimes you find that one clear diagram would explain an idea perfectly but nobody has made one so far so you need to draw a fresh one. Or you need to cut down your explanation because listeners are getting lost in the details. Plus your real life slows you down with work deadlines and goof ups like out of focus video recordings. This process of iterating until my script (and code) became streamlined took me months.

My approach has always been about posting higher quality stuff at low frequencies. So I am happy if the end result was worth the wait (and I hope it is). This could be a tutorial that might outlive many of my other videos and that is satisfying in itself. Hope you’ll enjoy this journey with me as much as I did.

Check back for part 2 (EDIT: it is out)!