diff options
Diffstat (limited to 'awt/javax/imageio/ImageReader.java')
| -rw-r--r-- | awt/javax/imageio/ImageReader.java | 1100 |
1 files changed, 1100 insertions, 0 deletions
diff --git a/awt/javax/imageio/ImageReader.java b/awt/javax/imageio/ImageReader.java new file mode 100644 index 0000000..780de26 --- /dev/null +++ b/awt/javax/imageio/ImageReader.java @@ -0,0 +1,1100 @@ +/* + * 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"); + } +} |