1101 lines
36 KiB
Java
1101 lines
36 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.
|
|
*/
|
|
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
|
|
* instanties 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 Signals that 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 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 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 Signals that 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 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 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 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");
|
|
}
|
|
}
|