An outstanding fluid simulation researcher

I am utterly impressed by Ryoichi Ando.
http://vacation.aid.design.kyushu-u.ac.jp/~and/

Currently a third year PhD student and has already produced some outstanding work. He is the guy behind smoke3d (code.google.com/p/smoke3d), 2dsmoke and other open source fluid code out there.

He invented flip3d, sheet preserving fluids (http://vacation.aid.design.kyushu-u.ac.jp/~and/sheetflip/index.html ) as well as highly adaptive liquid simulation recently published at SIGGRAPH 2013 (http://pub.ist.ac.at/group_wojtan/projects/2013_Ando_HALSoTM/index.html)

Whats realy good about him is that he has kept all of his work open sourced with a permissive BSD license. Really awesome work. 

A free online book on fundamentals of ray tracing

Although this book does not cover acceleration structures, it does give a fair amount of detail for beginners. Thought of putting a blog post in for this invaluable free resource. Here are the table of contents at a glance

Chapter 1: Introduction

Chapter 2: Digital Images

2.1 Pixels and colors

2.2 An example

2.3 Resolution

Chapter 3: Cameras, Eyes, and Ray Tracing

3.1 Images distort reality

3.2 Perspective in art

3.3 Cameras

Chapter 4: Vectors and Scalars

4.1 Scalars

4.2 Vectors

4.3 Vector addition

4.4 Vector subtraction

4.5 Scalars multiplied by vectors

4.6 Vector magnitude

4.7 Unit vectors

4.8 Vector dot products

4.9 Vector cross products

4.10 Sine and cosine: a crash course

Chapter 5: C++ Code for Ray Tracing

5.1 Platforms and redistribution

5.2 Downloading and installing

5.3 Building on Windows

5.4 Getting ready to build under OS X

5.5 Building on Linux and OS X

5.6 Running the unit tests

5.7 Example of creating a ray-traced image

5.8 The Vector class

5.9 struct LightSource

5.10 The SolidObject class

5.11 SolidObject::AppendAllIntersections

5.12 struct Intersection

5.13 Scene::SaveImage

5.14 Scene::TraceRay

5.15 Saving the final image to disk

Chapter 6: Sphere Intersections

6.1 General approach for all shapes

6.2 Parametric ray equation

6.3 Surface equation

6.4 Intersection of ray and surface

6.5 Surface normal vector

6.6 Filling in the Intersection struct

6.7 C++ sphere implementation

6.8 Switching gears for a while

Chapter 7: Optical Computation

7.1 Overview

7.2 class Optics

7.2.1 Matte color

7.2.2 Gloss color

7.2.3 Avoiding amplification

7.2.4 Opacity

7.2.5 Splitting the light's energy

7.2.6 Surface optics for a solid

7.3 Implementation of CalculateLighting

7.3.1 Recursion limits

7.3.2 Ambiguous intersections

7.3.3 Debugging support

7.3.4 Source code listing

Chapter 8: Matte Reflection

8.1 Source code listing

8.2 Clear lines of sight

8.3 Brightness of incident light

8.4 Using CalculateMatte's return value

Chapter 9: Refraction

9.1 Why refraction before reflection?

9.2 Understanding the physics of refraction

9.3 Snell's Law adapted for vectors

9.3.1 Introduction to Snell's Law

9.3.2 Refractive reflection

9.3.3 Special case: total internal reflection

9.3.4 Setting up the vector equations for refraction

9.3.5 Folding the three equations into one

9.3.6 Dealing with the double cone

9.3.7 Constraining F to the correct plane

9.3.8 Reducing to a scalar equation in k

9.3.9 Picking the correct solution for k and F

9.4 Calculating refractive reflection

9.5 Ambient refractive index

9.6 Determining a point's refractive index

9.7 CalculateRefraction source code

Chapter 10: Mirror Reflection

10.1 The physics of mirror reflection

10.2 Two kinds of reflection, same vectors

10.3 Deriving the vector formula

10.4 Recursive call to CalculateLighting

10.5 CalculateReflection source code

Chapter 11: Reorientable Solid Objects

11.1 The challenge of rotation

11.2 The SolidObject_Reorientable class

11.3 Implementing a rotation framework

11.4 Complex numbers help rotate vectors

11.5 Rotation matrices

11.6 Translating between camera coordinates and object coordinates

11.7 Simple example: the Cuboid class

11.8 Another reorientable solid: the Cylinder class

11.9 Surface normal vector for a point on the tube surface

Chapter 12: The TriangleMesh class

12.1 Making things out of triangles

12.2 Intersection of a ray and a triangle's plane

12.3 Determining whether a point is inside the triangle

12.4 The surface normal vector of a triangle

12.5 An ambiguity: which perpendicular is correct?

12.6 Example: using TriangleMesh to draw an icosahedron

12.7 Using TriangleMesh for polygons other than triangles

Chapter 13: The Torus class

13.1 Mathematics of the torus

13.2 Intersection of a ray and a torus

13.3 Solving the quartic intersection equation

13.4 Surface normal vector for a point on a torus

Chapter 14: Set Operations

14.1 A simpler way to code certain shapes

14.2 SetUnion

14.3 SetIntersection

14.4 The SolidObject::Contains member function

14.5 SetComplement

14.6 SetDifference

14.7 Combining set operations in interesting ways

14.8 A set operator example: concrete block

Recent books (Computer Graphics, OpenGL, OpenGL ES and WebGL)

I am listing recent books (published in 2012/2013) on Computer Graphics/OpenGL/OpenGL ES and WebGL.

Computer Graphics
Computer Graphics-Principles and Practice 3rd Edition Code
Fundementals of Computer Graphics 3rd Edition
Foundations of 3D Computer Graphics Code 

OpenGL
OpenGL Superbible 6th Edition Code
OpenGL Programming Guide 8th Edition v 4.3  Code
OpenGL Development Cookbook Code
OpenGL Insights Code
OpenGL 4.0 Shading Language Cookbook Code 

OpenGL ES 
Learn OpenGL ES: For Mobile Game and Graphics Development Covers OpenGL ES 3
OpenGL ES 2 for Android: A Quick Start Guide   Code
Learning OpenGL ES for iOS: A Hands-on Guide to Modern 3D Graphics Programming 
Pro OpenGL ES for Android

WebGL
WebGL Programming Guide  Code  
WebGL Beginners Guide Code
WebGL Up and Running Code 
Professional WebGL Programming: Developing 3D Graphics for the Web Code

Mitsuba Renderer: Loading PLY model files

In this tutorial, we will look at how to load the PLY dataset. Such datasets are quite common in graphics research and most rendering papers present their outputs for these datasets. These can be downloaded from the Stanford 3D scanning repository. I will assume that you have the required dragon.ply dataset downloaded and placed in the same location where your scene XML is.

Loading a PLY dataset is as simple as adding the following scene element.

< shape type="ply" >
   < string name="filename" value="dragon.ply"/ >
   < bsdf type="roughdielectric" >
      < ! -- Tweak the roughness parameter of the material -- >
      < float name="alpha" value="0.01" / >
    < / bsdf >
< / shape >

As can be seen it is very simple. Just change the shape's type to ply and then add the shape's bsdf. Here we have chosen a rough dielectric material to give the dragon a glass appearance. You can change the roughness value which controls how clear the glass is.

I rendered the glass dragon using path tracing, photon mapping, path space MLT (PSMLT), primary sample space MLT (PSSMLT) and energy redistribution path tracing (ERPT). The results are as follows

Path tracing

Energy redistribution path tracing (ERPT) 

Primary sample space MLT (PSSMLT)

Path space MLT (PSMLT)

Photon mapping

As in earlier tutorial, the full scene file may be downloaded from here: https://www.dropbox.com/s/h93wuwmbhkz8ozd/loadPly.xml

Mitsuba Renderer: Rendering spheres with plastic material and different integrators

In the last tutorial, we looked at a fairly stardard Lambartian/Diffuse material. We will now look at another material type which has specular highlights. This material type is called plastic in Mitsuba. We will render a large checkered plane with three spheres having red, green and blue plastic material so lets get started.

We define our sphere shape as in the first tutorial however the only difference is in the bsdf which has a different color for each sphere. The three spheres are defined as follows:

< !-- Setup blue sphere -- >
< shape type="sphere" >
  < float name="radius" value="0.1"/ >
  < transform name="toWorld" >
    < translate x="0.0" y="0" z="0.0"/ >
  < / transform >
  < bsdf type="plastic" >
    < srgb name="diffuseReflectance" value="#0000ff"/ >
      < float name="intIOR" value="1.9"/ >
  < / bsdf >
< / shape >

< !-- Setup green sphere -- >  
< shape type="sphere" >
  < float name="radius" value="0.1"/ >
  < transform name="toWorld" >
    < translate x="-0.2" y="0" z="0"/ >
  < / transform >
  < bsdf type="plastic" >
    < srgb name="diffuseReflectance" value="#00ff00"/ >
    < float name="intIOR" value="1.9"/ >
  < / bsdf >
< / shape >

< !-- Setup red sphere -- >
< shape type="sphere" >
  < float name="radius" value="0.1"/ >
  < transform name="toWorld" >
    < translate x="0.2" y="0" z="0"/ >
  < / transform >
  < bsdf type="plastic" >
    < srgb name="diffuseReflectance" value="#ff0000"/ >
    < float name="intIOR" value="1.9"/ >
  < / bsdf >
< / shape >

Lets look at one of the sphere's brdf properties in detail. The type for the bsdf in this case is plastic. The diffuseReflectance is the color of the material. If you look at Mitsuba documentation, this property is defined as a spectrum type. There are many ways to define a spectrum. We define it here as a hexadecimal srgb value. We could also define colors in rgb space (for e.g. blue with value="0.0,0.0,1.0") which would give the same output. The last parameter is the interior index of refraction. The rest of the scene elements are the same as in the previous checkered plane tutorial.

One neat feature of the Mistuba front end mtsgui is that it allows us to change the integrator type in real-time using the render settings options (the gear icon in the GUI) as shown below.

Render settings in mtsgui

There are 14 integrators to choose from. I have rendered current scene in all of the available integrators and the output results and timings are written for each integrator in the image caption. Note that these timings were calculated on my laptop with an AMD Radeon (TM) HD 6630M GPU hardware and these will likely differ on your machine. For some of the integrators like adjoint path tracer, path space MLT, progressive photon mapping and stochastic photon mapping, the scene could not converge. Here are all of the rendering for reference.

Adjoint path tracer [3.5970 secs @ 640x480]

Bidirectional path tracing [22.8360 secs @ 640x480]

Ambient occlusion [2.2860 secs @ 640x480]

Energy redistribution path tracing [1.5050 m @ 640x480]

Direct illumination [4.5020 secs @ 640x480]

Path space MLT [N/A @ 640x480]

Path tracing [5.6050 secs @ 640x480]

Photon mapping [1.1671 m @ 640x480]

Primary space MLT [37.7090 secs @ 640x480]

Progressive photon mapping [>6.1809 m @ 640x480]

Stochastic progressive photon mapping [>1.1635 m @ 640x480]

Volume path tracing (simple) [5.2190 secs @ 640x480]

Volume path tracing (extended) [5.9080 secs @ 640x480]

Virtual point light [0.598 secs @ 640x480]

The full scene XML file may be downloaded from here: https://www.dropbox.com/s/d7z5rpc5sgwmcpe/checkeredPlaneRGB_spheres.xml 

You should play around with different render settings and integrators to see their effect on the rendering output. 

Mitsuba Renderer: A more complete example

In the last tutorial, we had looked at a very simple example usage of Mitsuba with only a single sphere primitive. We will now look at a more complete scene with the description of other entities like film, intgrator, bsdf etc. So lets get started.

In this scene, we will render a plane primitive with a checkered material. We will introduce the following new scene elements.

1. integrator (for the rendering algorithm used)
2. sensor (for the camera settings like fov) 
3. film: a sub-entity of the sensor element (for the output image resolution and type) 
4. sampler: a sub-entity of the sensor element (for the number of camera samples and the type of sampling distribution to be used.
5. plane (for rendering of our plane shape)
6. bsdf: a child entity of our plane shape (for the checkered material)

Integrator:

This element tells Mitsuba the type of rendering algorithm to be used for the scene. For the first few tutorials, we will stick with the path tracing algorithm (type="path") for the integrator element. For this scene, the integrator element is defined as follows:

  < !--Setup scene integrator -- >

  < integrator type="path" >

    < !-- Path trace with a max. path length of 5 -- >

    < integer name="maxDepth" value="5"/ >

  < / integrator >

Sensor:

This element is analogous to a camera object. For this scene, we will use a perspective camera (type="perspective"). Its sub-elements transform controls the camera's position and orientation, the focusDistance element controls the distance of the camera focal plane. The fov element controls the camera field of view.

Film:

This is the sub-element of the sensor element. Its main attribute type controls the format of the output (ldrfilm or hdrfilm). If hdrfilm type is used, the output format is EXR. The sub-elements width and height control the output image dimensions.

For this scene, the sensor element is defined as follows:

  < sensor type="perspective" >

    < transform name="toWorld" >

      < translate x="0" y="0" z="-1"/ >

    < / transform >

    < float name="focusDistance" value="1"/ >

    < float name="fov" value="45"/ >

    < film type="hdrfilm" >

      < integer name="width" value="640"/ >

      < integer name="height" value="480"/ >

    < / film >

    < sampler type="independent" >

      < integer name="sampleCount" value="32"/ >

    < / sampler >

  < / sensor >

Plane:

The plane shape is defined by the type ("rectangle"). The position, orientation and scale of plane is controlled through the transform sub-element. To orient the plane properly, we rotate then scale and finally translate it. The material is controlled by the bsdf sub-element. Here we have defined a diffuse material. The bsdf element has a texture sub-element which has a uv scale of 32 (that is the texture tiling amount), color0 and color1 are the two checker colors and filtertype controls the texture filtering scheme to be used. This can be 

1. EWA (for EWA filtering which is the default filter type) 
2. trilinear (for linear filtering)
3. nearest (for nearest neighbor filtering)

For this scene, the shape element is defined as follows:

 < shape type="rectangle" >     

    < transform name="toWorld" >

      < rotate x="1" angle="-90"/ >

      < scale x="2" y="2" z="2"/ >

      < translate y="-0.1"/ >

    < / transform >

     

    < bsdf type="diffuse" >

      < texture type="checkerboard" name="reflectance" >

        < float name="uvscale" value="32"/ >

        < rgb name="color0" value="0,0,0"/ >

        < rgb name="color1" value="1,1,1"/ >

        < string name="filterType" value="EWA"/ >

      < / texture >

    < / bsdf >

  < / shape >

The entire scene description given above gives us the following output.

Output from the CheckeredPlane.xml scene

The scene file may be downloaded from here: https://www.dropbox.com/s/dtz7y9svuov7gxk/CheckeredPlane.xml 

Getting started with the Mitsuba Renderer

Mitsuba Renderer: An unbiased physically based  renderer written by Wenzel Jakobs who is a PhD student at Cornell. It is inspired and takes a lot of its design from the PBRT renderer of Matt Pharr. More details about this amazing renderer can be obtained from http://www.mitsuba-renderer.org/ I highly recommend this renderer to any student/researcher who is working on physically based rendering.

While the Mitsuba documentation is very well written, it lacks basic tutorials that teach the  user how the whole system works and this blog post will try to address these issues so lets get started.

If you have not done so then please download the latest binaries from the above mentioned website. As of this writing, the current version is 0.4.4. Extract the zip file to the root directory. In the binary package, there are a bunch of dlls (boost, OpenEXR, and others) and then there are a bunch of executables including the two main executables: mitsuba.exe (the main renderer) and the mtsgui (the Qt based GUI front end for the renderer). The mtsgui is the tool we will look at in this tutorial. This tool reads an XML based scene description written in any XML editor, parses it and renders the scene. When you run mtsgui, you get this window

The mtsgui window (The graphical front end to Mitsuba) 

Hello World Mitsuba

Go ahead and create a new XML document in your favorite editor. I usually prefer MS Visual Studio as it provides a lot of neat tools. Add the following contents to it.

< ? xml version="1.0" encoding="utf-8"? >

< scene version="0.4.4" >

  < shape type="sphere" >

    < float name="radius" value="1"/ >

  < /shape >

< /scene >

This is a very simple scene that displays a simple unit sphere on screen. All other settings like camera position, fov, sphere's material, environment map are assigned their default values. Go ahead and save the XML as sphere.xml in a suitable place. Go to mtsgui and open this scene. When you open this scene, you will see that your sphere will occupy the entire rendering window as shown below.

The sphere.xml scene rendered in mtsgui

This is the preview render of our scene. We can use the left mouse button to rotate the camera and use the up/down arrow keys to zoom in/out etc. Single left mouse click on our sphere selects it while double clicking on it zooms out the camera to properly display the sphere (similar to zoom extents of 3DSMax). Go ahead and double click on the sphere. This will give us the following output in mtsgui window.

Sphere after double clicking in mtsgui window

Now press the play button which will render our scene using path tracing as shown below.

Our sphere object path traced

This is a simple getting  started tutorial for Mitsuba. For more details about the mtsgui interface options, go through this video by Wenzel Jakob http://vimeo.com/13480342. I will follow up with more tutorials as and when time permits. You can download the final sphere.xml from here https://www.dropbox.com/s/i0gv68zw9211yo4/sphere.xml

Happy path tracing.