Ray Tracing from the Ground Up

This is an amazing book. I'm not an expert but I'm using it with two purposes. One of them for theory to understand a few concepts. For example, Chapter 13 is a great theory chapter that talks about BRDF and the rending equation (among other things.) At the same time, my other objective is to use it for a more applied work. It has neat code and the way that he explains everything is perfectly clear.

I recommend this book for anyone who wants to understand ray tracing, that wants some theory or both. Also, if you already know, I'm sure you know by now, this is a must to have in your library. It has over 703 pages and over 30 chapters.

Finally, I have to say that the further readings points to great places to get more in depth. I want to clarify here something. This is not a book that has a little bit of everything. It's a very complete book, but in some chapters (e.g) , when more theory is needed, then further reading works great!.

A must.
Francisco

I wish Suffern included an appendix with complete files so that I wouldn't have to go to the internet to look at them. Additionally the coverage of some topics was very in depth, but for others, it seemed like it was barely a paragraph (BRDFs for example). 

My experience with this book is as a textbook for a class about ray tracing, and I don't think he gives you any kind of math library, but I could be mistaken. I didn't see one. His code and reasoning for the way he does things is easy to understand, except for one thing which bugged me. It's been a while, but I think he overloads the ^ operator when multiplying two vectors.

This is THE book for someone interested in writing a ray tracer. What I love about the book is how the author also mixes in some great resources to learn more about a particular topic, all relevant to computer graphics. This is one of my favorite books ever, wonderfully written. Well done.

I bought this book a few years ago. I also have the first edition of the PBRT book. They are both excellent and I recommend both. Personally, I prefer this book because it is easier for me to understand. I think this book is more code oriented vs PBRT being more math oriented. Buy both, but if you're more of a programmer than mathematician get this one first. If you're already beyond the basics, I think PBRT would be more appropriate for you.

This book covers most parts of ray tracing. Rarely unnecessary theories and math. Problem of this book is the intersection testing is based on geometries, not mesh; So it is impossible to implement it on complex model by just finishing this book. But the pseudo code is clear enough for generating an implementation.

This book is great. It has a lot of illustrations to help show you what your vector graphics should look like. I bought this for a class, and I plan on using it later on to refresh myself on various concepts.

Since Amazon has an excerpt of my review, here's the whole thing, from "The Ray Tracing News".

I recall when I was a kid in sixth grade I got my hands on some book that was essentially presenting all grade-school and high-school mathematics in just one text. I read through the first parts, feeling quite smart that I knew all this stuff already. I hit a little more algebra than I was used to, but was able to slog on. Then I hit logarithms and was stopped dead - what's this bizarre concept? The text whipped through it so quickly that I couldn't get my head around it, and so the book lost me entirely. Many books for courses are just that, texts for the classroom. They cover each topic just enough to get the point across to most students, and assume a teacher is around to fill in the gaps and help along any other students who didn't quite understand the book. A reasonable assumption, certainly, but of necessity it means the text will skim over areas in order to cover every major topic in a field and so appear "complete".

The book "Ray Tracing from the Ground Up", by Kevin Suffern, published by A.K. Peters, will be available at SIGGRAPH 2007. I've skimmed through most of the chapters (not as a paid editor, but rather just to comment), so can offer up an initial impression. This book has a perfect title for it. Theory and code snippets are blended to show how to make a classical or stochastic ray tracer from scratch. It assumes the reader has just about no knowledge of graphics and at most some understanding of calculus. Each chapter tackles some topic: perspective, reflection, intersection, etc. The text has many excellent figures and illustrative renderings, along with C++ code snippets that are explained when presented (vs. the often slap-dash nature of many code-laden books that present long, weakly commented listings that fill half the book). The book will come with a CD that includes a basic ray tracer, as well as code for generating various scenes (there's no scripting language front-end for the ray tracer).

Overall, the book is somewhat "old school". With the exception of a few newer topics, e.g. ambient occlusion, most of the material presented dates back to the 80's and early 90's. But this is as it should be for a text of this sort: fundamentals are established and built upon, with the author doing his best to make sure the reader truly understands what is going on each step of the way, (hopefully) without the need of a teacher to fill in the gaps. Through examples and extensive illustrations the author attempts to build not only a basic understanding but present mental models and give some intuition as to what various equations and algorithms represent. For example, I've never seen a clearer explanation of the ray/box (slabs) intersection method - it's done as it deserves to be done, walking through the various types of hits and misses and showing (through excellent colored figures and ray-traced test images) how the algorithm actually works. This is not a text for researchers or advanced students, but truly for the novice, the hobbyist, the enthusiastic amateur.

The style is informal and approachable, with the author normally speaking in the first person singular or plural, e.g. "I'll use the same representation for the BRDFs", "We need an expression for the primary rays". He assumes you're going to make a ray tracer, and he leads you through what you need to know and gets you coding it up. He points out variations and elaborations along the way. This approach is perfectly in the spirit of writing your own ray tracer, in which you normally have the drive of adding "just one more feature" that keeps you up until 5 AM. He even points out common pitfalls and ways to debug various features.

The book is not without its limitations. The coverage of some topics sometimes ends a little too quickly for my tastes. For example, the basics of efficiency grid creation and traversal are presented, but simple efficiency improvements such as mailboxing are not mentioned. Admittedly, mailboxing is not useful for multiprocessor systems, but I think it's worth mentioning as a handy idea in general.

As a test, I chose two terms, "radiance" and "Fresnel", and searched through the book to see how these are treated. The book does well with radiance, as it does a reasonable job defining the various types of radiometric units and draws the important connection between radiance and a sample ray. For Fresnel it mostly focuses on the Fresnel equation's effect on reflectance vs. transmittance as a function of angle. This is fairly important for a ray tracer, though the text rightly points out that it's often less noticeable than you might think. Where I find it important is for things like the surface of a pool or pond, where the effect of reflectance is low looking directly into the bottom while it increases as you look more towards the horizon.

The book presents the technique of making the specular color match the diffuse color to give a metallic look, vs. using a white specular color for plastics. It would have been nice to note that the Fresnel equation also is important in how metal and plastic differ in appearance. The Fresnel reflection effect, where at grazing angles all surfaces approach becoming perfectly reflective, is briefly mentioned indirectly when shading models are discussed. The book is interesting in that it does a thorough job of reconciling the Phong shading model, which is not energy-conserving, by reformulating it properly as a BRDF. However, Phong is as complex a shading model as is presented in the book. And this makes perfect sense within the context of what the author is trying to do: the "80% of the way, good enough for a start" Phong shading model is presented and put into the proper theoretical context. The author gives brief explanations and a number of references to more elaborate shading models. The focus of the book is to get the reader to the 80% level in a wide range of areas, with pointers where to go for more information if an area is of particular interest.

I could easily imagine this textbook being the basis for a basic or mid-level undergraduate computer graphics course. Such a course would necessarily ignore GPUs entirely, but the advantage would be in teaching first principles (light transport, BRDFs, sampling theory) and focusing on the scientific and mathematical concepts used in rendering as a whole. There are any number of areas that are not addressed by the book, such as tone mapping or BSP tree formation or procedural bump mapping. However, the basics are all there, and each teacher can elaborate on their own areas of interest. Those basics are carefully covered, with the proper theory and equations being presented without any dumbing down of the material. Questions and exercises are provided at the end of every chapter. The informative illustrations alone make the book worth purchasing by anyone planning on teaching or understanding more about the essentials of ray tracing.