geotiffdirectory.java

来自「OpenMap是一个基于JavaBeansTM的开发工具包。利用OpenMap你」· Java 代码 · 共 363 行

package org.geotiff.image.jai;

import java.util.Iterator;
import java.util.TreeMap;

import org.libtiff.jai.codec.XTIFF;
import org.libtiff.jai.codec.XTIFFDirectory;
import org.libtiff.jai.codec.XTIFFField;

import com.sun.media.jai.codec.SeekableStream;

/**
 * An extension of the XTIFFDirectory that understands the structure of the
 * GeoTIFF key set
 * 
 * @author Niles D. Ritter
 */

public class GeoTIFFDirectory extends XTIFFDirectory implements
        java.io.Serializable {

    private TreeMap geoKeyIndex = new TreeMap();
    private int keyDirectoryVersion;
    private int majorRevision;
    private int minorRevision;
    private int numberOfKeys;
    private double[] tiepoints = null;
    private double[] scales = null;
    private double[] matrix = null;
    private boolean hasGeoKeys = false;

    /**
     * public constructor (for serializability)
     */
    public GeoTIFFDirectory() {}

    /**
     * Constructs a GeoTIFFDirectory by reading a SeekableStream. The ifd_offset
     * parameter specifies the stream offset from which to begin reading; this
     * mechanism is sometimes used to store private IFDs within a TIFF file that
     * are not part of the normal sequence of IFDs.
     */

    public GeoTIFFDirectory(SeekableStream stream, long ifd_offset)
            throws java.io.IOException {
        super(stream, ifd_offset);
        readGeoKeys();
        log("GeoTIFFDirectory constructor success.");
    }

    /**
     * Constructs a GeoTIFFDirectory from a SeekableStream. The directory
     * parameter specifies which directory to read from the linked list present
     * in the stream; directory 0 is normally read but it is possible to store
     * multiple images in a single TIFF file by maintaing multiple directories.
     */

    public GeoTIFFDirectory(SeekableStream stream, int directory)
            throws java.io.IOException {
        super(stream, directory);
        readGeoKeys();
        log("GeoTIFFDirectory constructor success.");
    }

    private void log(String msg) {}

    /**
     * Generates the TIFF fields from the GeoKey list
     */
    private void createGeoTags() {

        if (!hasGeoKeys)
            return;

        char numberOfKeys = (char) geoKeyIndex.size();
        char[] keys = new char[(numberOfKeys + 1) * 4];

        // Write the 4-entry header
        keys[0] = 1; // key version
        keys[1] = 1; // majorRevision
        keys[2] = 0; // minorRevision
        keys[3] = numberOfKeys;

        // Write the key directory out
        Iterator it = geoKeyIndex.values().iterator();
        double[] doubles = new double[numberOfKeys];
        String strings = "";
        int indx = 4;
        char numDoubles = 0;
        char tag = 0;
        char valueOrOffset = 0;
        while (it.hasNext()) {
            XTIFFField geoKey = (XTIFFField) it.next();
            switch (geoKey.getType()) {
            case XTIFFField.TIFF_SHORT:
                // short values are stored in the valueOrOffset
                tag = 0;
                valueOrOffset = (char) geoKey.getAsInt(0);
                break;
            case XTIFFField.TIFF_DOUBLE:
                tag = (char) XTIFF.TIFFTAG_GEO_DOUBLE_PARAMS;
                doubles[numDoubles] = geoKey.getAsDouble(0);
                valueOrOffset = numDoubles++;
                break;
            case XTIFFField.TIFF_ASCII:
                // strings are '|' pipe delimited
                tag = (char) XTIFF.TIFFTAG_GEO_ASCII_PARAMS;
                valueOrOffset = (char) strings.length();
                strings = strings + geoKey.getAsString(0) + "|";
                break;
            } // switch
            keys[indx++] = (char) geoKey.getTag();
            keys[indx++] = tag;
            keys[indx++] = (char) geoKey.getCount();
            keys[indx++] = valueOrOffset;
        } // while

        // Add the Directory tag
        addField(XTIFF.TIFFTAG_GEO_KEY_DIRECTORY,
                XTIFFField.TIFF_SHORT,
                keys.length,
                keys);

        // Add the Ascii tag if needed
        if (strings.length() > 0) {
            char zero = 0;
            strings = strings + zero;
            addField(XTIFF.TIFFTAG_GEO_ASCII_PARAMS,
                    XTIFFField.TIFF_ASCII,
                    strings.length(),
                    new String[] { strings });
        }

        // Add the double tag if needed
        if (numDoubles > 0) {
            double[] doubleVals = new double[numDoubles];
            for (int i = 0; i < numDoubles; i++)
                doubleVals = doubles;
            addField(XTIFF.TIFFTAG_GEO_DOUBLE_PARAMS,
                    XTIFFField.TIFF_DOUBLE,
                    numDoubles,
                    doubleVals);
        }

        // set up the other values stored in tags
        if (matrix != null)
            addField(XTIFF.TIFFTAG_GEO_TRANS_MATRIX,
                    XTIFFField.TIFF_DOUBLE,
                    matrix.length,
                    matrix);
        if (tiepoints != null)
            addField(XTIFF.TIFFTAG_GEO_TIEPOINTS,
                    XTIFFField.TIFF_DOUBLE,
                    tiepoints.length,
                    tiepoints);
        if (scales != null)
            addField(XTIFF.TIFFTAG_GEO_PIXEL_SCALE,
                    XTIFFField.TIFF_DOUBLE,
                    scales.length,
                    scales);
    }

    /**
     * stores a single geoKey in the index table, from the existing field
     * information
     */
    private void storeGeoKey(int keyID, int tiffTag, int valueCount,
                             int valueOrOffset) throws java.io.IOException {
        int type = XTIFFField.TIFF_SHORT;
        Object value = null;
        if (tiffTag > 0) {
            // Values are in another tag:
            XTIFFField values = getField(tiffTag);
            if (values != null) {
                type = values.getType();
                if (type == XTIFFField.TIFF_ASCII) {
                    String svalue = values.getAsString(0)
                            .substring(valueOrOffset,
                                    valueOrOffset + valueCount - 1);
                    value = new String[] { svalue };
                } else if (type == XTIFFField.TIFF_DOUBLE) {
                    // we shouldn't have valueCount != 1 here
                    double dvalue = values.getAsDouble(valueOrOffset);
                    value = new double[] { dvalue };
                }
            } else {
                throw new java.io.IOException("GeoTIFF tag not found");
            } // values tag found
        } else {
            // value is SHORT, stored in valueOrOffset
            type = XTIFFField.TIFF_SHORT;
            value = new char[] { (char) valueOrOffset };
        } // tiffTag
        addGeoKey(keyID, type, valueCount, value);
    }

    /**
     * Returns an array of XTIFFFields containing all the fields in this
     * directory. Prior to returning array, determine if there are any GeoKeys,
     * and if so, set up the corresponding GeoTIFF fields.
     */
    public XTIFFField[] getFields() {
        if (hasGeoKeys)
            createGeoTags();
        return super.getFields();
    }

    /**
     * populates the geoKeyIndex table from the values stored in the current
     * TIFF fields.
     */
    private void readGeoKeys() throws java.io.IOException {

        // read in the keys
        XTIFFField geoKeyTag = getField(XTIFF.TIFFTAG_GEO_KEY_DIRECTORY);
        if (geoKeyTag != null) {
            char[] keys = geoKeyTag.getAsChars();

            // Set up header info
            keyDirectoryVersion = keys[0]; // should be 1 forever.
            majorRevision = keys[1]; // currently 1
            minorRevision = keys[2]; // 0,1, or 2...
            numberOfKeys = keys[3];

            // Parse out keys and values
            for (int i = 4; i < keys.length; i += 4) {
                int keyID = keys[i];
                int tiffTag = keys[i + 1];
                int valueCount = keys[i + 2];
                int valueOrOffset = keys[i + 3];
                storeGeoKey(keyID, tiffTag, valueCount, valueOrOffset);
            }

        }

        // set up the values stored in tags
        // read in the data stored as real tags
        XTIFFField matrixTag = getField(XTIFF.TIFFTAG_GEO_TRANS_MATRIX);
        XTIFFField tiepointTag = getField(XTIFF.TIFFTAG_GEO_TIEPOINTS);
        XTIFFField scaleTag = getField(XTIFF.TIFFTAG_GEO_PIXEL_SCALE);
        if (tiepointTag != null) {
            tiepoints = tiepointTag.getAsDoubles();
        }
        if (scaleTag != null) {
            scales = scaleTag.getAsDoubles();
        }
        if (matrixTag != null) {
            matrix = matrixTag.getAsDoubles();
        }
    } // readGeoKeys

    /**
     * Add a geoKey to the directory
     */
    public void addGeoKey(int key, int type, int count, Object data) {
        XTIFFField geoKey = createField(key, type, count, data);
        addGeoKey(geoKey);
    }

    /**
     * Add an existing geoKey to the directory.
     */
    public void addGeoKey(XTIFFField geoKey) {
        geoKeyIndex.put(new Integer(geoKey.getTag()), geoKey);
        hasGeoKeys = true;
    }

    /**
     * Returns an array of XTIFFFields containing all the fields corresponding
     * to the GeoKeys.
     */
    public XTIFFField[] getGeoKeys() {
        XTIFFField[] keys = new XTIFFField[geoKeyIndex.size()];
        Iterator it = geoKeyIndex.values().iterator();
        int i = 0;
        while (it.hasNext()) {
            keys[i++] = (XTIFFField) it.next();
        }
        return keys;
    }

    /**
     * Indexed Accessor to the Geokeys,indexed by the key values.
     */
    public XTIFFField getGeoKey(int key) {
        return (XTIFFField) geoKeyIndex.get(new Integer(key));
    }

    /**
     * return the tiepoint tag values
     */
    public double[] getTiepoints() {
        return tiepoints;
    }

    /**
     * return the pixel scale tag values
     */
    public double[] getPixelScale() {
        return scales;
    }

    /**
     * return the transformation matrix tag values
     */
    public double[] getTransformationMatrix() {
        return matrix;
    }

    /**
     * set the tiepoint tag values
     */
    public void setTiepoints(double[] tiepoints) {
        this.tiepoints = tiepoints;
    }

    /**
     * return the pixel scale tag values
     */
    public void setPixelScale(double[] scales) {
        this.scales = scales;
    }

    /**
     * return the pixel scale tag values
     */
    public void setTransformationMatrix(double[] matrix) {
        this.matrix = matrix;
    }

    public int getKeyDirectoryVersion() {
        return keyDirectoryVersion;
    }

    public void setKeyDirectoryVersion(int keyDirectoryVersion) {
        this.keyDirectoryVersion = keyDirectoryVersion;
    }

    public int getMajorRevision() {
        return majorRevision;
    }

    public void setMajorRevision(int majorRevision) {
        this.majorRevision = majorRevision;
    }

    public int getMinorRevision() {
        return minorRevision;
    }

    public void setMinorRevision(int minorRevision) {
        this.minorRevision = minorRevision;
    }

    public int getNumberOfKeys() {
        return numberOfKeys;
    }

    public void setNumberOfKeys(int numberOfKeys) {
        this.numberOfKeys = numberOfKeys;
    }
}