Computational Geometry in C and over 2 million other books are available for Amazon Kindle . Learn more

Sign in to turn on 1-Click ordering.
Trade in Yours
For a £5.91 Gift Card
Trade in
More Buying Choices
Have one to sell? Sell yours here
Sorry, this item is not available in
Image not available for
Image not available

Start reading Computational Geometry in C on your Kindle in under a minute.

Don't have a Kindle? Get your Kindle here, or download a FREE Kindle Reading App.

Computational Geometry in C (Cambridge Tracts in Theoretical Computer Science) [Paperback]

Joseph O'Rourke
4.2 out of 5 stars  See all reviews (4 customer reviews)
Price: £33.99 & FREE Delivery in the UK. Details
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
In stock.
Dispatched from and sold by Amazon. Gift-wrap available.
Want it tomorrow, 1 Nov.? Choose Express delivery at checkout. Details


Amazon Price New from Used from
Kindle Edition £27.53  
Hardcover --  
Paperback £33.99  
Trade In this Item for up to £5.91
Trade in Computational Geometry in C (Cambridge Tracts in Theoretical Computer Science) for an Amazon Gift Card of up to £5.91, which you can then spend on millions of items across the site. Trade-in values may vary (terms apply). Learn more

Book Description

13 Oct 1998 0521649765 978-0521649766 2
This is the revised and expanded 1998 edition of a popular introduction to the design and implementation of geometry algorithms arising in areas such as computer graphics, robotics, and engineering design. The basic techniques used in computational geometry are all covered: polygon triangulations, convex hulls, Voronoi diagrams, arrangements, geometric searching, and motion planning. The self-contained treatment presumes only an elementary knowledge of mathematics, but reaches topics on the frontier of current research, making it a useful reference for practitioners at all levels. The second edition contains material on several new topics, such as randomized algorithms for polygon triangulation, planar point location, 3D convex hull construction, intersection algorithms for ray-segment and ray-triangle, and point-in-polyhedron. The code in this edition is significantly improved from the first edition (more efficient and more robust), and four new routines are included. Java versions for this new edition are also available. All code is accessible from the book's Web site ( or by anonymous ftp.

Frequently Bought Together

Computational Geometry in C (Cambridge Tracts in Theoretical Computer Science) + Discrete and Computational Geometry
Price For Both: £74.20

Buy the selected items together
  • Discrete and Computational Geometry £40.21

Product details

  • Paperback: 392 pages
  • Publisher: Cambridge University Press; 2 edition (13 Oct 1998)
  • Language: English
  • ISBN-10: 0521649765
  • ISBN-13: 978-0521649766
  • Product Dimensions: 17.7 x 2 x 25.3 cm
  • Average Customer Review: 4.2 out of 5 stars  See all reviews (4 customer reviews)
  • Amazon Bestsellers Rank: 933,743 in Books (See Top 100 in Books)
  • See Complete Table of Contents

More About the Author

Discover books, learn about writers, and more.

Product Description


'… the author does an excellent job of explaining difficult concepts in an accessible, even entertaining, manner … If this is your field, this is your book!' Developers Review

'The balanced combination of careful descriptions, examples, algorithms and exercises makes it a pleasure to read …'. Zentralblatt

'Anyone who wants to know what this field is all about should read this book! The book is a pleasure to read, as questions that arise naturally in the reader's mind are answered, in almost all cases, in the following paragraph. The style strikes an ideal balance between rigor and informality. Mr O'Rourke must be a wonderful teacher and I envy his students.' Miriam L. Lucian, Society for Industrial and Applied Mathematics

Book Description

This is the revised and expanded 1998 edition of a popular tutorial on the design and implementation of geometry algorithms. The self-contained treatment presumes only an elementary knowledge of mathematics but includes the latest research topics, making it an excellent resource for programmers in computer graphics, robotics, and engineering design.

Inside This Book (Learn More)
First Sentence
Much of computational geometry performs its computations on geometrical objects known as polygons. Read the first page
Explore More
Browse Sample Pages
Front Cover | Copyright | Table of Contents | Excerpt | Index | Back Cover
Search inside this book:

What Other Items Do Customers Buy After Viewing This Item?

Customer Reviews

4.2 out of 5 stars
4.2 out of 5 stars
Most Helpful Customer Reviews
3 of 3 people found the following review helpful
3.0 out of 5 stars Lots of Detail about not a lot. 2 Jun 2009
By Alun Williams VINE VOICE
Format:Paperback|Verified Purchase
What this book covers it usually covers well and in an interesting and thoughtful way. An undergraduate following a computer science course teaching several of the topics in this book would probably find it very useful. However, if you come to this book expecting it to solve some particular geometric problem you are liable to be disappointed. In particular there is little or no material relating to graphical questions. In the course of the book's 8 proper chapters (there is a chapter 9 listing further possible sources of information) there are only 12 algorithms given in full. Most of the book is taken up with various questions relating to convex hulls (two chapters), polygons, and polyhedra (three chapters). The other chapters are about Voronoi diagrams and motion planning. The latter is one of the few chapters where the author considers questions about circles in detail.

The author has a strong aversion to the use of floating point numbers and recommends using integers instead, though he is fairly silent on what one is supposed to do if the data being dealt with is naturally floating point in character. The emphasis on integer arithmetic means that in numerous places he is forced to discuss questions about overflow. He has a somewhat optimistic attitude to special cases - even though is often the case that the main practical difficulty of dealing with a geometric problem on a computer lies in handling special cases correctly.

Overall, this is a good book for the programmer interested in geometric questions to have on his bookshelf, but it is unlikely to be the only one he or she will need, or even the most useful.
Comment | 
Was this review helpful to you?
4 of 4 people found the following review helpful
By A Customer
Format:Paperback|Verified Purchase
This is beyond any doubt a must have for any student/researcher/programmer interested in computational geometry. The book is very well-written and presents all ideas and algorithms in a way that allows the reader to use them and implement them directly. The book does not have the depth of theoretical analysis of the classic reference of Shamos and Preparata, but is far more useful in practice from the computer scientist's / engineer's point if view.
Comment | 
Was this review helpful to you?
5.0 out of 5 stars A very good introduction 23 Mar 2007
By J. Jack
For the aspiring computer scientist or student alike - this book gives you a clear way forward into the computational geometry field and presents lemmas and proofs every step of the way. Thought and intelligence required.
Comment | 
Was this review helpful to you?
2 of 3 people found the following review helpful
4.0 out of 5 stars Not at all Bad ! 31 May 2000
Well presented and thought through, however it does tend to go around the block before getting to the point. A Lack of example code which doesn't help, but for the most part, but still a good book, and reccomended.
Comment | 
Was this review helpful to you?
Most Helpful Customer Reviews on (beta) 4.2 out of 5 stars  6 reviews
13 of 13 people found the following review helpful
4.0 out of 5 stars Very hepful 9 May 2002
By Dr. Lee D. Carlson - Published on
Anyone who is involved in areas such as computer graphics, computational radiology, robot vision, or visualization software should have a copy of this book. The author has done a fine job of introducing the most important algorithms in computational geometry, choosing the C language for their implementation. The choice of C might be somewhat dated now, since C++ is now beginning to dominate computational geometry, but readers who are actually programming these algorithms using C++ can easily extend the ones in the book to C++. Not all of the algorithms in the book are implemented into C, unfortunately, but the clarity of presentation is done well enough to make this implementation a fairly straightforward task. My interest in the book came from a need to design and implement algorithms for polyhedra in VRML and toric varieties in algebraic geometry. This book, along with others, was a great help in that regard. The running time of these algorithms was not really an issue with me, so the detail the author spends on discussing the complexity of the algorithms was not a concern. Readers who need to pay attention to running-time issues will appreciate his discussion of them for the algorithms that are presented.
The ability to visualize objects in an abstract subject like algebraic geometry boils down to, in the case of toric varieties, to a consideration of how to manipulate polytopes geometrically. A major portion of the book, if not all of it, is devoted to the computational geometry of polyhedra. Because it is an introductory book, some more advanced topics, such as Bayesian methods to find similarities between polyhedra, and neural network approaches to classifying polyhedral objects are not treated. Readers who need to do such things will be well-prepared for them after a study of this book. In addition, there are good exercises assigned at the end of each chapter, so the book could be used in the classroom. Some readers will however choose to use it as a reference source, and it would be a good one, for the author gives references to topics that he only touched upon in the book.
Some particular areas that were treated especially well were: 1. The discussion on data structures for surfaces of polyhedra. Although not very general, since he choose to deal with only triangulated polytopes, readers who need to be more general will have a good start in this discussion. 2. The discussion on volume overflow and how to deal with it using robust computation. 3. The discussion, albeit short, of the randomized incremental algorithm. 4. The treatment on the minimum spanning tree and Kruskal's algorithm. Communication network performance optimization is now a major application of this algorithm and others in graph theory, including the author's later discussion of Dijkstra's algorithm.
21 of 24 people found the following review helpful
5.0 out of 5 stars A clear, concise text on fundamental Computational Geometry 17 July 1998
By Bob Williamson ( - Published on
O'Rourke's approach reflects the essence of both "Computational Geometry" and the "C language" --- concise yet profound. The book covers the core subjects of Computational Geometry: polygon partitioning, convex hulls, Voronoi diagrams / Delaunay triangulation, "arrangements" of lines, geometric searching, and motion planning.
The book assumes some familiarity with the C language, but is very readable even for non-C programmers. This is an excellent text for use as an introduction to Computational Geometry, a primer for Preparata & Shamos, while at the same time it's an excellent addendum to that more seminal text. By weaving working code into his presentation, O'Rourke gives traction to the powerful engine of Preparata & Shamos.
10 of 12 people found the following review helpful
4.0 out of 5 stars Nice balance of theory with code 3 Feb 2003
By Jason - Published on
This book was pleasantly surprising: I had expected to see code presented with minimal motivation or discussion of the underlying ideas -- something of a "Computational Geometry for Dummies" sort of book. That's not the case at all. This is a bona fide textbook on the subject, suitable for an undergraduate course.
It covers all of the the "classical" topics: convex hulls, line segment intersection, polygon triangulation, Voronoi diagrams, motion planning.
The mode of presentation -- supporting a discussion of the theories with implementable code -- is actually a bit refreshing. For comparison: Other books, when discussing the line segment intersection problem (ie: Given a set of line segments, find all of their intersection points) simply assume that computing the intersection of a pair of segments can be done in constant time. This is not an especially difficult problem, but the discussion seems more complete with a brief description of how this might be done. The same can be said about other primitive tests and operations in other algorithms.
Overall, this book can stand alone as an excellent introduction to computational geometry, but a serious student in the subject will want more: perhaps Preparata and Shamos or de Berg et. al.
41 of 55 people found the following review helpful
3.0 out of 5 stars okay content, mediocre presentation 1 Mar 1999
By Pete Gonzalez ( - Published on
This book provides a reasonable introduction to the field of computational geometry, although the notation is sometimes sloppy and the author frequently makes inconsistent assumptions about the reader. For example, on the first page he refers to a circle as a "one-dimensonial set of points," which although valid from a toplogical perspective is a little confusing in an introductory text. As another example, the first exercise refers to "every point in dP," presumably meaning just the corner points (otherwise the problem would be unsolvable). The book also sets up a lot of irrelevant mathematical definitions that generally obfuscate the presentation rather than clarifying it. Although not prohibitive for the ambitious reader, these needless hindrances are at best a little annoying.
Secondly, I must criticize the text's scope, in light of the important role computational geometry has played in modern computer graphics. There is no discussion of clipping, culling, occlusion (e.g. BSP, octree, OBB), or even non-polygon primitives -- important topics arguably more useful to the target audience than e.g. convex hulls (to which over 1/4 of the book's pages are devoted).
Regardless, this book (combined with a professor and a course) probably would serve quite well as an undergraduate text. Readers interested in a cookbook of applied graphics algorithms, however, should look elsewhere.
3 of 3 people found the following review helpful
4.0 out of 5 stars Excellent text, obfuscated code 27 Jun 2010
By Zeljko Vrba - Published on
Format:Paperback|Verified Purchase
I bought this book to learn about convex hulls, voronoi diagrams and delaunay triangluations, and line arrangements. So far I have made it through the chapter on 2D convex hulls, and I must say that it is an excellently written book for learning about the covered topics in computational geometry. The text is clear easy to understand; algorithms are sufficiently detailed and illustrated to allow full implementation without needing other resources. Corner cases are meticulously covered. I also like the text because it is straight to the point, i.e., it does not spoon-feed the reader. So, although relatively short book, it contains a lot of densely packed, but still enjoyably readable, information. Illustrations are simple but excellent: they are carefully designed and very helpful for understanding the described algorithms.

I give the book four stars for two reasons.

First, the coverage of floating-poing precision issues is almost non-existant: most of the algorithms are integer-only. A survey chapter over techniques for handling FP precision issues would be *VERY* welcome. (After all, geometric algorithms are most often applied to floating-point data in the real world.) Judging by the quality of existing bibliography, I think the author would make an outstanding job on this topic. (Hint for the 3rd edition :-))

Second, I have strong objections against the coding style used in this book: the presented code is an excellent demonstration of how to obfuscate C programs by using typedefs and hungarian notation (inconsistently!) applied in postfix. (NOTE: I have 10+ years of experience in C and C++ coding, so I'm not just a "little bit confused").
Were these reviews helpful?   Let us know
Search Customer Reviews
Only search this product's reviews

Customer Discussions

This product's forum
Discussion Replies Latest Post
No discussions yet

Ask questions, Share opinions, Gain insight
Start a new discussion
First post:
Prompts for sign-in

Search Customer Discussions
Search all Amazon discussions

Look for similar items by category