lecture08 reading and writing images in java. imaging models of java push imaging model immediate...
Post on 19-Dec-2015
231 views
TRANSCRIPT
Lecture08Lecture08
Reading and Writing Images Reading and Writing Images in Javain Java
Imaging Models of Java
Push Imaging Model Immediate Mode Imaging Model Pull Imaging Model. This is fully
implemented in Java Advanced Imaging API. Some parts of this could be seen in java.awt.
Push Imaging Model
In push imaging model the image data isn’t introduced into the imaging pipeline until it is needed; at which time an object called ImageProducer starts pushing the data into this pipeline. On the other end of this pipeline is an ImageConsumer that must wait for the data to get pushed to it. This model was designed to provide a simple way to load images into applets and applications.
Push Imaging Model
Advantages• It can load and display images
incrementally as they become available. Disadvantages
• The image data isn’t collected into an accessible location, making anything more than simple image processing difficult.
• The programming interface can be confusing.
The Image Class
It is better to think of the java.awt.image class as a group of resources and methods that provide a means for transferring and inquiring about a collection of image data and not as the collection itself.
Image rendering situations in java
In an applet:// ...URL url;// ...Image img = getImage(url); // first step// ...public void paint(Graphics g) {
// ...g.drawImage(img, 0, 0, this); // second step// ...
}// ...
Image rendering situations in java
In an application:// ...Image img = Toolkit.getDefaultToolkit().getImage(filename);
// ...public void paint(Graphics g) {
// ...g.drawImage(img, 0, 0, this); // second step// ...
}// ...
In both cases, the initial step doesn’t start loading the image data, but instead instantiates an Image object that creates the resources necessary to process the image data.
The second method begins image loading, although the method returns immediately regardless of how much of the image is available to display.
The actual loading continues in a separate thread, where an object implementing the java.awt.ImageProducer interface sends image data to an object implementing the java.awt.ImageConsumer interface.
While ImageProducer sends image data into the ImageComsumer, the ImageObserver interface asynchronously receives the status information about the image transfer.
Image rendering situations in java
ImageObserver interface This status information is passed to the
ImageObserver interface via the method:public boolean imageUpdate(Image img, int
infoFlags, int x, int y,int width, int height)
of the ImageObserver class. Remember the Component class and any
decendent of it such as the Applet class, is an ImageObserver.
The default behaviour of the Applet’s imageUpdate method is to repaint the applet whenever new data bits are available.
Introduction to Image I/O API Java Image I/O package was created to
overcome the limitations of reading/writing of formatted images of then Java APIs. Now Java image I/O API is integrated with the core java language. Two useful properties of Java image I/O API:• Plug-ins: The run time Java Vitual Machine
(JVM) discovers which image readers/writers are available and what types of image formats they can decode/encode.
• Metadata: The non-pixel information about the input images and output images.
Supported FormatsSupported Formats
ReadersReaders• GIFGIF• JPEGJPEG• PNGPNG
WritersWriters• JPEGJPEG• PNGPNG
Image Readers
With the Java2D package, the input images are converted to Image objects using the getImage methods of the Applet class and the Toolkit class.
With Image I/O package, input images are converted to BufferedImages using the read methods of the javax.imageio.ImageReader class.
Generally you have more than one ImageReader subclasses.
javax.imageio.ImageReaderSpis
The initial step in reading an image is to choose an ImageReader that can decode the format of the image of interest. This is done by providing information about that image’s format to a set of ImageReader service providers javax.imageio.ImageReaderSpis. This information can be:• Image file suffix• Image MIME type• Image format• Image data
MIME type Multipurpose Internet Mail Extensions. Examples:
Extension Type Usejpg image/jpeg JPEG imagejpeg image/jpeg JPEG imagempg video/mpeg MPEG videoau audio/basic ULAW audio dataavi video/x-msvideo Microsoft video
For details check http://www.iana.org/assignments/media-types/
Reading and Writing Basics One of the ImageReaders whose service provider
responds positively will be choosen to convert the image into a BufferedImage.
While some ImageReaders are part of Java SDK, the rest can be downloaded from third party vendors, freeware, and shareware sites.
If no appropriate ImageReader available, then one can be written.
The process of writing images is simmilar and has the corresponding classes ImageWriters and javax.imageio.ImageWriterSpis.
ImageIO class
The ImageIO class contains static methods that are mainly used for locating ImageReaders and ImageWriters. To find out plugins by format names, you can use: static String[] getReaderFormatNames()
static String[] getWriterFormatNames() To find out plugins by MIME types:
static String[] getReaderMIMETypes()
static String[] getWriterMIMETypes()
ImageIO class In order to find out ImageReaders for a
particular image the following static methods of ImageIO class can be used:static Iterator getImageReadersByFormatName(String
formatName)static Iterator getImageReadersByMIMEType(String
MIMEType)static Iterator getImageReadersBySuffix(String fileSuffix)
The following method find ImageReaders by examining the object representing the image input stream ( of the class javax.imageio.stream.ImageInputStream):static Iterator getImageReaders(Object input)
ImageInputStream The ImageInputStreams can be created as follows:
URL url = new URL(imageURL);ImageInputStream iis = ImageIO.createImageInputStream(url.openStream());orSocket s = new Socket(imageHost, imagePort);ImageInputStream iis = ImageIO.createImageInputStream(s.getInputStream());orFileInputStream fis = new FileInputStream(imageFileName);ImageInputStream iis = ImageIO.createImageInputStream(fis);
Note that the most image formats begin with something called a magic number, which is the part of ImageInputStream that most ImageReaderSpis use to decide whether they can decode an image format.
ImageWriter
For a known ImageWriter the corresponding ImageReaders can be found by:static ImageReader getImageReader(ImageWriter writer)
The corresponding ImageWriter static methods of ImageIO are:static Iterator getImageWritersByFormatName(String
formatName)static Iterator getImageWritersByMIMEType(String
MIMEType)static Iterator getImageWritersBySuffix(String fileSuffix)static Iterator getImageWriters(ImageTypeSpecifier type,
string format)static ImageWriter getImageWriter(ImageReader reader)• The javax.imageio.ImageTypeSpecifier is a class that specifies
ColorModel/SampleModel combination.
Using The ImageReader An application need to do two things in order to
interact with an ImageReader:• provide it with an input source• Use it to read the source image(s)
The following method of ImageReader is used to provide it with an input source:public void setInput(Object input, boolean
seekForwardOnly)where input is usually an ImageInputStream and seekForwardOnly parameter is used to specify whether an application can go backwards in the input stream.
Using The ImageReader Once an input source is defined either of
the following methods can be used to read images:
public void read(int imageIndex)public void read(int imageIndex,
ImageReadParam param)
where imageIndex is the index of the image that will be read and param parameter provides control over how this image is to be read.
Using The ImageReader The number of images can be obtained using
the method:
public int getNumImages(boolean allowSearch)
where the allowSearch parameter specifies whether you want the entire ImageInputStream examined to determine the number of available images. If allowSearch parameter is false, the number of images is returned only if it is immediately available otherwise -1 is returned.
ExampleURL url;
try { url = new URL(inputURL);}catch (MalformedURLException mue) { // Process the exception}ImageInputStream iis;try { iis = ImageIO.createImageInputStream(url.openStream());}catch (IIOException iioe) { // Process the exception}catch (IOException ioe) { // Process the exception}
ExampleExample
Iterator readers = ImageIO.getImageReaders(iis);
ImageReader reader;if (readers.hasNext()) {
reader = (ImageReader) readers.next();reader.setInput(iis,true);
}if (reader == null) {
// Process the error message}
ExampleExampleBufferedImage bi;int imageIndex = 0;try {
while (bi = reader.read(imageIndex++)) {// process bi here
}}catch (IOException ioe) {
// Process the exception}catch (IndexOutOfBoundsException iobe) { /* all the images
have been read */ }// ...
Using The ImageWriter As with ImageReader, an application does
two things when interacting with an ImageWrier:• provide it with an output source• Use it to write the image(s) into the output
source The setOutput method of ImageWriter is
used to define an output source: public void setOutput(Object output)
where output is typically an ImageOutputStream
ImageOutputStream
Socket s = new Socket(imageHost, imagePort);ImageOutputStream ios =
ImageIO.createImageOutputStream(s.getOutputStream());
orFileOutputStream fos = new
FileOutputStream(imageFileName);ImageOutputStream ios =
ImageIO.createOutputStream(fos);
Using WritersUsing WritersThe main write method is:
public void write(IIOMetadata streamMetadata,IIOImage iioImage,ImageWriteParam param)
where streamMetadata can be set to null, if there is no stream metadata. javax.imageio.IIOImage is a container class used for holding the following information:• The image• The image’s associated thumbnail images, represented as
java.util.List of BufferedImages. If the image format does not support thumbnail images this can be
set to null.• The image’s metadata. If the image format does not support
metadata this can be set to null.
Simple Image Reading
The ImageIO class has the following methods:• public static BufferedImage read(File input)
throws IIOException• public static BufferedImage read(URL input)
throws IIOException• public static BufferedImage
read(InputStream stream) throws IIOException
• public static BufferedImage read(ImageInputStream stream) throws
IIOException
Example: Reading an Image
public static BufferedImage readAsBufferedImage(String filename) {try {
BufferedImage img = ImageIO.read(new File(filename));
return img;} catch (Exception e) {
e.printStackTrace();return null;
}}
Simple Image Writing
The ImageIO has following methods.public static boolean write(RenderedImage im,
String formatName,File output) throws IIOException
public static boolean write(RenderedImage im, String formatName,
OutputStream output) throws IIOException
public ststic boolean write(RenderedImage im, String formatname
ImageOutputStream output) throws IIOException
Example: Writing an Image
public void save(BufferedImage image, String filename) {try {
ImageIO.write((RenderedImage) image,"jpg", new File(filename));} catch (exception e) {
// Process the exception }
}