Image Operations

/**
 * Main TIFF/BigTIFF image reader with comprehensive format support
 */
class TIFFImageReader extends ImageReader {
    /**
     * Get the number of images in the TIFF file
     * @param allowSearch whether to search the entire file if necessary
     * @return number of images/pages in the file
     */
    public int getNumImages(boolean allowSearch);
    
    /**
     * Get the width of the specified image
     * @param imageIndex zero-based image index
     * @return image width in pixels
     */
    public int getWidth(int imageIndex);
    
    /**
     * Get the height of the specified image  
     * @param imageIndex zero-based image index
     * @return image height in pixels
     */
    public int getHeight(int imageIndex);
    
    /**
     * Get the raw image type specifier for the image
     * @param imageIndex zero-based image index
     * @return ImageTypeSpecifier representing the raw image format
     */
    public ImageTypeSpecifier getRawImageType(int imageIndex);
    
    /**
     * Get all supported image types for reading
     * @param imageIndex zero-based image index
     * @return Iterator of supported ImageTypeSpecifier objects
     */
    public Iterator<ImageTypeSpecifier> getImageTypes(int imageIndex);
    
    /**
     * Read the specified image as a BufferedImage
     * @param imageIndex zero-based image index
     * @param param read parameters (can be null)
     * @return BufferedImage containing the image data
     */
    public BufferedImage read(int imageIndex, ImageReadParam param);
    
    /**
     * Check if raster reading is supported (always returns true)
     * @return true - raster reading is supported
     */
    public boolean canReadRaster();
    
    /**
     * Read the specified image as a Raster
     * @param imageIndex zero-based image index  
     * @param param read parameters (can be null)
     * @return Raster containing the raw image data
     */
    public Raster readRaster(int imageIndex, ImageReadParam param);
    
    /**
     * Check if the image uses tiling
     * @param imageIndex zero-based image index
     * @return true if the image is tiled
     */
    public boolean isImageTiled(int imageIndex);
    
    /**
     * Get tile width for tiled images
     * @param imageIndex zero-based image index
     * @return tile width in pixels
     */
    public int getTileWidth(int imageIndex);
    
    /**
     * Get tile height for tiled images
     * @param imageIndex zero-based image index
     * @return tile height in pixels
     */
    public int getTileHeight(int imageIndex);
    
    /**
     * Read a specific tile as BufferedImage
     * @param imageIndex zero-based image index
     * @param tileX tile X coordinate
     * @param tileY tile Y coordinate
     * @return BufferedImage containing the tile data
     */
    public BufferedImage readTile(int imageIndex, int tileX, int tileY);
    
    /**
     * Read a specific tile as Raster
     * @param imageIndex zero-based image index
     * @param tileX tile X coordinate
     * @param tileY tile Y coordinate
     * @return Raster containing the tile data
     */
    public Raster readTileRaster(int imageIndex, int tileX, int tileY);
    
    /**
     * Get TIFF-specific image metadata
     * @param imageIndex zero-based image index
     * @return TIFFImageMetadata containing TIFF tags and metadata
     */
    public IIOMetadata getImageMetadata(int imageIndex);
    
    /**
     * Get TIFF-specific stream metadata
     * @return TIFFStreamMetadata containing stream-level metadata
     */
    public IIOMetadata getStreamMetadata();
}

import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
import java.awt.image.BufferedImage;
import java.io.File;

// Reading a single TIFF image
BufferedImage image = ImageIO.read(new File("example.tiff"));

// Reading multi-page TIFF with explicit reader
ImageReader reader = ImageIO.getImageReadersByFormatName("TIFF").next();
reader.setInput(ImageIO.createImageInputStream(new File("multipage.tiff")));

int numImages = reader.getNumImages(true);
System.out.println("Found " + numImages + " pages");

for (int i = 0; i < numImages; i++) {
    BufferedImage page = reader.read(i);
    System.out.println("Page " + i + ": " + page.getWidth() + "x" + page.getHeight());
}

reader.dispose();

// Reading tiled TIFF
reader = ImageIO.getImageReadersByFormatName("TIFF").next();
reader.setInput(ImageIO.createImageInputStream(new File("tiled.tiff")));

if (reader.isImageTiled(0)) {
    int tileWidth = reader.getTileWidth(0);
    int tileHeight = reader.getTileHeight(0);
    BufferedImage firstTile = reader.readTile(0, 0, 0);
}

reader.dispose();

/**
 * Main TIFF/BigTIFF image writer with multi-page support
 */
class TIFFImageWriter extends ImageWriter {
    /**
     * Set the output destination for writing
     * @param output ImageOutputStream, File, or other supported output
     */
    public void setOutput(Object output);
    
    /**
     * Write a single image with optional metadata
     * @param streamMetadata stream-level metadata (can be null)
     * @param image IIOImage containing image data and metadata
     * @param param write parameters for compression settings
     */
    public void write(IIOMetadata streamMetadata, IIOImage image, ImageWriteParam param);
    
    /**
     * Get default image metadata for the specified image type
     * @param imageType image type specifier
     * @param param write parameters
     * @return default TIFFImageMetadata instance
     */
    public IIOMetadata getDefaultImageMetadata(ImageTypeSpecifier imageType, ImageWriteParam param);
    
    /**
     * Convert metadata from another format to TIFF format
     * @param inData input metadata
     * @param imageType target image type
     * @param param write parameters
     * @return converted TIFFImageMetadata
     */
    public IIOMetadata convertImageMetadata(IIOMetadata inData, ImageTypeSpecifier imageType, ImageWriteParam param);
    
    /**
     * Get default stream metadata
     * @param param write parameters
     * @return default TIFFStreamMetadata instance
     */
    public IIOMetadata getDefaultStreamMetadata(ImageWriteParam param);
    
    /**
     * Convert stream metadata to TIFF format
     * @param inData input stream metadata
     * @param param write parameters
     * @return converted TIFFStreamMetadata
     */
    public IIOMetadata convertStreamMetadata(IIOMetadata inData, ImageWriteParam param);
    
    /**
     * Get default write parameters (returns TIFFImageWriteParam)
     * @return TIFFImageWriteParam with default settings
     */
    public ImageWriteParam getDefaultWriteParam();
    
    /**
     * Check if sequence writing is supported (always returns true)
     * @return true - multi-page writing is supported
     */
    public boolean canWriteSequence();
    
    /**
     * Prepare for writing a multi-page document
     * @param streamMetadata stream metadata for the document
     */
    public void prepareWriteSequence(IIOMetadata streamMetadata);
    
    /**
     * Write a page to the multi-page sequence
     * @param image IIOImage containing page data and metadata
     * @param param write parameters
     */
    public void writeToSequence(IIOImage image, ImageWriteParam param);
    
    /**
     * Finish writing the multi-page document
     */
    public void endWriteSequence();
}

import javax.imageio.ImageIO;
import javax.imageio.ImageWriter;
import javax.imageio.IIOImage;
import com.twelvemonkeys.imageio.plugins.tiff.TIFFImageWriteParam;
import java.awt.image.BufferedImage;
import java.io.File;

// Writing a single TIFF image
BufferedImage image = // ... create or load image
ImageIO.write(image, "TIFF", new File("output.tiff"));

// Writing with compression
ImageWriter writer = ImageIO.getImageWritersByFormatName("TIFF").next();
writer.setOutput(ImageIO.createImageOutputStream(new File("compressed.tiff")));

TIFFImageWriteParam writeParam = (TIFFImageWriteParam) writer.getDefaultWriteParam();
writeParam.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
writeParam.setCompressionType("LZW");

writer.write(null, new IIOImage(image, null, null), writeParam);
writer.dispose();

// Writing multi-page TIFF
writer = ImageIO.getImageWritersByFormatName("TIFF").next();
writer.setOutput(ImageIO.createImageOutputStream(new File("multipage.tiff")));

writer.prepareWriteSequence(null);

BufferedImage[] pages = // ... array of images
for (BufferedImage page : pages) {
    writer.writeToSequence(new IIOImage(page, null, null), writeParam);
}

writer.endWriteSequence();
writer.dispose();

/**
 * Standard TIFF image reading service provider
 */
class TIFFImageReaderSpi extends ImageReaderSpi {
    public TIFFImageReaderSpi();
    
    /**
     * Test if the input source contains TIFF format data
     * @param source input source (ImageInputStream, File, etc.)
     * @return true if source contains TIFF data
     */
    public boolean canDecodeInput(Object source);
    
    /**
     * Create a new TIFFImageReader instance
     * @param extension optional extension object
     * @return new TIFFImageReader instance
     */
    public ImageReader createReaderInstance(Object extension);
    
    /**
     * Get human-readable description of the provider
     * @param locale locale for localization
     * @return description string
     */
    public String getDescription(Locale locale);
}

/**
 * Standard TIFF image writing service provider
 */
class TIFFImageWriterSpi extends ImageWriterSpi {
    public TIFFImageWriterSpi();
    
    /**
     * Test if the image type can be encoded to TIFF
     * @param type image type specifier
     * @return true if type can be encoded
     */
    public boolean canEncodeImage(ImageTypeSpecifier type);
    
    /**
     * Create a new TIFFImageWriter instance
     * @param extension optional extension object  
     * @return new TIFFImageWriter instance
     */
    public ImageWriter createWriterInstance(Object extension);
    
    /**
     * Get human-readable description of the provider
     * @param locale locale for localization
     * @return description string
     */
    public String getDescription(Locale locale);
}

/**
 * BigTIFF format reading service provider (for files >4GB)
 */
class BigTIFFImageReaderSpi extends ImageReaderSpi {
    public BigTIFFImageReaderSpi();
    
    /**
     * Test if the input source contains BigTIFF format data
     * @param source input source
     * @return true if source contains BigTIFF data
     */
    public boolean canDecodeInput(Object source);
    
    /**
     * Create a new TIFFImageReader instance for BigTIFF
     * @param extension optional extension object
     * @return new TIFFImageReader instance
     */
    public ImageReader createReaderInstance(Object extension);
    
    /**
     * Get human-readable description of the provider
     * @param locale locale for localization
     * @return description string
     */
    public String getDescription(Locale locale);
}

/**
 * BigTIFF format writing service provider
 */
class BigTIFFImageWriterSpi extends ImageWriterSpi {
    public BigTIFFImageWriterSpi();
    
    /**
     * Test if the image type can be encoded to BigTIFF
     * @param type image type specifier
     * @return true if type can be encoded
     */
    public boolean canEncodeImage(ImageTypeSpecifier type);
    
    /**
     * Create a new TIFFImageWriter instance for BigTIFF
     * @param extension optional extension object
     * @return new TIFFImageWriter instance
     */
    public ImageWriter createWriterInstance(Object extension);
    
    /**
     * Get human-readable description of the provider
     * @param locale locale for localization
     * @return description string
     */
    public String getDescription(Locale locale);
}