java left logo
java middle logo
java right logo
 

Home arrow Book Reviews arrow Java 2D Graphics
 
 
Main Menu
Home
Java Tutorials
Book Reviews
Java SE Tips
Java ME Tips
Java EE Tips
Other API Tips
Java Applications
Java Libraries
Java Games
Java Network
Java Forums
Java Blog




Most Visited Tips
Java SE Tips
Java ME Tips
Java EE Tips
Other API Tips
Java Applications
Java Libraries
Java Games
Book Reviews
Top Rated Tips
Java SE Tips
Java ME Tips
Java EE Tips
Other API Tips
Java Applications
Java Libraries
Java Games
Book Reviews


Statistics
Registered Users: 4088
Java SE Tips: 614
Java ME Tips: 202
Java EE Tips: 183
Other API Tips: 779
Java Applications: 298
Java Libraries: 209
Java Games: 16
Book Reviews:
 
 
 
Java 2D Graphics E-mail
User Rating: / 21
PoorBest 
 Book Information

Image


Authors: Jonathan Knudsen
Paperback: 339 pages
Publisher: O'Reilly Media, Inc. (May 1999)
Language: English
ISBN: 1565924843
ImageAmazon.com Link


 Book Review

Java 2D Graphics by Jonathan Knudsen is a remarkably accessible guide to graphics programming which gives powerful collection of classes and interfaces designed to provide complex graphical capabilities to developers on the Java 2 platform. This book explores the wide variety of Graphics2D classes and methods touching just everything which the reader might want to know.

In this book Knudsen has admirably covered the salient features of the Java 2D API and provided sufficient examples to get one started. . Besides the basic navigation of the API, this title delivers plenty of useful advanced material for extending Java 2D's capabilities. The 2D API allows you to produce high-quality, professional images on a screen or printer. Java 2D Graphics describes a detailed picture of the 2D API, demonstrating how to set line styles and pattern fills as well as more advanced techniques of image processing and font handling.

After a simple introductory session on Java 2D, the book focuses on a slightly bigger picture i.e. the Graphics2D class comprising of various participating elements, the Aliasing and Antialiasing technique as well as the conversion of User Space to Device Space. The author then moves on to the Geometric aspects supported by 2D API including various Java 2D classes representing geometric shapes, points, Rectangle, Ellipses and Arcs. The combining of several shapes with each other had also been taken into account.

The book provides sufficient scope for the programmer to learn various things that can be done once the shapes are created. Author not only explains different types of painting supported by the 2D API but also the end effect of both stroking and painting a shape. The focus then turn towards the various Rendering techniques applicable to graphics object along with 2D APIís support to the manipulation of shapes, text, and images in many of the same ways. The Compositing and Clipping concept together with Graphics2Dís support has been extensively explained.

Taking the Rendering topic further the author also discusses the rendering of text along with 2D APIís support for different text rendering capabilities. Keeping in view of the usersí need some features like embedding of images and shapes in the text string, rendering bidirectional strings etc had also been explained in the best of the possible ways. The information related to Glyph vectors, Glyph shapes, Color class, retrieving color values as well as color space is of great use to the developers.

The book gives an in-depth coverage of Images and Image Processing techniques in 2D API. The author recognizes the strength of various other image related issues like ways of loading and displaying the images, modifying the appearance of images using the 2D API's image processing classes, geometrical transformation of images using the 2D classes and hence explaining them in one of the best possible ways. 2D API being an efficient graphics programming tool provides developers with plenty of useful advanced material for extending Java 2D's capabilities.

Java 2D APIís support to represent various individual devices along with compatible image creation to the device configuration reflects its easy device compatibility. Printing Issues related to the Printing API of Java2 platform, job control and pagination issues, integration of printing into an existing application had also been discussed. The book ends with some animation and performance related discussion including the building of animation applications using the 2D API, efficient memory handling and several optimizing techniques for the application.

Overall Knudsen has admirably covered the salient points of the Java 2D API and provided sufficient examples to get one started through this book. This book lives up to the usual expectation by providing insightful and well-researched information written effectively and accessibly by the author thereby making it a rewarding book both for the beginner as well as for intermediate computer graphics developer.


 Table of Contents
  1. Preface

    • Who Are You?
    • About This Book
    • About the Examples
    • Font Conventions
    • Request for Comments
    • Acknowledgments
    • Who Are You?
    • About This Book
    • About the Examples
    • Font Conventions
    • Request for Comments
    • Acknowledgments

  2. Chapter 1: Introduction

    • What Is Java 2D?
    • What Can Java 2D Do?
    • Relatives
    • Genesis
    • Where Do I Get a Graphics2D?
    • File Formats
    • Hello, 2D!

  3. Chapter 2: The Big Picture

    • Graphics2D
    • The Rendering Pipeline
    • All About Alpha
    • Compositing
    • Coordinate Space

  4. Chapter 3: Geometry

    • Points
    • Shapes and Paths
    • Lines and Curves
    • Rectangles
    • Ellipses and Arcs
    • Constructive Area Geometry

  5. Chapter 4: Painting and Stroking

    • Painting
    • Stroking
    • Overlap

  6. Chapter 5: Rendering

    • Transforming
    • Compositing
    • Clipping
    • Rendering Hints

  7. Chapter 6: Text

    • Overview
    • Drawing Text
    • Fonts
    • Font Metrics

  8. Chapter 7: Advanced Text Layout

    • Using the TextLayout Class
    • Getting Close to the Metal

  9. Chapter 8: Color

    • If Youíre Not Too Picky
    • Physics and Physiology
    • Color Spaces
    • Profiles
    • Putting It All Together

  10. Chapter 9: Images

    • Overview
    • Where Do Images Come From?
    • Displaying Images
    • Drawing on Images
    • Double Buffering
    • A Useful Class

  11. Chapter 10: Image Processing

    • The New Model
    • An Appetizer
    • Predefined Operations
    • Roll Your Own

  12. Chapter 11: Image Guts

    • BufferedImage
    • Color Models
    • Rasters
    • Sample Models
    • Data Buffers
    • A PNG Decoder

  13. Chapter 12: Devices

    • The Local Graphics Environment
    • The GraphicsDevice Class
    • Device Configurations

  14. Chapter 13: Printing

    • How Printing Works
    • Controlling Printing
    • Power Printing

  15. Chapter 14: Animation and Performance

    • Itís Tougher Than You Might Think
    • See for Yourself
    • Memory
    • Optimizations

 Overview of Chapters
  1. Chapter 1: Introduction

    • What is Java 2D?
    • What can Java 2D do?
    • Origin of Java2D.
    • How Java 2D relates to some other APIs.
    • How to use the Graphics2D supporting different shapes, text and images.
    • How and what are the various formats to store the graphics information in a file.

  2. Chapter 2: The Big Picture

    • The Graphics2D class
    • What are the various elements comprising Graphics2Dís internal state.
    • The Aliasing and Antialiasing technique.
    • How the colors of a new graphics primitive are combined with the existing colors on a drawing surface(compositing)
    • How User Space gets converted to Device Space when objects are drawn.

  3. Chapter 3: Geometry

    • What are the various Java 2D classes that represent geometric shapes?
    • What are the various classes that represent points?
    • The interface available for various geometric shapes.
    • What are the various 2D classes that implement the shape interface?
    • What are the various classes supporting the Rectangle, Ellipses and Arcs.
    • How does 2D support for combining several shapes with each other.

  4. Chapter 4: Painting and Stroking

    • What are the various things that can be done once the shapes are created?
    • What is Painting and Stroking?
    • The steps followed for filling a shape.
    • What are the different types of painting supported by the 2D API?
    • The 2D APIís support for Stroking.
    • What happens if you both stroke and paint a shape?

  5. Chapter 5: Rendering

    • How the 2D API supports the manipulation of shapes, text, and images in many of the same ways.
    • What are the various Rendering techniques applicable to graphics object?
    • How transformation is performed with the help of 2D API.
    • What is Compositing and how it is performed.
    • What is Clipping and how Graphics2D supports it.
    • How rendering hints in 2D API provides control over the quality of rendering.

  6. Chapter 6: Text

    • Concept of Text rendering.
    • What are different text rendering capabilities supported by the 2D API?
    • How to embed images and shapes in your text string.
    • How to render bidirectional strings.
    • How to create a font from a name, a style, and a size.
    • How 2D API provides font measurement information.

  7. Chapter 7: Advanced Text Layout

    • What are the different classes providing support for rendering and editing text.
    • How to use the TextLayout Class.
    • How you can manipulate the shapes yourself.
    • What are the classes related to glyphs.
    • How to create Glyph vectors.
    • How you can retrieve Glyph shapes.

  8. Chapter 8: Color

    • The Color class.
    • How humans perceive light and color.
    • How to create color.
    • How to retrieve color values.
    • What is a color space?
    • What is a profile and how does it compensate for device dependencies.

  9. Chapter 9: Images

    • How to load and display images.
    • What are the classes supporting the 2Dís image concept.
    • What are the different ways of loading an image?
    • Concept of Image Observer.
    • What are the different ways of displaying an image?
    • How to draw on Images.
    • What is double buffering and how does it eliminates flicker in animated graphics.

  10. Chapter 10: Image Processing

    • How you can modify the appearance of images using the 2D API's image processing classes.
    • What are the different image operator classes are defined in java.awt package?
    • How you can write your own operator in 2D API.
    • How you can convert the colors of an image from one color space to another.
    • How images can be geometrically transformed using the 2D classes.

  11. Chapter 11: Image Guts

    • How to make image data accessible in 2D API.
    • The 2D APIís BufferedImage class.
    • How to translate between a color and a set of pixel samples using the ColorModel class of 2D API.
    • What is a Raster and how to implement it in 2D API.
    • How raster's sample models are represented in 2D API.
    • How to create a BufferedImage from information contained in a Portable Network Graphics (PNG) file.

  12. Chapter 12: Devices

    • How the 2D API provide information about the local graphics capabilities.
    • How to represent the Graphics environment in 2D API.
    • How Individual devices are represented by the GraphicsDevice class.
    • How GraphicsConfiguration can be used for implementing several functionalities.
    • How Configuration information can be retrieved using GraphicsConfiguration.
    • How you can create an image that is compatible with the device configuration.

  13. Chapter 13: Printing

    • The Printing API of Java2 platform.
    • The job control and pagination issues of printing.
    • How printing API works.
    • How you can put control over the printing process.
    • How you can integrate printing into an existing application.
    • How you can go for Printing more than one page.

  14. Chapter 14: Animation and Performance

    • How you can build animation applications using the 2D API.
    • What are the factors on which smooth rendering of frames depends on.
    • The AnimationComponent class
    • How to make your application handle memory efficiently.
    • How you can use several techniques to optimize your applications.

Reviewer: Sumit Kulshreshtha


 Related Tips

 
< Prev   Next >

Page 1 of 0 ( 0 comments )

You can share your information about this topic using the form below!

Please do not post your questions with this form! Thanks.


Name (required)


E-Mail (required)

Your email will not be displayed on the site - only to our administrator
Homepage(optional)



Comment Enable HTML code : Yes No



 
       
         
     
 
 
 
   
 
 
java bottom left
java bottom middle
java bottom right
RSS 0.91 FeedRSS 1.0 FeedRSS 2.0 FeedATOM FeedOPML Feed

Home - About Us - Privacy Policy
Copyright 2005 - 2008 www.java-tips.org
Java is a trademark of Sun Microsystems, Inc.