②
Many image file formats don’t store floating-point color
values but instead use 8 bits for each color component, mapping the
values to the range . (For example, the TGA format that is supported
by ReadImage() is such a format.)
For images originally stored in this format,
the ImageTexture uses four times more memory than strictly necessary
by using floats in RGBSpectrum objects to store these colors.
Modify the image reading routines to directly return 8-bit values
when an image is read from
such a file.
Then modify the ImageTexture so that it keeps the data
for such textures in an 8-bit representation, and modify the
MIPMap so that it can filter data stored in this format. How much
memory is saved for image texture-heavy scenes? How is pbrt’s performance
affected? Can you explain the causes of any performance differences?
② For scenes with many image textures where reading them
all into memory simultaneously has a prohibitive memory cost, an effective
approach can be to allocate a fixed amount of memory for image maps (a
texture cache), load textures into that memory on demand, and
discard the image maps that haven’t been accessed recently when the memory
fills up (Peachey 1990). To enable good performance with small texture
caches, image maps should be stored in a tiled format that makes it
possible to load in small square regions of the texture independently of
each other. Tiling techniques like these are used in graphics hardware to
improve the performance of their texture memory caches (Hakura and Gupta 1997;
Igehy et al. 1998, 1999).
Implement a texture cache in pbrt.
Write a conversion program that converts images in other formats to a tiled
format. (You may want to investigate OpenEXR’s tiled image support.) How
small can you make the texture cache and still see good performance?
② Read the papers by Manson and Schaefer (2013, 2014) on
approximating high-quality filters with MIP maps and a small number of
bilinear samples. Add an option to use their method for texture filtering
in place of the EWA implementation currently in pbrt. Compare image
quality for a number of scenes that use textures. How does running time
compare? You may also find it useful to use a profiler to compare the
amount of time running texture filtering code for each of the two
approaches.
② Improve the filtering algorithm used for resampling image
maps to initialize the MIP map levels using the Lanczos filter instead of
the box filter. How do the sphere test images in the file
scenes/sphere-ewa-vs-trilerp.pbrt and
Figure 10.10 change after your improvements?
② It is possible to use MIP mapping with textures that have
non-power-of-two resolutions—the details are explained by Guthe and Heckbert (2005). Implementing this approach can save a substantial amount of
memory: in the worst case, the resampling that pbrt’s MIPMap
implementation performs can increase memory requirements by a factor of
four. (Consider a texture that is resampled to be .) Implement this approach in pbrt, and compare the amount of
memory used to store texture data for a variety of texture-heavy scenes.
② Some of the light transport algorithms in Chapters 14, 15, and 16
require a large number of samples to be taken per pixel for good results.
(Examples of such algorithms include path tracing as implemented by the
PathIntegrator.) If hundreds or thousands of samples are taken in
each pixel, then the computational expense of high-quality texture
filtering isn’t worthwhile; the high pixel sampling rate serves well to
antialias texture functions with high frequencies. Modify the
MIPMap implementation so that it optionally just returns a
bilinearly interpolated value from the finest level of the pyramid, even if
a filter footprint is provided. Compare rendering time and image quality
with this approach when rendering an image using many samples per pixel and
a scene that has image maps that would otherwise exhibit aliasing at
lower pixel sampling rates.
② An additional advantage of properly antialiased image map
lookups is that they improve cache performance. Consider, for example, the
situation of undersampling a high-resolution image map: nearby samples on
the screen will access widely separated parts of the image map, such that
there is low probability that texels fetched from main memory for one
texture lookup will already be in the cache for texture lookups at adjacent
pixel samples. Modify pbrt so that it always does image texture lookups
from the finest level of the MIPMap, being careful to ensure that
the same number of texels are still being accessed. How does performance
change? What do cache-profiling tools report about the overall change in
effectiveness of the CPU cache?
② Read Worley’s paper that describes a new noise function with
substantially different visual characteristics than Perlin
noise (Worley 1996). Implement this cellular noise function, and add
Textures to pbrt that are based on it.
② Implement one of the improved noise functions, such as
the ones introduced by Cook and DeRose (2005), Goldberg et al. (2008), or
Lagae et al. (2009). Compare image quality and rendering time for scenes
that make substantial use of noise functions to the current implementation
in pbrt.
② The implementation of the DotsTexture texture in this chapter
does not make any effort to avoid aliasing in the results that it
computes. Modify this texture to do some form of antialiasing. The
Checkerboard2DTexture offers a guide as to how this might be done,
although this case is more complicated, both because the polka dots are not
present in every grid cell and because they are irregularly positioned.
At the two extremes of a filter region that is within a single cell and a
filter region that spans a large number of cells, the task is easier. If
the filter is entirely within a single cell and is entirely inside or
outside the polka dot in that cell (if present), then it is only necessary
to evaluate one of the two subtextures as appropriate. If the filter is
within a single cell but overlaps both the dot and the base texture, then
it is possible to compute how much of the filter area is inside the dot and
how much is outside and blend between the two. At the other extreme, if
the filter area is extremely large, it is possible to blend between the two
textures according to the overall average of how much area is covered by
dots and how much is not. (Note that this approach potentially makes the
same error as was made in the checkerboard, where the subtextures aren’t
aware that part of their area is occluded by another texture. Ignore this
issue for this exercise.)
Implement these approaches and then consider the intermediate cases, where
the filter region spans a small number of cells. What approaches work well
for antialiasing in this case?
② Write a general-purpose Texture that stores a
reference to another texture and supersamples that texture when the
evaluation method is called, thus making it possible to apply supersampling
to any Texture. Use your implementation to compare the effectiveness
and quality of the built-in antialiasing done by various procedural
textures. Also compare the run-time efficiency of texture supersampling
versus increased pixel sampling.
③ Modify pbrt to support a shading language to allow
user-written programs to compute texture values. Unless you’re also
interested in writing your own compiler, OSL (Gritz et al. 2010) is
a good choice.