Customer Reviews

Building Imaging Applications with Java(TM) Technology: Using AWT Imaging, Java 2D(TM), and Java(TM) Advanced Imaging (JAI)

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

 

 

I have recently bought this book after buying the o'reilly's Java 2D Graphics and the sun Java2D API which are realy 2 great books but compared to this one are absolutely nothing. It's amazing how this book manages to combine concepts of the whole 3 mthods of dealing with images in Java in AWT, Java2D and the new JAI which no other book not to my knowlege at least hasnt even dealt with the subject let alone explain it so thoroughly with great examples like this one. It's also full of code utilizing alot of new methods and techniques which would make this a great book to learn from even if u didnt want to learn anything about imaging in Java. It puts alot of emphasis on dealing with imaging neglegting the other aspects of the API but I guess for most of us interested in this subject that is the only thing that matters I certinly skipped all the chapters dealing with the others subjects in the other 2 books. If u were in doubt of buying this title just take a look at the output of the examples given and you will see the potential of the things that could be done with imaging using JAI or JAVA2D.

This book suffers from tacit knowledge oversight, a situation where the author assumes that the reader already knows the subject matter. Reading this book didn't help me understand the design behind Java 2D API or how to use it effectively

The concept of the Alpha channel is not discussed at all. How do you use Java 2D with ARGB data? This book does not tell you.

An example of a simple problem that I couldn't solve after reading this book is how do you use Java 2D when your data is ordered BGR instead of RGB? You would think that interchanging the values in the BandOffsets would do it, but Java 2D throws an Exception. In general his short examples seem too contrived to be useful, and the examples that use random numbers as images are not useful because you can't tell if the image is displayed correctly.

On the positive side the region of interest example included looks very interesting (though I haven't tried it).

I'd like to see a second edition that explains the design of Java 2D, how the APIs are supposed to be used, and why certain things don't work as expected.

I have found this book very helpful to me as a professional programmer developing an imaging application in Java.

In addition to showing how images can be created and manipulated using the Java APIs, it also follows sound software engineering methodology. Before presenting the example code, the author first discusses and defines the expected capabilities/requirements of the subsystem that he is building. Next he defines a Java interface that captures those capabilities and finally presents and discusses the code that implements the interface(s). He also discusses Design Patterns where appropriate and makes use of Factory patterns, etc.

This book is packed with information, advice, strategies, and sample code. In this sense the book is a great reference. My only `warning' to potential readers is that this book follows the `big example' paradigm. Chapters are fairly long and each chapter builds a fairly large multi-file example. Later chapters often `extend' classes discussed and developed in earlier chapters. This means that the best approach is probably to read the book through from start to finish if you want a thorough understanding of the examples.

On the plus side, the examples are not `toys.' They are solid well-engineered Java programs that should be useful to anyone serious about work in imaging.

The book provides a complete coverage of image display, menipulation and processing using AWT, JAI etc. The books is well written and provides a step by step approach to get people started on java applications from a simple image viewer to fairly advanced handling of image data. While providing valuable insight into the subject of image handling a sound software engineering framework is at the same time used, incl regular java libraries, beans, applets etc. Overall the readers is given a solid introduction to these issues. From the material presented the readers gets a good sense for how one might expand the techniques into professional applications. If you plan to use imaging as part of a real application this is a must read to see the many potential approaches to a particular problem. In addition to presenting the java-image facilities the authors also provides a reasonable introduction to basic topics such as color space, image filtering, image formats, etc. Thus a minimum of prior experience is needed. If you are a long-term expert in image processing you might still find good guidance here. I.e. there is something for everyone here.

I bought this book based on the positive reviews and I have the following complaints:
1) The writing style is extremely poor and the book is full of grammatical errors.
2) Some statements are absolutely false because errors were missed during editing. (See 2nd last paragraph of page 22).
2.) The code snippets are often incorrect or sloppy. (e.g.) snippet may contain a "catch" statement with no corresponding "try".

Overall this book compares very unfavourably to the Java 2D book in the Sun series even though that book is becoming somewhat dated.

This book is an OK tutorial on Java imaging technologies, even though the book is 5 years old. Some things have changed, particularly with the Java Advanced Imaging API, but not enough to invalidate the book's tutorial. I would say if you are a complete novice to imaging in Java, you should read "Java 2D Graphics" by Knudsen. Also, the chapters on Swing in "Core Java Volume 1" by Cornell are essential. For the Java advanced imaging API, go to the JAI API website and download the "Java Advanced Imaging Programming Guide" that is freely available online from Sun Microsystems.
After you know the essentials, this book is good for specific problems you'll encounter in the AWT, Java2D, and JAI. For example this book talks about how to load images from Jar files, how to build region-of-interest (ROI) applications in Java 2D, the use of Java Beans and imaging, interactive graphics, and curves.
Finally, this book is good because it goes into details - including code - on how to perform certain common but often difficult imaging utilities in Java such as pie charting, image histograms, viewing very large images using JAI tiles, image processing with JAI, and performing Internet imaging by using the JAI with servlets.
If you are serious about imaging in Java it is an essential reference, but don't use it as your primary source for a tutorial.

This is an excellent resource for imaging development with Java and an altogther beautiful book complete with glossy, color pages. The only downside to this text is that there seems to be a new imaging API every week in the Java world. Even still, this is a great source to help you get started.

This is a really neat book. Lots of very cool useful working examples. It's hard to put this book down. I really like how the author steps you through the code after each example. Even a novice like me can understand most of it. My only complaint is the code has almost no comments. He makes up for it in the book however. His coding style is also very clean and logical. This book was designed for J2SE 1.3.

I bought this book with the intention of learning the JAI API for dealing with imagery. I have read the book from cover to cover three times, and all I have learned is how wonderful a developer the author believes he is.

This book does not go into enough detail on any of the API's, but it is especially lacking with regards to JAI. He has some sample code in the book, but all of the sample code is wrappers he has written around the Sun API's. Instead of explaining the API's one would like to learn, we are given a full detailed explanation of the wrapper code he has written, and leaves the API explanation details to the reader to figure out for themselves.

This book is a complete waste of time, and has to be the worst book I have ever read relating to Java. Next time, save your development skill advertising to your resume.

I love this book; I was tempted to write this review since I saw a few negative comments by others that might put a potential purchaser off, and I would not want that.

As someone who both develops and specifies medical imaging applications in Java and other languages, I buy every book that has anything to do with the subject, and this is the one that I find most helpful and the one that I refer to most, even after all these years of using it.

This is NOT a book dedicated to JAI, however, and it pre-dates the JIIO stuff, so you will still need the Sun material for that, as others have pointed out.

It is also very elegantly presented and produced, for those who appreciate the aesthetics of a book as well as its content.

David