Images « Graphics Desktop « Java Articles

True to its name, an image producer produces image data. The image producer in last month's column produced an image showing a color gradient. However, an image producer is not limited to generating (and regenerating) a single, static frame of image data; in fact, it is free to redefine the image data at any time.

The developers of the Java class library used the producer/consumer model as the basis for the library's low-level image-handling API. This model, which has several advantages we'll examine in a minute, consists of two tightly coupled components: producers and consumers. You may have been able to guess the components' names, but understanding what they do requires some explanation. Let's take a look.

One suggestion is to use below-background image placement to provide textual information relating to the link; interesting graphical effects can be achieved with Image overlays. If this applet is designed to be as generic as possible, then it can be written and compiled once, and reused many times with differing effects.

For this reason, the Java class library was designed to support asynchronous loading of media, such as images. Asynchronous loading means that loading occurs out of step with the rest of the application -- in another thread -- in the background. In fact, what might be thought of as one operation, the loading of an image from across the network, actually occurs in two distinct stages, which often occur asynchronously. These stages are: image definition and the actual downloading of the image.

© O'Reilly Media, Inc. | (707) 827-7000 / (800) 998-9938 All trademarks and registered trademarks appearing on oreilly.com are the property of their respective owners.

Ratings, keywords, and groupings are different categories of evaluation that can be cross-referenced with each other to narrow down your searches to a small number of likely results. For example, if you are looking for "good pictures of Josie" for some purpose, your work assigning ratings, keywords, and groupings can be very helpful.

With that, I invite you to enjoy "Resizing an Image." It may just be the most fun you’ve had with a 21-foot-tall rocking chair in all your life.

Perhaps the question we should asking in 2004 is what can we do to improve this situation? Sometimes it is an attitude problem. If the typical conversation falls along the line of ?What does a Java guy know about business, anyway??, and yet you?re still required to build a sophisticated working application for the business, then it is not surprising if there are faults. It is my view that all stakeholders should be a part of the software design and analysis committee. Moreover, they should take far more active involvement and oversee the development of long-term critical projects. Instead of creating a business process that inserts an intermediate layer, a liaison between IT and the core business, these two should constantly be in direct communication, more often than less. On the other hand it is up to the developers and technical people to become more involved with the core business. As we are always going to start learning the next biggest thing to arrive since Enterprise Java Beans, really it is up to us to actually learn about the business of our clients and show enough interest. We have to become our own value-add in their eyes, I think, if we are to survive .

This article presents an algorithm for embossing images. The article then implements it as EmbossedIcon, a class that displays embossed images. Because EmbossedIcon subclasses javax.swing.ImageIcon, you can easily convert source code that depends on ImageIcon to source code based on EmbossedIcon.

Image I/O is a powerful API for reading and writing images in an extensible variety of formats. Because this power comes with a degree of complexity that can overwhelm developers new to Image I/O (and possibly frustrate experienced developers), this article presents a grab bag of useful Image I/O utilities that can make your Image I/O experiences more productive. Help yourself to them.

For years, the Java 2D team has been encouraging developers to move away from JDK-1.0-isms like Image.getScaledInstance() and onto more modern APIs. We often make blanket statements like, "oh you don't want to do it that way, here's a better approach" and hope that developers take our word for it. It's a great strategy, that is until we receive the inevitable follow-up question: "But why?"

In part one of this series, you begin to discover TWAIN. You then explore a very simple API that bridges the Java world with the TWAIN world: JTwain. Finally, you play with a simple Swing-based application that interacts with JTwain to select an image-acquisition device and acquire images from that device, to be displayed within a scrollable window: JTwainDemo. Part two increases your knowledge of TWAIN, and then builds upon the JTwain API to take advantage of additional TWAIN features. Finally, part three concludes this series, by exploring SANE, presenting a SANE-based API for Java, explaining the need for two standards, and studying the goal of merging the TWAIN and SANE standards into a unified image-acquisition standard.

Note: The methods getRC() and getCC() return values that identify failures with TWAIN. They do not return values that identify non-TWAIN failures. The only places where a non-TWAIN failure might occur are located in the acquire() method: an image transfer used compression or did not produce an 8-bit (grayscale) or 24-bit (RGB) image, the transferred image could not be added to an internal vector data structure (because of limited memory), or the image could not be converted from Windows' device-independent bitmap format to a Java-based image (perhaps a Java class or method couldn't be found, memory was exhausted, or a method could not be called).

Wow, that is a long list of complaints! Wouldn't it be nice to have an image viewer with fast, predictable zooming so that magnified details of the image stay on the screen rather than disappear from view, a viewer with good quality rendering, and easy navigation around the zoomed image? The Navigable Image Panel presented in this article, is my attempt at this.

This article begins with an introduction to SANE, where you learn about SANE's environment, API, and network protocol. The article next explores a Java API for acquiring images with SANE. Moving forward, the article discusses the need for both SANE and TWAIN. The article (and series) closes by looking at merging SANE with TWAIN into a unified image-acquisition specification.

Processing images sent from a distant spacecraft is something that most of us will never need to handle. But you might find yourself needing to sharpen a blurred image that you took with your digital camera, for example. Although you can use off-the-shelf software to accomplish this and other image-processing tasks, that software might not support your special requirements. Instead of building your own Java-based image-processing software to meet these requirements, you might want to investigate Imagician.

Interested in manipulating images but need to use formats other than GIF, JPEG, and PNG? Looking for better performance when working with JPEG images and don't know where to look? Need to manipulate images through geometric operations, including non-linear transformations? Fret no more; the answers are here in the form of the Java Advanced Imaging (JAI) API and the Java Advanced Imaging Image I/O API 1.0 RC from Sun.

The basic approach with intermediate images is to create an image of the type and size that you need, perform your expensive operations to that intermediate image, and thereafter copy from that image instead of performing your rendering operations directly.

In two-dimensional (2D) animation it is often necessary to move an object or objects around the 2D area in predetermined patterns, sometimes called control paths. This type of animation requires that you solve two problems:

By using this program as a driver, you can concentrate on writing and executing image-processing algorithms without having to worry about many of the details involving image files, image display, etc.

The programs that I am providing and explaining in this series of lessons are not intended to be used for high-volume production work. Numerous integrated image-processing programs are available for that purpose. In addition, the Java Advanced Imaging (JAI) API has a number of built-in special effects if you prefer to write your own production image-processing programs using Java.

In these two tutorial articles on GUI components, we have covered text button, image button, group panel, line separator, label, image canvas, and progress bar. There are still a few components we did not investigate (e.g., tab, slide bar). However, the main purpose of these discussions is to give you an idea as to how you can improve or create your own GUI components. I believe many of you have more of these basic skills than I do, so no doubt you can definitely do a much better job with these than I've done.

In this article, two types of buttons ? text-based and image-based ? are described in detail and illustrated by working examples. If standard AWT GUI components offered by Sun's JDK package do not satisfy you, this should be a good tutorial to get you started on making your own unique GUI components from scratch. These components can be used by applets or applications. However, to make sure they work in most browsers when used in applets, no new classes in JDK 1.1 or later versions are included in our design. Now it is your turn to put your artistic and technical expertise into action.

This tutorial will focus on how to make use of some basic Java Development Kit (JDK) classes and image-manipulation techniques to create a simple image puzzle game. It is intended to give you a taste of how fun programming can be and a starting point leading to more serious applications, if you are really encouraged by these simple fundamental tips.

The first lesson in the series was entitled Processing Image Pixels using Java, Getting Started. The previous lesson was entitled Processing Image Pixels, Performing Convolution on Images. This lesson builds upon those earlier lessons.

400 Processing Image Pixels using Java, Getting Started 402 Processing Image Pixels using Java, Creating a Spotlight 404 Processing Image Pixels Using Java: Controlling Contrast and Brightness 406 Processing Image Pixels, Color Intensity, Color Filtering, and Color Inversion 408 Processing Image Pixels, Performing Convolution on Images 410 Processing Image Pixels, Understanding Image Convolution in Java 412 Processing Image Pixels, Applying Image Convolution in Java, Part 1 414 Processing Image Pixels, Applying Image Convolution in Java, Part 2 416 Processing Image Pixels, An Improved Image-Processing Framework in Java

The check box at the top of Figure 6 is checked, sending a message to the image-processing program to implement color inversion.

The programs that I am providing and explaining in this series of lessons are not intended to be used for high-volume production work. Numerous integrated image-processing programs are available for that purpose. In addition, the Java Advanced Imaging (JAI) API has a number of built-in special effects if you prefer to write your own production image-processing programs using Java.

The ImageBrowser class, as the name suggests, is a simple image browser. You can view GIF and JPG, JPEG images using this browser. I have included the

A couple of months later in the lesson entitled Processing Image Pixels Using Java: Controlling Contrast and Brightness, I published an updated version of the program. The updated version was named ImgMod02a. The purpose of that update was rather minor. Basically it improved the code that reads an input image file.

In this article, I will briefly walk through how colors of image pixels are encoded in Java. Then I'll offer transparency examples, and I will show what they look like if the issue is not taken care of. Lastly, I will provide the code and the result.

The image-processing program that I will explain in this lesson will show you how to control image contrast and brightness by controlling the distribution of color values that make up the image.

The first lesson in the series was entitled Processing Image Pixels using Java, Getting Started. Because this lesson builds upon that earlier lesson, you will need to understand the code in the previous lesson before the code in this lesson will make much sense.

One of the most important issues in performing convolution on images has to do with the ability to vary the 2D aspect of the size of the convolution operator. The two programs that I will explain in this lesson approach this process in two different ways.

This article introduces you to the blending transition. First we'll look at an algorithm for blending two images by directly manipulating their pixels, followed by a Java application that demonstrates this algorithm. Then we'll focus on a superior technique for blending images: alpha compositing. Finally, I'll reveal a Java slideshow application that performs slide transitions via blending as a practical demonstration.

Back in the days of the MS-DOS and PC-DOS operating systems, images were often stored in files based on ZSoft Corporation’s PiCture eXchange (PCX) format. Because you might have some PCX images that you want your Java programs to read, and because Java does not support the PCX format, I’ve created a plug-in for Image I/O that lets Java programs read PCX images.

Several drawImage methods can be called to perform scaling prior to drawing an image. To demonstrate how this works, Listing 1 presents source code to an ImageScale applet. This applet draws an original image along with a scaled-down version of the image.