Preface

This book is about design, programming and geometry, or, better, about design programming using geometry. These three worlds meet and communicate with each other using computer graphics. Therefore, this book is also about computer graphics, but its first aim is to discuss a functional approach to geometric programming that supports the rapid prototyping of design applications.

It is our experience that some great people (at Spatial, Dassault, Autodesk, EDS, PTS, etc.) have spent a lot of time and effort programming great geometric tools so that the rest of us may make better designs. The results of their work are the powerful computer-aided design systems that some readers may have on their desk. But such systems, even when they offer an application programming interface, hide the power and the beauty of geometric methods behind the scenes. My opinion is that we need to gain full control of what we do when we develop new design methods or applications, not least for æstetic reasons.

In particular, to teach (and learn) computer-aided design and graphics methods using a standard programming approach, say one based on imperative languages and on some kernel APIs, may be quite difficult. To explain, and display, how to stack three cubes of varying dimensions requires a substantial programming effort, that might be measured in several lines of code. Even worse, the majority of such a code may have nothing to do with the problem, but with the computational framework, the user interface, the display method, and so on. My hope, about 12 years ago, was to devise some symbolic design approach, where an assembly made by three parametrized cubes could be defined by writing one line of code.

About one decade ago, after having taught computer graphics and geometric modeling for several years, I learned some functional programming and discovered the Backus' FL language and its algebra of programs. I suddenly realized that an algebraic calculus oriented to geometric expressions could be established upon this language. We only needed to add to FL some specialized data structure to represent geometric objects and their properties and some fundamental geometric algorithms.

PLaSM is the result of this addition. It provides a specialized design environment where complex geometric objects and methods may be defined, abstracted, parametrized and combined by writing one or, more rarely, a few lines of code, thus giving a very powerful and terse geometric calculus under direct user control. The author's hope is that this language may became useful for geometric design applications, as Mathematica or MathLab are for symbolic or numeric applications, by offering the user a programming environment where geometric objects and methods may be prototyped and visualized with the minimal development effort.

This book is also the product of 25 years of teaching practice in computer graphics and geometric modeling with engineering students at various curricula levels, giving courses that in the past six years have been successfully based on PLaSM examples and implementations. I hope the book will help the reader to learn that programming with geometry, and the development of customized computer-aided design tools, may be very easy and fast, and great fun.

Book roadmap

This book contains three parts, dedicated to: (a) providing an introduction to functional programming with PLaSM and covering the mathematical background needed to work with geometric applications; (b) teaching some basic techniques of graphics programming; and (c) discussing some basic and advanced geometric modeling, including motion modeling and animation. A useful appendix is dedicated to documenting both the built-in operators of the language and the libraries that can be loaded at run time in its computational environment.

Each of the three parts is relatively self-contained, provided that a working introduction to the language is obtained by reading some sections of Chapter 1. One part can therefore be used to teach one semester courses in functional programming and geometry, in basic graphics programming and in geometric modeling, respectively. An advanced graphics course could also add the motion modeling chapter. Conversely, a geometric modeling course could find useful additions from materials located in Chapters 6 and 8, which are more dedicated to affine transformations and to hierarchical assemblies, respectively.

The more advanced sections can be skipped both by those on a beginner's or undergraduate course. They may possibly integrate the teaching materials for courses at graduate level.

To gain a deep understanding of graphics and modeling issues is not easy, because it requires being able to know, appreciate and combine several topics from different areas of mathematics, engineering, computer science and arts. In writing this book, we made an attempt to show some of these connections. As a consequence we had to collect quite different materials that do not necessarily require to be read by the casual user of the book. Conversely, we hope that some book sections are likely to be appreciated by different audiences, and in particular by people with a background in mathematics or mechanical engineering or architecture.

Finally, we would like to remark that, since the book presents the reader with methodological issues, the central role that we assigned to PLaSM should be considered the assessment of an interpreted RAD (rapid application development) environment for graphics, modeling and animation, that allows both the teacher and the student to generate examples and prototypes with the minimal programming effort and using free software. When a PLaSM prototype is ready, it is usually a fast and error-free task to deploy an efficient version of a design application making use of the best libraries and geometric kernels available.

The more recent versions of the opensource and multiplatform PLaSM environment are available at the web site www.plasm.net, where several programming and teaching resources are also available, including most examples and pictures given in the following chapters, and up-to-date software sources, binaries and documentation.

Acknowledgements

My first acknowledgement is for Gianfranco Carrara, who, several years ago, proposed I create a language for architectural design, and suggested I read Ferdinand de Saussure and Noam Chomsky, as well as the design theorists of seventies, the Negroponte's Architecture Machine [Neg70] and the Mitchell's Computer Aided Architectural Design [Mit77]. The present book describes the result of two and half decades of research following his initial suggestion.

Then, my most grateful thanks go to the memory of Antonio Ruberti, who gave me a position in the Computer Science Department at "La Sapienza" University in

Rome, and as the Italian Ministry of Research (later the European Commissary for Research) liked the PLaSM project and helped to get it funded. Without his insight, this language and this book would not exist.

Great thanks to John E. Hopcroft, who invited me to visit his Robotics Group at Cornell University during my sabbatical in 1986. He posed some challenging problems and offered me the opportunity to learn doing research in a highly competitive academic environment. My first work with simplicial geometric complexes is dated to the last weeks of my stay at Cornell.

The PLaSM project started in 1990, funded by a pluriannual grant from the "PF Edilizia" Project of Italian National Research Council. At about the same time, I encountered the algebraic approach to functional programming carried out by the Backus' and Williams' Functional Programming Group at IBM Almaden. Their FL language, with its unique compositional semantics, strongly inspired the PLaSM design. I never met John Backus, although I visited his group at Almaden, but I hope that he would appreciate the demonstration of the FL expressive power given by PLaSM.

To acknowledge all people that contributed to this project is quite impossible. Important contributions came from Carlo Cattani, Vincenzo Ferrucci and Fausto Bernardini, who contributed to the seminal work on multidimensional geometric computing with simplicial complexes; later Claudio Sansoni collaborated with the initial language design; Valerio Pascucci, Michele Vicentino and Giuseppe Proietti developed the first PLaSM interpreter and kernel based on hierarchical polyhedral complexes of convex cells; Claudio Baldazzi contributed the implementation of Boolean operations with multidimensional BSP trees. More recently, Simone Portuesi, Giorgio Scorzelli, Stefano Francesi and Glauco Cenciotti have developed the current interpreter and geometric kernel written respectively in Scheme and C++; Franco Milicchio has developed the specialized editor XPLODE. Giorgio Marzano is using the language for knowledge representation and interaction with a reasoning engine. Several students gave us useful feedback by developing PLaSM-based projects and applications. Also, I am grateful to the many hundreds of students which experimented with the various versions of the language, and pained over preliminary teaching materials and drafts of some chapters of this book.

I'm also most grateful to the friends and collegues that gave encouragement, advice and comments during the long development of this book. In particular, I...