1163 lines
37 KiB
Java
1163 lines
37 KiB
Java
/*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership.
|
|
* The ASF licenses this file to You under the Apache License, Version 2.0
|
|
* (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
/**
|
|
* @author Rustem V. Rafikov
|
|
* @version $Revision: 1.3 $
|
|
*/
|
|
|
|
package javax.imageio;
|
|
|
|
import javax.imageio.spi.ImageReaderSpi;
|
|
import javax.imageio.stream.ImageInputStream;
|
|
import javax.imageio.metadata.IIOMetadata;
|
|
import javax.imageio.event.IIOReadWarningListener;
|
|
import javax.imageio.event.IIOReadProgressListener;
|
|
import javax.imageio.event.IIOReadUpdateListener;
|
|
import java.util.Locale;
|
|
import java.util.List;
|
|
import java.util.Iterator;
|
|
import java.util.Set;
|
|
import java.io.IOException;
|
|
import java.awt.image.BufferedImage;
|
|
import java.awt.image.Raster;
|
|
import java.awt.image.RenderedImage;
|
|
import java.awt.*;
|
|
|
|
/**
|
|
* The ImageReader class is an abstract class for decoding images. ImageReader
|
|
* objects are instantiated by the service provider interface, ImageReaderSpi
|
|
* class, for the specific format. ImageReaderSpi class should be registered
|
|
* with the IIORegistry, which uses them for format recognition and presentation
|
|
* of available format readers and writers.
|
|
*
|
|
* @since Android 1.0
|
|
*/
|
|
public abstract class ImageReader {
|
|
|
|
/**
|
|
* The originating provider.
|
|
*/
|
|
protected ImageReaderSpi originatingProvider;
|
|
|
|
/**
|
|
* The input object such as ImageInputStream.
|
|
*/
|
|
protected Object input;
|
|
|
|
/**
|
|
* The seek forward only.
|
|
*/
|
|
protected boolean seekForwardOnly;
|
|
|
|
/**
|
|
* The ignore metadata flag indicates whether current input source has been
|
|
* marked as metadata is allowed to be ignored by setInput.
|
|
*/
|
|
protected boolean ignoreMetadata;
|
|
|
|
/**
|
|
* The minimum index.
|
|
*/
|
|
protected int minIndex;
|
|
|
|
/**
|
|
* The available locales.
|
|
*/
|
|
protected Locale[] availableLocales;
|
|
|
|
/**
|
|
* The locale.
|
|
*/
|
|
protected Locale locale;
|
|
|
|
/**
|
|
* The list of warning listeners.
|
|
*/
|
|
protected List<IIOReadWarningListener> warningListeners;
|
|
|
|
/**
|
|
* The list of warning locales.
|
|
*/
|
|
protected List<Locale> warningLocales;
|
|
|
|
/**
|
|
* The list of progress listeners.
|
|
*/
|
|
protected List<IIOReadProgressListener> progressListeners;
|
|
|
|
/**
|
|
* The list of update listeners.
|
|
*/
|
|
protected List<IIOReadUpdateListener> updateListeners;
|
|
|
|
/**
|
|
* Instantiates a new ImageReader.
|
|
*
|
|
* @param originatingProvider
|
|
* the ImageReaderSpi which instantiates this ImageReader.
|
|
*/
|
|
protected ImageReader(ImageReaderSpi originatingProvider) {
|
|
this.originatingProvider = originatingProvider;
|
|
}
|
|
|
|
/**
|
|
* Gets the format name of this input source.
|
|
*
|
|
* @return the format name of this input source.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public String getFormatName() throws IOException {
|
|
return originatingProvider.getFormatNames()[0];
|
|
}
|
|
|
|
/**
|
|
* Gets the ImageReaderSpi which instantiated this ImageReader.
|
|
*
|
|
* @return the ImageReaderSpi.
|
|
*/
|
|
public ImageReaderSpi getOriginatingProvider() {
|
|
return originatingProvider;
|
|
}
|
|
|
|
/**
|
|
* Sets the specified Object as the input source of this ImageReader.
|
|
*
|
|
* @param input
|
|
* the input source, it can be an ImageInputStream or other
|
|
* supported objects.
|
|
* @param seekForwardOnly
|
|
* indicates whether the stream must be read sequentially from
|
|
* its current starting point.
|
|
* @param ignoreMetadata
|
|
* parameter which indicates if metadata may be ignored during
|
|
* reads or not.
|
|
*/
|
|
public void setInput(Object input, boolean seekForwardOnly, boolean ignoreMetadata) {
|
|
if (input != null) {
|
|
if (!isSupported(input) && !(input instanceof ImageInputStream)) {
|
|
throw new IllegalArgumentException("input " + input + " is not supported");
|
|
}
|
|
}
|
|
this.minIndex = 0;
|
|
this.seekForwardOnly = seekForwardOnly;
|
|
this.ignoreMetadata = ignoreMetadata;
|
|
this.input = input;
|
|
}
|
|
|
|
/**
|
|
* Checks if is supported.
|
|
*
|
|
* @param input
|
|
* the input.
|
|
* @return true, if is supported.
|
|
*/
|
|
private boolean isSupported(Object input) {
|
|
ImageReaderSpi spi = getOriginatingProvider();
|
|
if (null != spi) {
|
|
Class[] outTypes = spi.getInputTypes();
|
|
for (Class<?> element : outTypes) {
|
|
if (element.isInstance(input)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Sets the specified Object as the input source of this ImageReader.
|
|
* Metadata is not ignored.
|
|
*
|
|
* @param input
|
|
* the input source, it can be an ImageInputStream or other
|
|
* supported objects.
|
|
* @param seekForwardOnly
|
|
* indicates whether the stream must be read sequentially from
|
|
* its current starting point.
|
|
*/
|
|
public void setInput(Object input, boolean seekForwardOnly) {
|
|
setInput(input, seekForwardOnly, false);
|
|
}
|
|
|
|
/**
|
|
* Sets the specified Object as the input source of this ImageReader.
|
|
* Metadata is not ignored and forward seeking is not required.
|
|
*
|
|
* @param input
|
|
* the input source, it can be ImageInputStream or other objects.
|
|
*/
|
|
public void setInput(Object input) {
|
|
setInput(input, false, false);
|
|
}
|
|
|
|
/**
|
|
* Gets the input source object of this ImageReader, or returns null.
|
|
*
|
|
* @return the input source object such as ImageInputStream, or null.
|
|
*/
|
|
public Object getInput() {
|
|
return input;
|
|
}
|
|
|
|
/**
|
|
* Checks if the input source supports only forward reading, or not.
|
|
*
|
|
* @return true, if the input source supports only forward reading, false
|
|
* otherwise.
|
|
*/
|
|
public boolean isSeekForwardOnly() {
|
|
return seekForwardOnly;
|
|
}
|
|
|
|
/**
|
|
* Returns true if the current input source allows to metadata to be ignored
|
|
* by passing true as the ignoreMetadata argument to the setInput method.
|
|
*
|
|
* @return true, if the current input source allows to metadata to be
|
|
* ignored by passing true as the ignoreMetadata argument to the
|
|
* setInput method.
|
|
*/
|
|
public boolean isIgnoringMetadata() {
|
|
return ignoreMetadata;
|
|
}
|
|
|
|
/**
|
|
* Gets the minimum valid index for reading an image, thumbnail, or image
|
|
* metadata.
|
|
*
|
|
* @return the minimum valid index for reading an image, thumbnail, or image
|
|
* metadata.
|
|
*/
|
|
public int getMinIndex() {
|
|
return minIndex;
|
|
}
|
|
|
|
/**
|
|
* Gets the available locales.
|
|
*
|
|
* @return an array of the available locales.
|
|
*/
|
|
public Locale[] getAvailableLocales() {
|
|
return availableLocales;
|
|
}
|
|
|
|
/**
|
|
* Sets the locale to this ImageReader.
|
|
*
|
|
* @param locale
|
|
* the Locale.
|
|
*/
|
|
public void setLocale(Locale locale) {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Gets the locale of this ImageReader.
|
|
*
|
|
* @return the locale of this ImageReader.
|
|
*/
|
|
public Locale getLocale() {
|
|
return locale;
|
|
}
|
|
|
|
/**
|
|
* Gets the number of images available in the current input source.
|
|
*
|
|
* @param allowSearch
|
|
* the parameter which indicates what a search is required; if
|
|
* false, the reader may return -1 without searching.
|
|
* @return the number of images.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public abstract int getNumImages(boolean allowSearch) throws IOException;
|
|
|
|
/**
|
|
* Gets the width of the specified image in input source.
|
|
*
|
|
* @param imageIndex
|
|
* the image index.
|
|
* @return the width in pixels.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public abstract int getWidth(int imageIndex) throws IOException;
|
|
|
|
/**
|
|
* Gets the height of the specified image in input source.
|
|
*
|
|
* @param imageIndex
|
|
* the image index.
|
|
* @return the height in pixels.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public abstract int getHeight(int imageIndex) throws IOException;
|
|
|
|
/**
|
|
* Checks if the storage format of the specified image places an impediment
|
|
* on random pixels access or not.
|
|
*
|
|
* @param imageIndex
|
|
* the image's index.
|
|
* @return true, if the storage format of the specified image places an
|
|
* impediment on random pixels access, false otherwise.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public boolean isRandomAccessEasy(int imageIndex) throws IOException {
|
|
return false; // def
|
|
}
|
|
|
|
/**
|
|
* Gets the aspect ratio (width devided by height) of the image.
|
|
*
|
|
* @param imageIndex
|
|
* the image index.
|
|
* @return the aspect ratio of the image.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public float getAspectRatio(int imageIndex) throws IOException {
|
|
return (float)getWidth(imageIndex) / getHeight(imageIndex);
|
|
}
|
|
|
|
/**
|
|
* Gets an ImageTypeSpecifier which indicates the type of the specified
|
|
* image.
|
|
*
|
|
* @param imageIndex
|
|
* the image's index.
|
|
* @return the ImageTypeSpecifier.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public ImageTypeSpecifier getRawImageType(int imageIndex) throws IOException {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Gets an Iterator of ImageTypeSpecifier objects which are associated with
|
|
* image types that may be used when decoding specified image.
|
|
*
|
|
* @param imageIndex
|
|
* the image index.
|
|
* @return an Iterator of ImageTypeSpecifier objects.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public abstract Iterator<ImageTypeSpecifier> getImageTypes(int imageIndex) throws IOException;
|
|
|
|
/**
|
|
* Gets the default ImageReadParam object.
|
|
*
|
|
* @return the ImageReadParam object.
|
|
*/
|
|
public ImageReadParam getDefaultReadParam() {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Gets an IIOMetadata object for this input source.
|
|
*
|
|
* @return the IIOMetadata.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public abstract IIOMetadata getStreamMetadata() throws IOException;
|
|
|
|
/**
|
|
* Gets an IIOMetadata object for this input source.
|
|
*
|
|
* @param formatName
|
|
* the desired metadata format to be used in the returned
|
|
* IIOMetadata object.
|
|
* @param nodeNames
|
|
* the node names of the document.
|
|
* @return the IIOMetadata.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public IIOMetadata getStreamMetadata(String formatName, Set<String> nodeNames)
|
|
throws IOException {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Gets the image metadata of the specified image in input source.
|
|
*
|
|
* @param imageIndex
|
|
* the image index.
|
|
* @return the IIOMetadata.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public abstract IIOMetadata getImageMetadata(int imageIndex) throws IOException;
|
|
|
|
/**
|
|
* Gets the image metadata of the specified image input source.
|
|
*
|
|
* @param imageIndex
|
|
* the image index.
|
|
* @param formatName
|
|
* the desired metadata format to be used in the returned
|
|
* IIOMetadata object.
|
|
* @param nodeNames
|
|
* the node names which can be contained in the document.
|
|
* @return the IIOMetadata.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public IIOMetadata getImageMetadata(int imageIndex, String formatName, Set<String> nodeNames)
|
|
throws IOException {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Reads the specified image and returns it as a BufferedImage using the
|
|
* default ImageReadParam.
|
|
*
|
|
* @param imageIndex
|
|
* the image index.
|
|
* @return the BufferedImage.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public BufferedImage read(int imageIndex) throws IOException {
|
|
return read(imageIndex, null);
|
|
}
|
|
|
|
/**
|
|
* Reads the specified image and returns it as a BufferedImage using the
|
|
* specified ImageReadParam.
|
|
*
|
|
* @param imageIndex
|
|
* the image index.
|
|
* @param param
|
|
* the ImageReadParam.
|
|
* @return the BufferedImage.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public abstract BufferedImage read(int imageIndex, ImageReadParam param) throws IOException;
|
|
|
|
/**
|
|
* Reads the specified image and returns an IIOImage with this image,
|
|
* thumbnails, and metadata for this image, using the specified
|
|
* ImageReadParam.
|
|
*
|
|
* @param imageIndex
|
|
* the image index.
|
|
* @param param
|
|
* the ImageReadParam.
|
|
* @return the IIOImage.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public IIOImage readAll(int imageIndex, ImageReadParam param) throws IOException {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Returns an Iterator of IIOImages from the input source.
|
|
*
|
|
* @param params
|
|
* the Iterator of ImageReadParam objects.
|
|
* @return the iterator of IIOImages.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public Iterator<IIOImage> readAll(Iterator<? extends ImageReadParam> params) throws IOException {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Checks whether or not this plug-in supports reading a Raster.
|
|
*
|
|
* @return true, if this plug-in supports reading a Raster, false otherwise.
|
|
*/
|
|
public boolean canReadRaster() {
|
|
return false; // def
|
|
}
|
|
|
|
/**
|
|
* Reads a new Raster object which contains the raw pixel data from the
|
|
* image.
|
|
*
|
|
* @param imageIndex
|
|
* the image index.
|
|
* @param param
|
|
* the ImageReadParam.
|
|
* @return the Raster.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public Raster readRaster(int imageIndex, ImageReadParam param) throws IOException {
|
|
throw new UnsupportedOperationException("Unsupported");
|
|
}
|
|
|
|
/**
|
|
* Checks if the specified image has tiles or not.
|
|
*
|
|
* @param imageIndex
|
|
* the image's index.
|
|
* @return true, if the specified image has tiles, false otherwise.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public boolean isImageTiled(int imageIndex) throws IOException {
|
|
return false; // def
|
|
}
|
|
|
|
/**
|
|
* Gets the tile width in the specified image.
|
|
*
|
|
* @param imageIndex
|
|
* the image's index.
|
|
* @return the tile width.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public int getTileWidth(int imageIndex) throws IOException {
|
|
return getWidth(imageIndex); // def
|
|
}
|
|
|
|
/**
|
|
* Gets the tile height in the specified image.
|
|
*
|
|
* @param imageIndex
|
|
* the image's index.
|
|
* @return the tile height.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public int getTileHeight(int imageIndex) throws IOException {
|
|
return getHeight(imageIndex); // def
|
|
}
|
|
|
|
/**
|
|
* Gets the X coordinate of the upper left corner of the tile grid in the
|
|
* specified image.
|
|
*
|
|
* @param imageIndex
|
|
* the image's index.
|
|
* @return the X coordinate of the upper left corner of the tile grid.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public int getTileGridXOffset(int imageIndex) throws IOException {
|
|
return 0; // def
|
|
}
|
|
|
|
/**
|
|
* Gets the Y coordinate of the upper left corner of the tile grid in the
|
|
* specified image.
|
|
*
|
|
* @param imageIndex
|
|
* the image's index.
|
|
* @return the Y coordinate of the upper left corner of the tile grid.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public int getTileGridYOffset(int imageIndex) throws IOException {
|
|
return 0; // def
|
|
}
|
|
|
|
/**
|
|
* Reads the tile specified by the tileX and tileY parameters of the
|
|
* specified image and returns it as a BufferedImage.
|
|
*
|
|
* @param imageIndex
|
|
* the image index.
|
|
* @param tileX
|
|
* the X index of tile.
|
|
* @param tileY
|
|
* the Y index of tile.
|
|
* @return the BufferedImage.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public BufferedImage readTile(int imageIndex, int tileX, int tileY) throws IOException {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Reads the tile specified by the tileX and tileY parameters of the
|
|
* specified image and returns it as a Raster.
|
|
*
|
|
* @param imageIndex
|
|
* the image index.
|
|
* @param tileX
|
|
* the X index of tile.
|
|
* @param tileY
|
|
* the Y index of tile.
|
|
* @return the Raster.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public Raster readTileRaster(int imageIndex, int tileX, int tileY) throws IOException {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Reads the specified image using the specified ImageReadParam and returns
|
|
* it as a RenderedImage.
|
|
*
|
|
* @param imageIndex
|
|
* the image index.
|
|
* @param param
|
|
* the ImageReadParam.
|
|
* @return the RenderedImage.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public RenderedImage readAsRenderedImage(int imageIndex, ImageReadParam param)
|
|
throws IOException {
|
|
return read(imageIndex, param);
|
|
}
|
|
|
|
/**
|
|
* Returns true if the image format supported by this reader supports
|
|
* thumbnail preview images.
|
|
*
|
|
* @return true, if the image format supported by this reader supports
|
|
* thumbnail preview images, false otherwise.
|
|
*/
|
|
public boolean readerSupportsThumbnails() {
|
|
return false; // def
|
|
}
|
|
|
|
/**
|
|
* Checks if the specified image has thumbnails or not.
|
|
*
|
|
* @param imageIndex
|
|
* the image's index.
|
|
* @return true, if the specified image has thumbnails, false otherwise.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public boolean hasThumbnails(int imageIndex) throws IOException {
|
|
return getNumThumbnails(imageIndex) > 0; // def
|
|
}
|
|
|
|
/**
|
|
* Gets the number of thumbnails for the specified image.
|
|
*
|
|
* @param imageIndex
|
|
* the image's index.
|
|
* @return the number of thumbnails.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public int getNumThumbnails(int imageIndex) throws IOException {
|
|
return 0; // def
|
|
}
|
|
|
|
/**
|
|
* Gets the width of the specified thumbnail for the specified image.
|
|
*
|
|
* @param imageIndex
|
|
* the image's index.
|
|
* @param thumbnailIndex
|
|
* the thumbnail's index.
|
|
* @return the thumbnail width.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public int getThumbnailWidth(int imageIndex, int thumbnailIndex) throws IOException {
|
|
return readThumbnail(imageIndex, thumbnailIndex).getWidth(); // def
|
|
}
|
|
|
|
/**
|
|
* Gets the height of the specified thumbnail for the specified image.
|
|
*
|
|
* @param imageIndex
|
|
* the image's index.
|
|
* @param thumbnailIndex
|
|
* the thumbnail's index.
|
|
* @return the thumbnail height.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public int getThumbnailHeight(int imageIndex, int thumbnailIndex) throws IOException {
|
|
return readThumbnail(imageIndex, thumbnailIndex).getHeight(); // def
|
|
}
|
|
|
|
/**
|
|
* Reads the thumbnail image for the specified image as a BufferedImage.
|
|
*
|
|
* @param imageIndex
|
|
* the image index.
|
|
* @param thumbnailIndex
|
|
* the thumbnail index.
|
|
* @return the BufferedImage.
|
|
* @throws IOException
|
|
* if an I/O exception has occurred.
|
|
*/
|
|
public BufferedImage readThumbnail(int imageIndex, int thumbnailIndex) throws IOException {
|
|
throw new UnsupportedOperationException("Unsupported"); // def
|
|
}
|
|
|
|
/**
|
|
* Requests an abort operation for current reading operation.
|
|
*/
|
|
public void abort() {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Checks whether or not a request to abort the current read operation has
|
|
* been made successfully.
|
|
*
|
|
* @return true, if the request to abort the current read operation has been
|
|
* made successfully, false otherwise.
|
|
*/
|
|
protected boolean abortRequested() {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Clears all previous abort request, and abortRequested returns false after
|
|
* calling this method.
|
|
*/
|
|
protected void clearAbortRequest() {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Adds the IIOReadWarningListener.
|
|
*
|
|
* @param listener
|
|
* the IIOReadWarningListener.
|
|
*/
|
|
public void addIIOReadWarningListener(IIOReadWarningListener listener) {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Removes the specified IIOReadWarningListener.
|
|
*
|
|
* @param listener
|
|
* the IIOReadWarningListener to be removed.
|
|
*/
|
|
public void removeIIOReadWarningListener(IIOReadWarningListener listener) {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Removes all registered IIOReadWarningListeners.
|
|
*/
|
|
public void removeAllIIOReadWarningListeners() {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Adds the IIOReadProgressListener.
|
|
*
|
|
* @param listener
|
|
* the IIOReadProgressListener.
|
|
*/
|
|
public void addIIOReadProgressListener(IIOReadProgressListener listener) {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Removes the specified IIOReadProgressListener.
|
|
*
|
|
* @param listener
|
|
* the IIOReadProgressListener to be removed.
|
|
*/
|
|
public void removeIIOReadProgressListener(IIOReadProgressListener listener) {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Removes registered IIOReadProgressListeners.
|
|
*/
|
|
public void removeAllIIOReadProgressListeners() {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Adds the IIOReadUpdateListener.
|
|
*
|
|
* @param listener
|
|
* the IIOReadUpdateListener.
|
|
*/
|
|
public void addIIOReadUpdateListener(IIOReadUpdateListener listener) {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Removes the specified IIOReadUpdateListener.
|
|
*
|
|
* @param listener
|
|
* the IIOReadUpdateListener to be removed.
|
|
*/
|
|
public void removeIIOReadUpdateListener(IIOReadUpdateListener listener) {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Removes registered IIOReadUpdateListeners.
|
|
*/
|
|
public void removeAllIIOReadUpdateListeners() {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Processes the start of an sequence of image reads by calling the
|
|
* sequenceStarted method on all registered IIOReadProgressListeners.
|
|
*
|
|
* @param minIndex
|
|
* the minimum index.
|
|
*/
|
|
protected void processSequenceStarted(int minIndex) {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Processes the completion of an sequence of image reads by calling
|
|
* sequenceComplete method on all registered IIOReadProgressListeners.
|
|
*/
|
|
protected void processSequenceComplete() {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Processes the start of an image read by calling the imageStarted method
|
|
* on all registered IIOReadProgressListeners.
|
|
*
|
|
* @param imageIndex
|
|
* the image index.
|
|
*/
|
|
protected void processImageStarted(int imageIndex) {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Processes the current percentage of image completion by calling the
|
|
* imageProgress method on all registered IIOReadProgressListeners.
|
|
*
|
|
* @param percentageDone
|
|
* the percentage done.
|
|
*/
|
|
protected void processImageProgress(float percentageDone) {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Processes image completion by calling the imageComplete method on all
|
|
* registered IIOReadProgressListeners.
|
|
*/
|
|
protected void processImageComplete() {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Processes the start of a thumbnail read by calling the thumbnailStarted
|
|
* method on all registered IIOReadProgressListeners.
|
|
*
|
|
* @param imageIndex
|
|
* the image index.
|
|
* @param thumbnailIndex
|
|
* the thumbnail index.
|
|
*/
|
|
protected void processThumbnailStarted(int imageIndex, int thumbnailIndex) {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Processes the current percentage of thumbnail completion by calling the
|
|
* thumbnailProgress method on all registered IIOReadProgressListeners.
|
|
*
|
|
* @param percentageDone
|
|
* the percentage done.
|
|
*/
|
|
protected void processThumbnailProgress(float percentageDone) {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Processes the completion of a thumbnail read by calling the
|
|
* thumbnailComplete method on all registered IIOReadProgressListeners.
|
|
*/
|
|
protected void processThumbnailComplete() {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Processes a read aborted event by calling the readAborted method on all
|
|
* registered IIOReadProgressListeners.
|
|
*/
|
|
protected void processReadAborted() {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Processes the beginning of a progressive pass by calling the passStarted
|
|
* method on all registered IIOReadUpdateListeners.
|
|
*
|
|
* @param theImage
|
|
* the image to be updated.
|
|
* @param pass
|
|
* the current pass index.
|
|
* @param minPass
|
|
* the minimum pass index.
|
|
* @param maxPass
|
|
* the maximum pass index.
|
|
* @param minX
|
|
* the X coordinate of of the upper left pixel.
|
|
* @param minY
|
|
* the Y coordinate of of the upper left pixel.
|
|
* @param periodX
|
|
* the horizontal separation between pixels.
|
|
* @param periodY
|
|
* the vertical separation between pixels.
|
|
* @param bands
|
|
* the number of affected bands.
|
|
*/
|
|
protected void processPassStarted(BufferedImage theImage, int pass, int minPass, int maxPass,
|
|
int minX, int minY, int periodX, int periodY, int[] bands) {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Processes the update of a set of samples by calling the imageUpdate
|
|
* method on all registered IIOReadUpdateListeners.
|
|
*
|
|
* @param theImage
|
|
* the image to be updated.
|
|
* @param minX
|
|
* the X coordinate of the upper left pixel.
|
|
* @param minY
|
|
* the Y coordinate of the upper left pixel.
|
|
* @param width
|
|
* the width of updated area.
|
|
* @param height
|
|
* the height of updated area.
|
|
* @param periodX
|
|
* the horizontal separation between pixels.
|
|
* @param periodY
|
|
* the vertical separation between pixels.
|
|
* @param bands
|
|
* the number of affected bands.
|
|
*/
|
|
protected void processImageUpdate(BufferedImage theImage, int minX, int minY, int width,
|
|
int height, int periodX, int periodY, int[] bands) {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Processes the end of a progressive pass by calling passComplete method of
|
|
* registered IIOReadUpdateListeners.
|
|
*
|
|
* @param theImage
|
|
* the image to be updated.
|
|
*/
|
|
protected void processPassComplete(BufferedImage theImage) {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Processes the beginning of a thumbnail progressive pass by calling the
|
|
* thumbnailPassStarted method on all registered IIOReadUpdateListeners.
|
|
*
|
|
* @param theThumbnail
|
|
* the thumbnail to be updated.
|
|
* @param pass
|
|
* the current pass index.
|
|
* @param minPass
|
|
* the minimum pass index.
|
|
* @param maxPass
|
|
* the maximum pass index.
|
|
* @param minX
|
|
* the X coordinate of the upper left pixel.
|
|
* @param minY
|
|
* the Y coordinate of the upper left pixel.
|
|
* @param periodX
|
|
* the horizontal separation between pixels.
|
|
* @param periodY
|
|
* the vertical separation between pixels.
|
|
* @param bands
|
|
* the number of affected bands.
|
|
*/
|
|
protected void processThumbnailPassStarted(BufferedImage theThumbnail, int pass, int minPass,
|
|
int maxPass, int minX, int minY, int periodX, int periodY, int[] bands) {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Processes the update of a set of samples in a thumbnail image by calling
|
|
* the thumbnailUpdate method on all registered IIOReadUpdateListeners.
|
|
*
|
|
* @param theThumbnail
|
|
* the thumbnail to be updated.
|
|
* @param minX
|
|
* the X coordinate of the upper left pixel.
|
|
* @param minY
|
|
* the Y coordinate of the upper left pixel.
|
|
* @param width
|
|
* the total width of the updated area.
|
|
* @param height
|
|
* the total height of the updated area.
|
|
* @param periodX
|
|
* the horizontal separation between pixels.
|
|
* @param periodY
|
|
* the vertical separation between pixels.
|
|
* @param bands
|
|
* the number of affected bands.
|
|
*/
|
|
protected void processThumbnailUpdate(BufferedImage theThumbnail, int minX, int minY,
|
|
int width, int height, int periodX, int periodY, int[] bands) {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Processes the end of a thumbnail progressive pass by calling the
|
|
* thumbnailPassComplete method on all registered IIOReadUpdateListeners.
|
|
*
|
|
* @param theThumbnail
|
|
* the thumbnail to be updated.
|
|
*/
|
|
protected void processThumbnailPassComplete(BufferedImage theThumbnail) {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Processes a warning message by calling warningOccurred method of
|
|
* registered IIOReadWarningListeners.
|
|
*
|
|
* @param warning
|
|
* the warning.
|
|
*/
|
|
protected void processWarningOccurred(String warning) {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Processes a warning by calling the warningOccurred method of on all
|
|
* registered IIOReadWarningListeners.
|
|
*
|
|
* @param baseName
|
|
* the base name of ResourceBundles.
|
|
* @param keyword
|
|
* the keyword to index the warning among ResourceBundles.
|
|
*/
|
|
protected void processWarningOccurred(String baseName, String keyword) {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Resets this ImageReader.
|
|
*/
|
|
public void reset() {
|
|
// def
|
|
setInput(null, false);
|
|
setLocale(null);
|
|
removeAllIIOReadUpdateListeners();
|
|
removeAllIIOReadWarningListeners();
|
|
removeAllIIOReadProgressListeners();
|
|
clearAbortRequest();
|
|
}
|
|
|
|
/**
|
|
* Disposes of any resources.
|
|
*/
|
|
public void dispose() {
|
|
// do nothing by def
|
|
}
|
|
|
|
/**
|
|
* Gets the region of source image that should be read with the specified
|
|
* width, height and ImageReadParam.
|
|
*
|
|
* @param param
|
|
* the ImageReadParam object, or null.
|
|
* @param srcWidth
|
|
* the source image's width.
|
|
* @param srcHeight
|
|
* the source image's height.
|
|
* @return the Rectangle of source region.
|
|
*/
|
|
protected static Rectangle getSourceRegion(ImageReadParam param, int srcWidth, int srcHeight) {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Computes the specified source region and the specified destination region
|
|
* with the specified the width and height of the source image, an optional
|
|
* destination image, and an ImageReadParam.
|
|
*
|
|
* @param param
|
|
* the an ImageReadParam object, or null.
|
|
* @param srcWidth
|
|
* the source image's width.
|
|
* @param srcHeight
|
|
* the source image's height.
|
|
* @param image
|
|
* the destination image.
|
|
* @param srcRegion
|
|
* the source region.
|
|
* @param destRegion
|
|
* the destination region.
|
|
*/
|
|
protected static void computeRegions(ImageReadParam param, int srcWidth, int srcHeight,
|
|
BufferedImage image, Rectangle srcRegion, Rectangle destRegion) {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Checks the validity of the source and destination band and is called when
|
|
* the reader knows the number of bands of the source image and the number
|
|
* of bands of the destination image.
|
|
*
|
|
* @param param
|
|
* the ImageReadParam for reading the Image.
|
|
* @param numSrcBands
|
|
* the number of bands in the source.
|
|
* @param numDstBands
|
|
* the number of bands in the destination.
|
|
*/
|
|
protected static void checkReadParamBandSettings(ImageReadParam param, int numSrcBands,
|
|
int numDstBands) {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
|
|
/**
|
|
* Gets the destination image where the decoded data is written.
|
|
*
|
|
* @param param
|
|
* the ImageReadParam.
|
|
* @param imageTypes
|
|
* the iterator of ImageTypeSpecifier objects.
|
|
* @param width
|
|
* the width of the image being decoded.
|
|
* @param height
|
|
* the height of the image being decoded.
|
|
* @return the BufferedImage where decoded pixels should be written.
|
|
* @throws IIOException
|
|
* the IIOException is thrown if there is no suitable
|
|
* ImageTypeSpecifier.
|
|
*/
|
|
protected static BufferedImage getDestination(ImageReadParam param,
|
|
Iterator<ImageTypeSpecifier> imageTypes, int width, int height) throws IIOException {
|
|
throw new UnsupportedOperationException("Not implemented yet");
|
|
}
|
|
}
|