| /* |
| * 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"); |
| } |
| } |