Customer Reviews

The Pocket Handbook of Image Processing Algorithms In C

5 star:		(5)
4 star:		(2)
3 star:		(3)
2 star:		(0)
1 star:		(2)

 

 

This book presents many algorithms and their C implementations in alphabetical order. Many of the entries show the result of the algorithm's application on an image. A table of contents groups the algorithms into classes, such as image fundamentals (convolution, correlation), morphological filters, and nonlinear filters. The basic stuff is all there. Also included in the appendix are programs to read and write image data, which can be used in conjunction with the C code listed for each algorithm for a working solution.

The theory is not emphasized, so readers should look elsewhere for that information. However, considering its small size, this book offers a lot of very useful information.

Very useful book. It provides *many* useful algorithms. The book is tiny, 3x5x1 so pound for pound it is a great (and portable!) book.

Some issues however detract from a 5 star rating:

a) The code examples are lame (lots of single letter variables) and poor C idioms, and some silly extra calculations, like counting pixels one at time in a loop when a single multiply would yield the same result.

b)The book feels old even though it was written in 1993. It has a codec for MacPaint files. If this doesn't ring a bell to you, MacPaint was written circa 1985 and it supports two bit images only. Most algorithms are tweaked for the B/W and/or grayscale versions so the reader will have to interpolate/derive her own color versions

C) The descriptions of the algorithms are suboptimal, but heck it is still orders of magnitude more useful than one of the fat texts on the subject. Coupled with the code examples you can easily figure out any non-clear descriptions without having to wade through a giant tome full of pseudo code.

Would I get it again - absolutely. I even made a special place for it (the top of my monitor so it won't get lost).

Potential buyers, please keep in mind that this book is for people that already know image processing theory or are enrolled in a course. We wrote this book for the student engineer to rapidly be able to code algorithms. They are very simply written, more so for understanding and ease of typing (most are one small page) than for algorithmic elegance or efficiency. Note that the book is very small and has a soft leatherette cover--this is so it fits comfortably in your back pocket and can be pulled out as needed. There is no CD, type the code in yourself and learn as you go. Some things are done for a reason, enjoy!

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.

I am currently enrolled in a computer vision class and we used the book to write a lot of the code for image processing. So far we have found a lot of typos and bugs in the code which wasted a lot of time in getting this to work. Some like an incorrectly calculated quadratic formula where easy to see in Major Axis but others like errors in the Moments code took a lot of debugging to find. Would love a second revised edition with the code thoroughly checked for errors. Oh and it turns out that the Major Axis code does not even work correctly, allowing the major and minor axis to switch after 90 degrees of rotation, this is something you probably wouldn't notice using it to process a static image but you can see when working with live video. I understand that this book is meant for people already in the field but that is not an excuse for writing bad code.

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.

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.

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 may seem like it's dated, since it was published almost 20 years ago, but it's one of the few image processing books that I keep turning to again and again. The amazing thing is that I turn to it not only for image processing, but for signal processing as well, since it's not difficult to remove one of the dimensions from 2-D algorithms. The main beautiful thing about this book is that it provides working code examples for many core image and signal processing algorithms. There is nothing better than seeing a simple implementation of an algorithm which you are trying to understand, and this book provides this perfectly. Yes, you can find more efficient FFT implementations (such as fftw.org), but you won't figure out how the FFT algorithm works as quickly.

Don't expect this book to explain the theory behind the algorithms, but expect it to solidify your understanding of the algorithms that are covered by providing a simple algorithm implementation.

Very well done!

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.