Fixing the silly bugs…

January 10, 2014 - 2:53 pm by Joss Whittle C/C++ Graphics PhD

Here is a more converged render of the pool balls which I left running on my uni computer overnight. The image is 1024 x 1024 pixels and was rendered to 1250 samples over the course of around 4 hours.

There are also several notable changes that have been made to the renderer which show up in the new image. Firstly, the strange distortion of the texture on the sphere (visible on the ‘4’) has been fixed. This was due to an incorrect method of rotating the UV coordinates of the sphere around it’s centre. Previously this was accomplished by adding radians to the computed (phi, theta) coordinates. However, this was not a true rotation but rather a translation over the surface along the polar axis. So by attempting to lean the sphere backwards slightly I had really just shifted the texture slightly higher on the sphere.

The new method for rotating a sphere is defined below, it works by having a pair of ‘home’ vectors for the sphere. One pointing upwards towards the north pole, and the other point outwards at 90′ degrees towards the intersection of equator & the prime meridian.

// In the sphere constructor // ... where 'rot' is 4x4 Matrix // Apply the rotation matrix to the two 'home' vectors m_vn = rot % Vec3::Y; m_ve = rot % Vec3::Z; // ... // Get UV void getUV(Vec3 &normal, float &u, float &v) const { // Compute the angle (in radians), phi, between the // rotated home vector `vn` and the surface normal float phi = acosf( -(m_vn | normal) ); // The v coord is phi normalized by PI radians v = phi / PI; // Compute theta as the angle between the home vector `ve` // and the surface normal float theta = (acosf( (normal | m_ve) / sinf(phi) )) / TAU; // If the coord lies in the southern hemispher then flip theta if ((( m_vn ^ m_ve ) | normal) > 0.0f) { u = theta; } else { u = 1.0f - theta; } };

The second change is the addition of Bi-Linear Interpolation on texture sampling. In my rush to get a minimum renderer working to begin research I skipped adding this and opted for the simple Nearest Neighbor approach by simply casting my computed texture coordinates to int‘s. However, as I am now beginning to produce higher quality renders it became painfully apparent how important a good texture lookup can be to final quality.

Below is a quick comparison of the previous image (left) and the new image (right). Other than the obvious texture distortion as mentioned above, you can also see how jagged the edges are where the texture changes colour dramatically. In the right hand image, however, the effect of Bi-Linear interpolations can be seen a subtle blurring as the colours change.

Here, an even more dramatic comparison is shown where a 2 x 2 pixel texture has been wrapped around the spheres. On the right, the colour of the sphere jumps dramatically between the four pixels of the texture while the left rendering shows a smooth transition between colours.

Here is the code for Bi-Linear Interpolation based on a set of UV texture coordinates in the range 0 -> 1.

Pixel sampleBL(float u, float v) const { // Compute texture coords float x = (u * (float) (m_w)); float y = (v * (float) (m_h)); // Vars to hold interpolated values Pixel r0, r1; // Compute the bounding values for the coord int x0 = (int) floorf(x); int x1 = ((int) ceilf(x)) % m_w; int y0 = (int) floorf(y); int y1 = ((int) ceilf(y)) % m_h; // If x is whole if ((float) x0 == x) { // If y is whole too then just return the pixel if ((float) y0 == y) { return getPixel(x0, y0); } else { // No x interpolation needed, just interpolate along y r0 = getPixel(x0, y0); r1 = getPixel(x0, y1); return linearInterpolate(r0, r1, y0, y); } } // Values to hold edge pixels Pixel a, b; // Interpolate top edge a = getPixel(x0, y0); b = getPixel(x1, y0); r0 = linearInterpolate(a, b, x0, x); // If y is whole only one interpolation needed if ((float) y0 == y) { return r0; } // Interpolate bottom edge a = getPixel(x0, y1); b = getPixel(x1, y1); r1 = linearInterpolate(a, b, x0, x); // Interpolate between edges return linearInterpolate(r0, r1, y0, y); }; Pixel linearInterpolate(Pixel &a, Pixel &b, int x0, float x) const { float ratio = (x - (float)x0); // Will be some value between 0 -> 1 return (a * (1.0f - ratio)) + (b * ratio); // Sum the two pixels by the ratio };

Tags Global Illumination, Monte Carlo Integration, Path Tracing, Ray Tracing

The rantings of a lunatic Scientist

Program The rantings of a lunatic Scientist

Fixing the silly bugs…