Metadata Management

/**
 * TIFF image-level metadata container with standard format support
 */
class TIFFImageMetadata extends IIOMetadata {
    
    /** Scale factor used for rational values in metadata */
    public static final int RATIONAL_SCALE_FACTOR = 100000;
    
    /**
     * Create empty metadata instance
     */
    public TIFFImageMetadata();
    
    /**
     * Create metadata from TIFF Image File Directory (IFD)
     * @param ifd Directory containing TIFF tags and values
     */
    public TIFFImageMetadata(Directory ifd);
    
    /**
     * Create metadata from collection of entries
     * @param entries Collection of metadata entries
     */
    public TIFFImageMetadata(Collection<? extends Entry> entries);
    
    /**
     * Check if metadata is read-only
     * @return true if metadata cannot be modified
     */
    public boolean isReadOnly();
    
    /**
     * Set metadata from XML DOM tree
     * @param formatName metadata format name
     * @param root root node of DOM tree
     */
    public void setFromTree(String formatName, Node root);
    
    /**
     * Merge metadata from XML DOM tree
     * @param formatName metadata format name  
     * @param root root node of DOM tree to merge
     */
    public void mergeTree(String formatName, Node root);
    
    /**
     * Reset metadata to original state
     */
    public void reset();
    
    /**
     * Get TIFF field by tag number
     * @param tagNumber TIFF tag number (e.g., 256 for ImageWidth)
     * @return Object containing tag value, or null if not present
     */
    public Object getTIFFField(int tagNumber);
}

import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
import javax.imageio.metadata.IIOMetadata;
import com.twelvemonkeys.imageio.plugins.tiff.TIFFImageMetadata;
import java.io.File;

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

TIFFImageMetadata metadata = (TIFFImageMetadata) reader.getImageMetadata(0);

// Get specific TIFF tags
Integer width = (Integer) metadata.getTIFFField(256);      // ImageWidth
Integer height = (Integer) metadata.getTIFFField(257);     // ImageLength  
Integer compression = (Integer) metadata.getTIFFField(259); // Compression
String software = (String) metadata.getTIFFField(305);     // Software

System.out.println("Image: " + width + "x" + height);
System.out.println("Compression: " + compression);
System.out.println("Created with: " + software);

// Get metadata as XML tree
Node tree = metadata.getAsTree(TIFFImageMetadataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME);

reader.dispose();

// Creating custom metadata for writing
TIFFImageMetadata customMetadata = new TIFFImageMetadata();

// Set metadata values (using XML tree manipulation)
IIOMetadataNode root = new IIOMetadataNode(TIFFImageMetadataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME);
IIOMetadataNode softwareNode = new IIOMetadataNode("Software");
softwareNode.setAttribute("value", "My Application v1.0");
root.appendChild(softwareNode);

customMetadata.setFromTree(TIFFImageMetadataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME, root);

/**
 * TIFF stream-level metadata (byte order configuration)
 */
class TIFFStreamMetadata extends IIOMetadata {
    
    /** Standard stream metadata format name */
    public static final String SUN_NATIVE_STREAM_METADATA_FORMAT_NAME = 
        "com_sun_media_imageio_plugins_tiff_stream_1.0";
    
    /**
     * Create stream metadata with default big-endian byte order
     */
    public TIFFStreamMetadata();
    
    /**
     * Check if metadata is read-only (always returns false)
     * @return false - stream metadata is writable
     */
    public boolean isReadOnly();
    
    /**
     * Get metadata as XML DOM tree
     * @param formatName metadata format name
     * @return Node representing the metadata tree
     */
    public Node getAsTree(String formatName);
    
    /**
     * Merge metadata from XML DOM tree
     * @param formatName metadata format name
     * @param root root node of tree to merge
     */
    public void mergeTree(String formatName, Node root);
    
    /**
     * Reset metadata to default state
     */
    public void reset();
    
    /**
     * Configure stream byte order based on metadata and output stream
     * @param streamMetadata stream metadata containing byte order information
     * @param imageOutput target image output stream
     */
    public static void configureStreamByteOrder(IIOMetadata streamMetadata, ImageOutputStream imageOutput);
}

import javax.imageio.ImageWriter;
import com.twelvemonkeys.imageio.plugins.tiff.TIFFStreamMetadata;

// Creating stream metadata for writing
ImageWriter writer = ImageIO.getImageWritersByFormatName("TIFF").next();
TIFFStreamMetadata streamMetadata = (TIFFStreamMetadata) writer.getDefaultStreamMetadata(null);

// Get stream metadata as XML tree
Node streamTree = streamMetadata.getAsTree(TIFFStreamMetadata.SUN_NATIVE_STREAM_METADATA_FORMAT_NAME);

// Use stream metadata when writing
writer.write(streamMetadata, new IIOImage(image, null, imageMetadata), writeParam);

/**
 * Metadata format descriptor for TIFF image metadata
 */
class TIFFImageMetadataFormat extends IIOMetadataFormatImpl {
    
    /** Standard image metadata format name */
    public static final String SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME = 
        "com_sun_media_imageio_plugins_tiff_image_1.0";
    
    /**
     * Constructor for metadata format
     */
    public TIFFImageMetadataFormat();
    
    /**
     * Check if a node can appear for the specified image type
     * @param elementName name of the XML element
     * @param imageType image type specifier
     * @return true if node is valid for the image type
     */
    public boolean canNodeAppear(String elementName, ImageTypeSpecifier imageType);
    
    /**
     * Get singleton instance of the format descriptor
     * @return singleton TIFFImageMetadataFormat instance
     */
    public static TIFFImageMetadataFormat getInstance();
}

/**
 * Metadata format descriptor for TIFF stream metadata
 */
class TIFFStreamMetadataFormat extends IIOMetadataFormatImpl {
    
    /** Standard stream metadata format name */
    public static final String SUN_NATIVE_STREAM_METADATA_FORMAT_NAME = 
        "com_sun_media_imageio_plugins_tiff_stream_1.0";
    
    /**
     * Get singleton instance of the format descriptor
     * @return singleton TIFFStreamMetadataFormat instance
     */
    public static TIFFStreamMetadataFormat getInstance();
}

/**
 * Alternative metadata format for compatibility
 */
class TIFFMedataFormat extends IIOMetadataFormatImpl {
    
    /** References the image metadata format name */
    public static final String SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME = 
        TIFFImageMetadataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME;
    
    /**
     * Get singleton instance of the format descriptor
     * @return singleton TIFFMedataFormat instance
     */
    public static TIFFMedataFormat getInstance();
}

// Reading image with metadata preservation
ImageReader reader = ImageIO.getImageReadersByFormatName("TIFF").next();
reader.setInput(ImageIO.createImageInputStream(new File("input.tiff")));

BufferedImage image = reader.read(0);
TIFFImageMetadata originalMetadata = (TIFFImageMetadata) reader.getImageMetadata(0);
reader.dispose();

// Writing image with preserved metadata
ImageWriter writer = ImageIO.getImageWritersByFormatName("TIFF").next();
writer.setOutput(ImageIO.createImageOutputStream(new File("output.tiff")));

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