Both hardware and software implementations of pyramid-based systems used for computer vision applications are described. The pyramid architecture is a common model for the processing that is done in computer vision and has parallels in the human visual system. A number of different multilevel representations, such as wavelets and different kinds of pyramids, are used in image analysis. Many computer vision systems are described in terms of hierarchical processing even though all the implementation is on a single processor. The standard computer vision paradigm is a hierarchy composed of low-level processing (image processing or preprocessing), intermediate-level processing (or feature extraction), and high-level processing (or recognition).
After this introduction to the basics of computer vision and hierarchical architectures, the book describes how different hierarchical architectures are implemented. In the introduction and in later chapters, the authors note that true pyramid systems have only reached the hardware prototype stage, with most systems either in software or superimposed on other parallel architectures.
The fourth chapter introduces a taxonomy of hierarchical machines. This taxonomy is hierarchical; it first divides machines into either homogeneous or heterogeneous according to the processing modules. The second level of division is based on the coupling between the processing nodes (tight or loose; compact or distributed; and fixed or reconfigurable).
The next chapter introduces the two classes that are discussed in this book: compact and distributed (homogeneous) pyramids. They capture most of the proposed implementations. Most are tightly coupled with fixed configurations, though examples of others are described in later chapters.
The next three chapters discuss the implementation of pyramids on other real or prototype parallel systems. The first covers implementations on pipelined systems, which typically implement two levels of the pyramid. Next come simulations of pyramids on arrays of machines or hypercubes, especially the Connection Machine. Since there are several real implementations, this chapter can analyze the different ways to store the pyramid on the available processors. Finally, the eighth chapter discusses heterogeneous hierarchical systems, where the different levels are composed of different types of machines. These systems are motivated by the basic paradigm of computer vision processing (low, middle, or high level) and by the differences in the processing at different levels of the human visual system. In these three chapters, the implementations and designs are evaluated on the basis of the load on the processors and on the communication links.
While the speed available from parallel implementations is necessary for real-time applications, the programming language and operating system may be as important for research and development of algorithms. The ninth chapter discusses the difficulties developing programs for these machines. The programming environments range from assembly language to parallelized versions of FORTRAN, C, or LISP. This chapter presents the general issues in parallel languages that are critical for computer vision algorithms, and illustrates how different systems have addressed the problem. The final chapter discusses the effectiveness of pyramid architectures for computer vision applications.
This book describes general parallel systems and places existing implementations in some context, and thus could serve as a text on parallel implementations for computer vision. Details on individual systems are omitted when not relevant for the analysis here but are available in other books and papers. Each chapter has an extensive bibliography, but a single alphabetical listing of the papers would make the book more useful as a general reference. Given that the authors are from Italy, the problems with English in the book are minor.
This book was written when the development of massively parallel machines was at its peak, with many proposed machines. Some had reached the prototype stage and a few were even commercial products. Since that time, many prototype projects have ended and Thinking Machines (the maker of the Connection Machine) has filed for bankruptcy. While the authors do not address the commercial failure of these kinds of systems, they do give some hints in their mention of development time for hardware, the available languages and operating systems, and the cost of actual implementation. Since the book discusses pyramid-based architectures from both the actual hardware implementation side and the algorithm development side, it can be useful for researchers even if few actual pyramid systems are available to researchers.
