Customer Reviews

Java 2D API Graphics

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

 

 

I have read both Java 2D grpahics books from front to back. I am working intensively with Java2D recently. The "Java 2D API Graphics" by V. Hardy is the best. It covers all the basic rendering API for Java 2D. The most amazing part is the GLF (Graphics Layer Framework) that was clearly described in this book. You can also see the full source code of how to extend Java 2D. The GLF is very valuable and the code is well written. Considering the content, it goes way beyond just Java 2D.

If you also are student of OO design patterns, you will find the framework is filled with design patterns, such as composite, factory, mementos, etc.. Although the book is more expensive, the book is beautifully done and the demo softwares are carefully crafted. You won't regret to buy and read it.

With one caveat, this book provides a thorough introduction to combining the features available in the Java 2D API. Following an introduction to many of the nuances the API itself (chapters 1-5), Mr. Hardy shows one way, but not the only way, to use the API in developing classes designed to solve real-world problems. I found this second section alone worth the price of the book. The book presupposes a firm grounding in Java and Object Oriented design; remembering, of course, that Mr. Hardy's point is not OO-design, but the underlying graphics capability of Java. Working through the code will repay you handsomely.

The third section takes you through some tool-building for creating, maintaining, storing, and retrieving images. Ignore Mr. Hardy's claims of computational intensiveness at your peril.

My only caveat is the paucity of information about printing, and developing sophisitcated printing classes. While it is true that printing entails knowing something about java.awt.print, nonetheless, learning how to build classes that provide for effective printing rather than just effective video display would have made this book near perfect. But I cavil! Buy this book if you want to learn to use the API.

There are two books that I feel empowered just to have them around. JavaScript Bible, and the Java 2D API Graphics. So fantastic. Shows you how and whys of the underlying graphics, colour models, the graphics... and damn... the graphics you can make with the GLF.

If you want to cut and past code donkey style... "templates" I think someone wrote... don't get this book, as you're missing the point.

Printed in full colour, it shows the technology at its best.

All great book are written by evangelists, and Mr hardy is one of them.

I have a graphic design background before becomming a programmer, and it completed a hole in my knowledge of graphics programming, about convolutions etc. Empower the graphical ability of your applications by reading this book. I was shopping for a 2D api book for months upon months before finding this. Really, this book can take your programming graphics ability to new levels, and is just too cool for words.

This book is a great source for whoever wants to use advanced graphics with Java, even if you are not an expert in Java (or in graphics for that matter, even it helps to know a little about the basics of graphics). This book is clear , well written and fully illustrated (full color!), with a gradual approach that will introduce all the necessary concepts of graphics (simple to advanced - check the couple of pretty tough chapters in Part III). Good for basic Web sites "funky" illustrations (navigation bar with advanced shadowing effects upon selection for instance) to full PhotoShop-like application written in Java !

Very good value, I believe and a reference guide for Java 2D Graphics (for additional API info, see the Java 2D Graphics book by Jonathan B. Knudsen).

Great Job !

I think this book is better than OReilly 2D. It shows how to justify text, modify text, create drop shadows, create layers, place text inside geometric objects like circles, and apply photoshop-like effects and filters to images. The CD comes with a Graphic Layer Framework jar file by Sun that I have not used yet.

Neil

i don't understand what the previous reviewer is ranting about giving this book a 1 star. disorganized? nothing could be further from the truth. chapter 1 is an introduction to the api, chapter 2 is an overview of the rendering pipeline, chapters 3,4,5 describe the api in detail, and the remaining chapters dealing with customized extensions to the api that any advanced programmer can do, showcasing the versatility of the api. there's code examples and walkthroughs on how to do complicated effects such as lighting, shadows, circular text, etc. text is interspersed with code and images of the code output so you know what the author is talking about. this book is for anyone who wants to do more than just draw circles and rectangles on the screen. if you want to write sophisticated 2d graphics code that looks like flash, pick this book up, it will give you valuable hints and examples.

This book is absolutely great. No words can describe how well the author tackles the problems. Newbies beware: This book does not have copy&paste type of code and you are much better off with some other book that describes the basics. You have to know how to use Java docs and other stuff like that. Since the book heavily depends bufferedImage, its not a good book for fast paced programming, such as games, but nontheless, all the examples can be modified to work on accelerated images.

If the bufferedImage becomes accelerated some day, the value of this book will sky rocket. If you want to know how to use 2D api, get it. There is no better way to learn it.

Not only is this book well-written, accurate and comprehensive, it also features an incredible example of how extensible the Java2D API is: the Graphics Layers Framework. This Photoshop-like image effects and compositing library alone is worth buying this book for. And last but not least, this book is printed in full, glorious colour to really show off before and after screenshots of the example programs. If only more books were made to this standard...

It is unfortunate that this excellent book is out of print. If you are an individual who wants to learn how to implement Photoshop-like effects and use Java2D doing it, this is the book for you. Pay any price to get your hands on it. However, this is not a tutorial on the general theory of computer graphics or image processing, and to understand this book you should already be familiar with both.

Part one is an adequate tutorial on the Java 2D API itself. It does not spend any time acquainting you with Java, as the author assumes you know this already. There is plenty of example code and instructive diagrams, plus the text is very accessible. However, some readers might also want to read "Java 2D Graphics" by Knudsen if they need more information strictly on the Java 2D API.

Parts two and three are about the author's own GLF (Graphics Layer Framework), which provides a foundation for the easy creation of rendering effects. This is what makes the book so valuable to programmers who want to implement interesting visual effects. The book describes how the framework is put together and how it can be used and extended by the reader's own code to produce Photoshop-like effects. The author starts out with very simple examples, such as "Hello Layers" in chapter six, and works up to more complex features. The author shows how to work with text, how to combine text and images, add patterns, and how to show transparency using alpha blending all using the GLF. The author has also built into his application a lighting studio of effects that he explains in great detail in chapter nine. The effects include directional light, spotlights, and elevation maps. By the conclusion of chapter nine, the author has described his framework as a set of tools that enable the reader to enhance the Java 2D platform capabilities.

Part three is about specific effects that can be built using these tools. Chapter 11 is about creating realistic effects and shadows. Effects discussed are all accompanied by code and include drop shadow, cast shadow, recessed shadow, embossing with directional light, tinting an image, and border embossing. Chapter 12 is about various text effects. Effects discussed include creating a glow behind objects backlit by a neon light, building a background texture from scratch, and using an image as a background texture. Chapter 13, "Sculpting with Light", is about creating realistic lighting conditions. Topics covered include carving with light, embossing with a spotlight, surface extrusion, and creating color contrast between text and its background. Chapter 14, "Fancy Text Layouts", covers unusual text layouts. Topics include how to lay out text in a circle or triangle, using strokes of various sizes and colors to make decoration elements stand out, and combining layer compositions. Chapter 15, "Tinting Photographs", uses the GLF ToneAdjustmentOp to tint or antique a photograph. Fast blur is also covered. Chapter 16, "Creating a Sense of Volume", covers using various gradient paints to create realistic 3D effects and give a sense of volume and depth. Topics include using transforms, shapes, and gradient paints to build cylinders, spheres, and bars. Also covered is the creative use of gradients for giving a sense of texture to objects. Finally, more sophisticated combinations and compositions are covered using the GLF's CompositionProxyLayer and CompositionFactory beans. There are code snippets throughout these chapters, and examples of what kind of effects the code produces. The entire framework source code is well laid out and commented and on the accompanying CD.

Chapter 17, the final chapter of the book, consists of a gallery of eleven sample visual effects created with the GLF. Each effect includes a verbal description of how it was produced, a figure illustrating the effect, and the name of the program on the CD that produces the effect.

In summary, this book is a masterpiece dealing with producing professional looking effects and graphics using Java2D and the author's framework. It is highly recommended for any programmer that looks at Photoshop's catalog of filters and asks "How?". Make sure you get a copy with the CD.

I spent some time going through the beginning of the book, and when I searched the web for more examples of code using Graphics2D, I discovered that those recent examples all override paintComponent(). In this book, the author's demos all override paint(). After further exploring, I found a number of posts in various Java forums where the advice was *never* to override paint() and to use paintComponent(). If using a container, then provide definitions for each component's paintComponent() method.

One explanation I found regarding this situation was:

"Rule: never override paint(). In the old AWT, that was the only way to go (there was no paintComponent) and confusion in the change from AWT to Swing, and old code still circulating, means that people are still overriding paint()! Stop it!"

Given that, I feel the Java 2D API Graphics should be read with a grain of salt. It provides a lot of the "under the hood" concepts and code (like Graphic Context Attributes) that are useful. However, the major code examples are out of date.