While this book at first appeared to be exactly what I was looking for, I quickly became disappointed by how hit or miss the entries are. Some entries are useful, while others simply waste space by going far to in-depth (for example, there is an entire algorithm that conveniently shows how to add pi/2 to the maximum axis to find the minimum axis of an object in an image). Other complicated topics are frustratingly over-simplified. The storage format topics are almost laughable; there are encoding and decoding details for macpaint and pc paintbrush formats that nobody ever uses, but entries for jpeg, gif, and tiff claim that the algorithm is to complicated for the scope of the book and point to outside references. The book isn't terribly useful unless you are well versed in the topic, and if that is the case then you probably don't require a book like this.

This book is ok for a quick find, but I've found mistakes that could have you scratching your head, like in the algoritm for Gaussian Noise. Your Images will look like crap and will not implement correctly until you discover they forgot to add the original pixel image to the noise. This can be annoying(unless you like to debug code) and time wasting. Fortuately they do provide before and after images that can help you muck through this. I could have given it a 2 star, but it does give a easy start if you are aware and informed. This is obviously not a tutorial or an indepth look at image processing. Just a way to implement image agorithms.

I really like this book. It gave me a jump start on image processing and it's good for anyone immersed in the field to find a quick solution to a particular algorithm they're looking for, get a good glimpse at how they're doing it and put it to code. However, there are a couple of flaws:

1. A good majority of the algorithms have the for loop indices reversed when performing spatial filtering. If you take a look at, let's say, the point detector code, the main 2 for loops to access the rows and the columns of the image are correct where the variable y iterates through the rows and x through the columns... however, for the sub-for loops when they iterate through the mask, they reversed the variables. i would be iterating through the rows and j would be iterating through the columns. To access a particular pixel within the spatial mask, they put *(IMAGE -> Data + X + I + IMAGE->Cols*(Y+J)). This syntax is incorrect. If I and J should be interchanged, then the loop iterations would be correct, but they're not. This error appears in several of the algorithms that are in the book.

2. The lack of the documentation makes it hard to go through. I understand that the book is for those who are already immersed in the field, but some comments do help.

3. They did a poor job on some of the theory in the book. The Hough Transform section of the book is written very poorly. They don't go too much into depth for some of the other concepts of the book.. then again, that's left for a textbook.

Though these errors surface in this handbook, it's very light, compact, and a good thing to keep beside your computer when you're coding away. All in all, I do recommend this book to anyone who wants to learn image processing quickly.

This book is excellent if you use it as intended - to lift working C code for the implementation of a variety of image processing algorithms. There are even algorithms for computer vision techniques such as circularity, compactness, and finding the minimum or maximum axis. This book assumes that you already know how to program in C and that you are already familiar with the theory of image processing as it was never intended to be a textbook on either of these subjects. However, this does not mean that this cookbook is devoid of theory. Each transform contains a short description of its purpose, a before and after image showing its effect, a paragraph describing the algorithm, and then the C code that performs the transform. Some reviewers have complained about the C code, but to me it was commented well enough that I have been able to easily translate several of the algorithms into Java for an application I have been writing. Depending on the complexity of the transform there may also be a diagram or an equation included. The algorithms are laid out in alphabetical order, so as to be convenient for quick look-up. It is true that the code assumes in most cases that the input image is a 256 level gray scale image, but then if the reader is familiar with image processing it should be easy to extend any of these transforms to color images. Where this book is weakest and most shows its age is in the class of transformations labeled "storage formats". For the image types the user is still most likely to encounter- GIF, JPEG, and TIF- the book only shows routines that tell you how to determine if the file is or isn't one of these types. Details on decoding or encoding these image types is beyond the scope of the book. The book does include details for PC Paintbrush and MacPaint formats. However, these simple image storage formats are no longer commonly used. I don't think that this one weakness negates the usefulness of this book for the vast majority of readers.

Plusses: lots of algorithms, good pseudo-code for implementing them, very easy to find stuff.

Minuses: some of the code presented is outdated (MacPaint files? Really, now...), while others are inaccurate. The 'Thinning' code generates incorrect results; it finds critical points, but does not produce a connected skeleton.