Visual computing is all about geometry and image. It combines important aspects of computational geometry, computer graphics, and computer vision, but other research fields could also be included, such as image processing, visualization, medical imaging, virtual reality, geometric modeling, and multimedia.

Several books published in the last decade have tried to establish bridges between these geometry and image areas [1,2,3,4,5]. However, this book goes a step further toward an interdisciplinary approach to visual computing by providing a general framework for handling common problems in computer graphics, computer vision, and geometric computing. As stated in the first chapter, this interdisciplinary approach to visual computing is the primary purpose of the book.

The second chapter illustrates how implementation-independent, abstract data structures can be reused to solve computer vision, computer graphics, or computational geometry problems. It also shows how these abstract data types can be implemented in C++, in particular using the standard template library (STL) and traits. Traits are particularly illuminating here, because they reinforce abstraction by unifying constants, types, and predicates.

The third chapter describes the various coordinate systems and pipelines found in geometry, graphics, and vision, as well as their interrelations. The geometry pipeline transforms a geometric object into another geometric object, the graphics pipeline transforms a geometric object into an image, and the vision pipeline allows us to reconstruct a geometric object from two or more images. Each pipeline can be viewed as a product of matrices, each matrix concerning a particular transformation. The only weakness of this chapter is that it lacks a brief description of the mathematical theory behind these pipelines. Mathematically speaking, each pipeline is a group of transformations; for example the isometries of the Euclidean geometry form a group, the affinities of the affine geometry form a group, and the projectivities of the projective geometry also form a group. It would also be interesting to show that the projective geometry is a generalization of the affine geometry, which, in turn, generalizes the Euclidean geometry, and so on. Unfortunately, this unifying theoretical perspective is missing.

The fourth chapter focuses on image. As the author notes on page 199, “image is the ubiquitous medium in visual computing.” This chapter provides a nice interplay between image processing and computer graphics. Warping and morphing images are two applications of image processing in computer graphics. In particular, image-based rendering, which is a three-dimensional (3D) warping method, has received a lot of attention in the computer graphics community, because model-based rendering has significant “limitations in producing photo-realistic images of complex scenes.” This chapter also reviews color models and color quantization techniques when rendering images with low memory costs.

The fifth chapter is about meshes, the most popular geometric objects in computer graphics. Graphics hardware is optimized to render triangles, and the geometric objects of a scene are thus usually represented through triangular meshes. Meshes and respective data structures are therefore described, namely triangular meshes (including Delaunay triangulations), hexagonal tesselations, procedural meshes, progressive meshes, and multiresolution meshes. However, the encoding of the connectivity of meshes is only discussed in terms of the classical representations of the winged-edge, half-edge, and quad-edge. It is a little bit disappointing that the author has missed recent and challenging topological representations of geometric objects, in particular those introduced by the multiresolution meshes community. This chapter also introduces important aspects about mesh aesthetics, particularly isotropic and anisotropic remeshing.

The sixth chapter starts by defining animation as a “field that covers all aspects of acquiring, processing, representing, and storing dynamic data.” It presents a well-known kinetic data structure to keep geometric structures under motion. The author then describes relevant motion capture techniques, such as video tracking and matchmoving, to create realistic animations, and shows why they are important in the visual effects industry. Finally, there is a succinct survey of animation techniques commonly used in computer graphics: keyframing using interpolation or forward/inverse kinematics, physics-based animation, and particle systems.

The seventh chapter covers several aspects of randomization: randomized analysis of sorting algorithms (for example quicksort), randomization of sampling sequences (for example, image pattern matching using random sample consensus (RANSAC), and light scattering simulation through Monte Carlo samplings), randomized data structures (for example skip lists), and randomized optimization algorithms (for example, randomized incremental construction of the Delaunay triangulation of a planar point set, and randomized incremental collision-detection algorithms).

The eighth chapter is written with the mindset that it is sometimes better to use algorithms in higher dimensions to process 3D data efficiently, especially those handling multidimensional nearest neighbor queries in computational geometry and computer graphics (for example, image analogies, texture synthesis, and geometry synthesis). These algorithms normally use generic multidimensional search trees, called kD-trees. They generalize bintrees, quadtrees, and octrees to higher dimensions. A weakness of this chapter is that the author does not show how C++ classes and traits (see second chapter) could ease the design, implementation, and maintenance of dimension-independent data structures and algorithms.

The book closes with a chapter on robustness. This is possibly the weakest chapter of the book, but even so it helps us to identify code weaknesses and follow software design principles, to guarantee the numerical stability and robustness of programs in visual computing. For that, the essence of the IEEE 754 Binary Floating-Point Standard is presented and discussed, and well-known multiple precision arithmetic libraries are listed and overviewed: the GNU Multiple Precision Arithmetic Library (GMP), Library of Efficient Data Types and Algorithms (LEDA), Computational Geometry Algorithms Library (CGAL), and CORE.

In summary, the contribution of this book lies precisely in the way the author has found a common, but not complete, ground for computational geometry, graphics, and imaging with respect to mathematical theories, spatial data structures, algorithms, and arithmetic robustness. The result is an exciting textbook suited for graduate students who intend to understand the relations between disciplines concerning geometry and image. In addition to the book’s extensive bibliography, the bibliographical notes at the end of each chapter are particularly useful for those starting research in a specific field of visual computing.