Learning Java, 4th Edition

Converting an Image to a BufferedImage

• Image processing can be performed only on BufferedImages, not Images. Remember that the core AWT tools all work with Image and that only if you are loading images using the ImageIO package will you get BufferedImages. Our ImageProcessor example demonstrates an important technique: how to convert a plain AWT Image to a BufferedImage. You do it by painting into the buffer, effectively copying the data. The main() method loads an Image from a file using Toolkit’s getImage() method:
  

1.     Image i = Toolkit.getDefaultToolkit().getImage(filename);

复制代码

• Next, main() uses a MediaTracker to make sure the image data is fully loaded.
• Finally, the trick of converting an Image to a BufferedImage is to draw the Image into the drawing surface of the BufferedImage. Because we know the Image is fully loaded, we just need to create aBufferedImage, get its graphics context, and draw the Image into it:
  

1.     BufferedImage bi = new BufferedImage(w, h,
   
2.             BufferedImage.TYPE_INT_RGB);
   
3.     Graphics2D imageGraphics = bi.createGraphics();
   
4.     imageGraphics.drawImage(i, 0, 0, null);

复制代码

1. //file: NoisyButton.java
   
2.     import java.applet.*;
   
3.     import java.awt.*;
   
4.     import java.awt.event.*;
   
5.     import javax.swing.*;
   
6. 
   
7.     public class NoisyButton {
   
8. 
   
9.       public static void main(String[] args) throws Exception {
   
10.         JFrame frame = new JFrame("NoisyButton");
    
11.         java.io.File file = new java.io.File( args[0] );
    
12.         final AudioClip sound = Applet.newAudioClip(file.toURL());
    
13. 
    
14.         JButton button = new JButton("Woof!");
    
15.         button.addActionListener(new ActionListener() {
    
16.           public void actionPerformed(ActionEvent e) { sound.play(); }
    
17.         });
    
18. 
    
19.         Container content = frame.getContentPane();
    
20.         content.setBackground(Color.pink);
    
21.         content.setLayout(new GridBagLayout());
    
22.         content.add(button);
    
23.         frame.setVisible(true);
    
24.         frame.setSize(200, 200);
    
25.         frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
    
26.         frame.setVisible(true);
    
27.       }
    
28.     }

复制代码

Saving Image Data

We’ve spent a lot of time talking about loading images from files and generating and transforming image data, but nothing about saving it. First, let’s remember that saving an image to a file such as a JPG or GIF really implies doing two things: encoding it (highly compressing the data in a way optimized for the type of image) and then writing it to a file, possibly with various metadata. As we mentioned earlier, the core AWT does not provide tools for encoding image data, only decoding it. By contrast, the ImageIO framework has the capability of writing images in any format that it can read.

Writing a BufferedImage is simply a matter of calling the static ImageIO write() method:

1.   File outFile = new File("/tmp/myImage.png");
   
2.     ImageIO.write( bufferedImage , "png", outFile );

复制代码

The second argument is a string identifier that names the image type. You can get the list of supported formats by calling ImageIO.getWriterFormatNames(). We should note that the actual type of the image argument is something called RenderedImage, but BufferedImage implements that interface.

You can get more control over the encoding (for example, JPG quality settings) by getting an ImageWriter for the output format and using ImageWriteParams. The process is similar to that in the reader progress listener snippet from the section ImageIO.

Working with Overloaded Constructors

A constructor can refer to another constructor in the same class or the immediate superclass using special forms of the this and super references. We’ll discuss the first case here and return to that of the superclass constructor after we have talked more about subclassing and inheritance. A constructor can invoke another overloaded constructor in its class using the self-referential method call this()with appropriate arguments to select the desired constructor. If a constructor calls another constructor, it must do so as its first statement:

   

1. class Car {
   
2.         String model;
   
3.         int doors;
   
4. 
   
5.         Car( String model, int doors ) {
   
6.             this.model = model;
   
7.             this.doors = doors;
   
8.             // other, complicated setup
   
9.             ...
   
10.         }
    
11. 
    
12.         Car( String model ) {
    
13.             this( model, 4 /* doors */ );
    
14.         }
    
15.         ...
    
16.     }

复制代码

In this example, the class Car has two constructors. The first, more explicit, one accepts arguments specifying the car’s model and its number of doors. The second constructor takes just the model as an argument and, in turn, calls the first constructor with a default value of four doors. The advantage of this approach is that you can have a single constructor do all the complicated setup work; other auxiliary constructors simply feed the appropriate arguments to that constructor.

The special call to this() must appear as the first statement in our delegating constructor. The syntax is restricted in this way because there’s a need to identify a clear chain of command in the calling of constructors. At the end of the chain, Java invokes the constructor of the superclass (if we don’t do it explicitly) to ensure that inherited members are initialized properly before we proceed.

There’s also a point in the chain, just after invoking the constructor of the superclass, where the initializers of the current class’s instance variables are evaluated. Before that point, we can’t even reference the instance variables of our class. We’ll explain this situation again in complete detail after we have talked about inheritance.

For now, all you need to know is that you can invoke a second constructor (delegate to it) only as the first statement of your constructor. For example, the following code is illegal and causes a compile-time error:

   

1. Car( String m ) {
   
2.         int doors = determineDoors();
   
3.         this( m, doors );   // Error: constructor call
   
4.                             // must be first statement
   
5.     }

复制代码

The simple model name constructor can’t do any additional setup before calling the more explicit constructor. It can’t even refer to an instance member for a constant value:

   

1. class Car {
   
2.         ...
   
3.         final int default_doors = 4;
   
4.         ...
   
5. 
   
6.         Car( String m ) {
   
7.             this( m, default_doors ); // Error: referencing
   
8.                                       // uninitialized variable
   
9.         }
   
10.         ...
    
11.     }

复制代码

The instance variable defaultDoors is not initialized until a later point in the chain of constructor calls setting up the object, so the compiler doesn’t let us access it yet. Fortunately, we can solve this particular problem by using a static variable instead of an instance variable:

   

1. class Car {
   
2.         ...
   
3.         static final int DEFAULT_DOORS = 4;
   
4.         ...
   
5. 
   
6.         Car( String m ) {
   
7.             this( m, DEFAULT_DOORS );  // Okay!
   
8.         }
   
9.         ...
   
10.     }

复制代码

The static members of a class are initialized when the class is first loaded into the virtual machine, so it’s safe to access them in a constructor.

1. //file: ObserveImageLoad.java
   
2.     import java.awt.*;
   
3.     import java.awt.image.*;
   
4. 
   
5.     public class ObserveImageLoad {
   
6. 
   
7.       public static void main( String [] args)
   
8.       {
   
9.        ImageObserver myObserver = new ImageObserver() {
   
10.           public boolean imageUpdate(
    
11.              Image image, int flags, int x, int y, int width, int height)
    
12.           {
    
13.              if ( (flags & HEIGHT) !=0 )
    
14.                System.out.println("Image height = " + height );
    
15.              if ( (flags & WIDTH ) !=0 )
    
16.                System.out.println("Image width = " + width );
    
17.              if ( (flags & FRAMEBITS) != 0 )
    
18.                System.out.println("Another frame finished.");
    
19.              if ( (flags & SOMEBITS) != 0 )
    
20.                 System.out.println("Image section :"
    
21.                     + new Rectangle( x, y, width, height ) );
    
22.              if ( (flags & ALLBITS) != 0 )
    
23.                System.out.println("Image finished!");
    
24.              if ( (flags & ABORT) != 0 )
    
25.                System.out.println("Image load aborted...");
    
26.              return true;
    
27.          }
    
28.        };
    
29. 
    
30.         Toolkit toolkit = Toolkit.getDefaultToolkit();
    
31.         Image img = toolkit.getImage( args[0] );
    
32.         toolkit.prepareImage( img, -1, -1, myObserver );
    
33.       }
    
34.     }

复制代码

1.     public class StatusImage extends JComponent
   
2.     {
   
3.       boolean loaded = false;
   
4.       String message = "Loading...";
   
5.       Image image;
   
6. 
   
7.       public StatusImage( Image image ) { this.image = image; }
   
8. 
   
9.       public void paint(Graphics g) {
   
10.         if (loaded)
    
11.             g.drawImage(image, 0, 0, this);
    
12.         else {
    
13.           g.drawRect(0, 0, getSize().width - 1, getSize().height - 1);
    
14.           g.drawString(message, 20, 20);
    
15.         }
    
16.       }
    
17.       public void loaded() {
    
18.         loaded = true;
    
19.         repaint();
    
20.       }
    
21.       public void setMessage( String msg ) {
    
22.         message = msg;
    
23.         repaint();
    
24.       }
    
25. 
    
26.       public static void main( String [] args ) {
    
27.         JFrame frame = new JFrame("TrackImage");
    
28.         Image image = Toolkit.getDefaultToolkit().getImage( args[0] );
    
29.         StatusImage statusImage = new StatusImage( image );
    
30.         frame.add( statusImage );
    
31.         frame.setSize(300,300);
    
32.         frame.setVisible(true);
    
33. 
    
34.         MediaTracker tracker = new MediaTracker( statusImage );
    
35.         int MAIN_IMAGE = 0;
    
36.         tracker.addImage( image, MAIN_IMAGE );
    
37.         try {
    
38.             tracker.waitForID( MAIN_IMAGE ); }
    
39.         catch (InterruptedException e) {}
    
40.         if ( tracker.isErrorID( MAIN_IMAGE ) )
    
41.             statusImage.setMessage( "Error" );
    
42.         else
    
43.             statusImage.loaded();
    
44.       }
    
45.     }

复制代码

1. Creating an Image
   
2. Let’s take a look at producing some image data. A picture is worth a thousand words, and, fortunately, we can generate a pretty picture in significantly fewer than a thousand words of Java. If we just want to render image frames byte by byte, you can put together a BufferedImage pretty easily.
   
3. 
   
4. The following application, ColorPan, creates an image from an array of integers holding RGB pixel values:
   
5. 
   
6.     //file: ColorPan.java
   
7.     import java.awt.*;
   
8.     import java.awt.image.*;
   
9.     import javax.swing.*;
   
10. 
    
11.     public class ColorPan extends JComponent {
    
12.       BufferedImage image;
    
13. 
    
14.       public void initialize() {
    
15.         int width = getSize().width;
    
16.         int height = getSize().height;
    
17.         int[] data = new int [width * height];
    
18.         int i = 0;
    
19.         for (int y = 0; y < height; y++) {
    
20.           int red = (y * 255) / (height - 1);
    
21.           for (int x = 0; x < width; x++) {
    
22.             int green = (x * 255) / (width - 1);
    
23.             int blue = 128;
    
24.             data[i++] = (red << 16) | (green << 8 ) | blue;
    
25.           }
    
26.         }
    
27.         image = new BufferedImage(width, height,
    
28.             BufferedImage.TYPE_INT_RGB);
    
29.         image.setRGB(0, 0, width, height, data, 0, width);
    
30.       }
    
31. 
    
32.       public void paint(Graphics g) {
    
33.         if (image == null)
    
34.             initialize();
    
35.         g.drawImage(image, 0, 0, this);
    
36.       }
    
37. 
    
38.       public void setBounds(int x, int y, int width, int height) {
    
39.         super.setBounds(x,y,width,height);  
    
40.         initialize();
    
41.       }
    
42. 
    
43.       public static void main(String[] args) {
    
44.         JFrame frame = new JFrame("ColorPan");
    
45.         frame.add(new ColorPan());
    
46.         frame.setSize(300, 300);
    
47.         frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
    
48.         frame.setVisible(true);
    
49.       }
    
50.     }

复制代码

1. //file: StaticGenerator.java
   
2.     import java.awt.*;
   
3.     import java.awt.event.*;
   
4.     import java.awt.image.*;
   
5.     import java.util.Random;
   
6.     import javax.swing.*;
   
7. 
   
8.     public class StaticGenerator extends JComponent implements Runnable {
   
9.       byte[] data;
   
10.       BufferedImage image;
    
11.       Random random;
    
12. 
    
13.       public void initialize() {
    
14.         int w = getSize().width, h = getSize().height;
    
15.         int length = ((w + 7) * h) / 8;
    
16.         data = new byte[length];
    
17.         DataBuffer db = new DataBufferByte(data, length);
    
18.         WritableRaster wr = Raster.createPackedRaster(db, w, h, 1, null);
    
19.         ColorModel cm = new IndexColorModel(1, 2,
    
20.             new byte[] { (byte)0, (byte)255 },
    
21.             new byte[] { (byte)0, (byte)255 },
    
22.             new byte[] { (byte)0, (byte)255 });
    
23.         image = new BufferedImage(cm, wr, false, null);
    
24.         random = new Random();
    
25.       }
    
26. 
    
27.       public void run() {
    
28.         if ( random == null )
    
29.             initialize();
    
30.         while (true) {
    
31.           random.nextBytes(data);
    
32.           repaint();
    
33.           try { Thread.sleep(1000 / 24); }
    
34.           catch( InterruptedException e ) { /* die */ }
    
35.         }
    
36.       }
    
37. 
    
38.       public void paint(Graphics g) {
    
39.         if (image == null) initialize();
    
40.         g.drawImage(image, 0, 0, this);
    
41.       }
    
42. 
    
43.       public void setBounds(int x, int y, int width, int height) {
    
44.         super.setBounds(x,y,width,height);
    
45.         initialize();
    
46.       }
    
47. 
    
48.       public static void main(String[] args) {
    
49.         //RepaintManager.currentManager(null).setDoubleBufferingEnabled(false);
    
50.         JFrame frame = new JFrame("StaticGenerator");
    
51.         StaticGenerator staticGen = new StaticGenerator();
    
52.         frame.add( staticGen );
    
53.         frame.setSize(300, 300);
    
54.         frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
    
55.         frame.setVisible(true);
    
56.         new Thread( staticGen ).start();
    
57.       }
    
58.     }

复制代码