The object on the left in the above video is a textured and shaded object with a small amount of specular reflection (lit using the Debvec Funston Beach at Sunset light probe). On the right, I’m illustrating the dominant orientations in the image, across the surface of the object.

Click through for some more visualizations.

The above video illustrates the vector field’s dominant orientations as well as the kurtosis/”peakedness” of the orientated filter response distributions (reflected in the size of the vectors).

Using line integral convolution, we get a better visualization of the global structure of the orientation field. Note that the above LIC images were computed in MATLAB using the Matlab Vector Field Visualization toolkit.

The LIC images in the video above were computed in Mathematica and colored as a function of the orientation field’s dominant orientation.

Finally, a video illustrating all the aforementioned visualization techniques simultaneously.

I created a series of HDR cube maps using NVIDIA’s CubeMapGen (currently hosted on Google Code). Starting with the Debevec light probes, I applied a Gaussian blur with increasing kernel size (10°, 20°, 30°, 40°, and 50°), creating 6 cube maps (one for each blur). In the videos, the cube maps have increasing blur from left-to-right, top-to-bottom. Note that I did not tone-map or account for changes in overall exposure (so the specular reflections can appear blown-out, especially for the higher blurs). After the break, you can see the effect using different light probes (and different shapes).

After the break, see how increasing the size of the convolution kernel affects the quality of the 3D noise.

Note that “Time to Process” was calculated tic and toc (see above) on a quad-core Xeon W3530 @ 2.80GHz with 12 GB of RAM. In addition, the 2D FFT animations were generated using each frame of the GIF animations using the following code:

k		Time to Process	2D FFT
1		0.4167
3		0.8670
5		2.2663
7		5.7784
9		11.2293
11		20.8108
13		33.3277
15		52.0085
17		82.3220
19		187.6235
21		397.4730
23		615.1934
25		852.5891
27		1190.7
29		1641.1
31		1822.3

Subjectively, there is diminishing return as the convolution kernel increases past 13-15 pixels. Objectively, it makes little sense to spend the computational time processing past 15:

Here is a MAT file with these 3D noise arrays:
noise3Dwrap64_k1_31.mat

Continue after the break to see how this 3D noise was generated.

The noise was generated using a (relatively) simple function:

This is similar to the code that I posted yesterday for 2D and 3D Perlin Noise in MATLAB; however, it basically creates a matrix that is a cube of 9 identical noise fields (i.e., a 3x3x3 cube of mxmxm cubes) and only extracts the central cube when returning the texture. Simple, but it creates seamless wrapping “Perlin-esque” noise fields that look pretty darn good as 3D textures for my stimuli. Since they can take a long time to generate, here’s some pre-generated matrices:

256x256x256 pixels with a 23 pixel convolution kernel. The MAT file contains 2 matrices that were independently generated, “noiseStandard” and “noiseComparison”. (MAT file)

192x192x192 pixels with a 23 pixel convolution kernel. The MAT file contains 2 matrices that were independently generated, “noiseStandard” and “noiseComparison”. (MAT file)

128x128x128 pixels with a 23 pixel convolution kernel. The MAT file contains 2 matrices that were independently generated, “noiseStandard” and “noiseComparison”. (MAT file)

64x64x64 pixels with a 23 pixel convolution kernel. The MAT file contains 2 matrices that were independently generated, “noiseStandard” and “noiseComparison”. (MAT file)

And just for the heck of it, here’s the MATLAB code I used to generate the AVIs and GIFs from the matrices (messy and uncommented but it worked):

In my search for some MATLAB code, I found a page that had the following GNU Octave 2D Perlin noise generation code:

Since GNU Octave is so similar to MATLAB, it was very simple to translate:

I added the following code to normalize the output (making all values range from 0 to 1):

This code can create some nice 2D Perlin noise images, such as:

32 x 32
64 x 64
128 x 128
256 x 256

And since interp3 (and interpn) are higher-dimensional interpolation functions available in MATLAB, it was simple to create a 3D perlin noise function:

The earlier code creates 3D Perlin textures, such as: (please note that these are animated by slicing the texture in depth)

32 x 32
64 x 64

However interp3 is VERY memory intensive. Here are example MATLAB profiler outputs illustrating the peak memory used by MATLAB (note that I used the undocumented MATLAB profiler memory option “profile -memory on;”, described here):

32 x 32
64 x 64

Replacing interp3 with smooth3, I was able to reduce the memory requirements a bit:

As I mentioned, smooth3 then reduces the memory requirements:

32 x 32
64 x 64
128 x 128
256 x 256

And produces (subjectively) similar Perlin-style noise, but with lower contrast. We can increase the contrast by simply scaling the values using a simple cosine transform:

Producing:

32 x 32
64 x 64

The contrast still isn’t as good as the “true” Perlin noise, so I’ll try to see how simplex noise is implemented..