TIFFField.java
上传用户:btjssb159
上传日期:2018-01-04
资源大小:241k
文件大小:15k
源码类别:

DNA

开发平台:

Java

  1. /*
  2.  * Copyright (c) 2001 Sun Microsystems, Inc. All Rights Reserved.
  3.  *
  4.  * Redistribution and use in source and binary forms, with or without 
  5.  * modification, are permitted provided that the following conditions are met:
  6.  * 
  7.  * -Redistributions of source code must retain the above copyright notice, this 
  8.  * list of conditions and the following disclaimer.
  9.  *
  10.  * -Redistribution in binary form must reproduct the above copyright notice,
  11.  * this list of conditions and the following disclaimer in the documentation
  12.  * and/or other materials provided with the distribution.
  13.  * 
  14.  * Neither the name of Sun Microsystems, Inc. or the names of contributors may
  15.  * be used to endorse or promote products derived from this software without
  16.  * specific prior written permission.
  17.  * 
  18.  * This software is provided "AS IS," without a warranty of any kind. ALL
  19.  * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
  20.  * IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
  21.  * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE
  22.  * LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
  23.  * OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS
  24.  * LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT,
  25.  * INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
  26.  * CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF
  27.  * OR INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE
  28.  * POSSIBILITY OF SUCH DAMAGES.
  29.  * 
  30.  * You acknowledge that Software is not designed,licensed or intended for use in 
  31.  * the design, construction, operation or maintenance of any nuclear facility.
  32.  */
  33. import java.io.Serializable;
  34. /**
  35.  * A class representing a field in a TIFF 6.0 Image File Directory.
  36.  *
  37.  * <p> The TIFF file format is described in more detail in the
  38.  * comments for the TIFFDescriptor class.
  39.  *
  40.  * <p> A field in a TIFF Image File Directory (IFD).  A field is defined
  41.  * as a sequence of values of identical data type.  TIFF 6.0 defines
  42.  * 12 data types, which are mapped internally onto the Java datatypes
  43.  * byte, int, long, float, and double.
  44.  *
  45.  * <p><b> This class is not a committed part of the JAI API.  It may
  46.  * be removed or changed in future releases of JAI.</b>
  47.  *
  48.  * @see javax.media.jai.operator.TIFFDescriptor
  49.  * @see TIFFDirectory
  50.  */
  51. public class TIFFField extends Object implements Comparable, Serializable {
  52.     /** Flag for 8 bit unsigned integers. */
  53.     public static final int TIFF_BYTE      =  1;
  54.     /** Flag for null-terminated ASCII strings. */
  55.     public static final int TIFF_ASCII     =  2;
  56.     /** Flag for 16 bit unsigned integers. */
  57.     public static final int TIFF_SHORT     =  3;
  58.     /** Flag for 32 bit unsigned integers. */
  59.     public static final int TIFF_LONG      =  4;
  60.     /** Flag for pairs of 32 bit unsigned integers. */
  61.     public static final int TIFF_RATIONAL  =  5;
  62.     /** Flag for 8 bit signed integers. */
  63.     public static final int TIFF_SBYTE     =  6;
  64.     /** Flag for 8 bit uninterpreted bytes. */
  65.     public static final int TIFF_UNDEFINED =  7;
  66.     /** Flag for 16 bit signed integers. */
  67.     public static final int TIFF_SSHORT    =  8;
  68.     /** Flag for 32 bit signed integers. */
  69.     public static final int TIFF_SLONG     =  9;
  70.     /** Flag for pairs of 32 bit signed integers. */
  71.     public static final int TIFF_SRATIONAL = 10;
  72.     /** Flag for 32 bit IEEE floats. */
  73.     public static final int TIFF_FLOAT     = 11;
  74.     /** Flag for 64 bit IEEE doubles. */
  75.     public static final int TIFF_DOUBLE    = 12;
  76.     /** The tag number. */
  77.     int tag;
  78.     /** The tag type. */
  79.     int type;
  80.     /** The number of data items present in the field. */
  81.     int count;
  82.     /** The field data. */
  83.     Object data;
  84.     
  85.     /** The default constructor. */
  86.     TIFFField() {}
  87.     /**
  88.      * Constructs a TIFFField with arbitrary data.  The data
  89.      * parameter must be an array of a Java type appropriate for the
  90.      * type of the TIFF field.  Since there is no available 32-bit
  91.      * unsigned datatype, long is used. The mapping between types is
  92.      * as follows:
  93.      *
  94.      * <table border=1>
  95.      * <tr>
  96.      * <th> TIFF type </th> <th> Java type </th>
  97.      * <tr>
  98.      * <td><tt>TIFF_BYTE</tt></td>      <td><tt>byte</tt></td>
  99.      * <tr>
  100.      * <td><tt>TIFF_ASCII</tt></td>     <td><tt>String</tt></td>
  101.      * <tr>
  102.      * <td><tt>TIFF_SHORT</tt></td>     <td><tt>char</tt></td>
  103.      * <tr>
  104.      * <td><tt>TIFF_LONG</tt></td>      <td><tt>long</tt></td>
  105.      * <tr>
  106.      * <td><tt>TIFF_RATIONAL</tt></td>  <td><tt>long[2]</tt></td>
  107.      * <tr>
  108.      * <td><tt>TIFF_SBYTE</tt></td>     <td><tt>byte</tt></td>
  109.      * <tr>
  110.      * <td><tt>TIFF_UNDEFINED</tt></td> <td><tt>byte</tt></td>
  111.      * <tr>
  112.      * <td><tt>TIFF_SSHORT</tt></td>    <td><tt>short</tt></td>
  113.      * <tr>
  114.      * <td><tt>TIFF_SLONG</tt></td>     <td><tt>int</tt></td>
  115.      * <tr>
  116.      * <td><tt>TIFF_SRATIONAL</tt></td> <td><tt>int[2]</tt></td>
  117.      * <tr>
  118.      * <td><tt>TIFF_FLOAT</tt></td>     <td><tt>float</tt></td>
  119.      * <tr>
  120.      * <td><tt>TIFF_DOUBLE</tt></td>    <td><tt>double</tt></td>
  121.      * </table>
  122.      */
  123.     public TIFFField(int tag, int type, int count, Object data) {
  124.         this.tag = tag;
  125.         this.type = type;
  126.         this.count = count;
  127.         this.data = data;
  128.     }
  129.     /**
  130.      * Returns the tag number, between 0 and 65535.
  131.      */
  132.     public int getTag() {
  133.         return tag;
  134.     }
  135.     /**
  136.      * Returns the type of the data stored in the IFD.
  137.      * For a TIFF6.0 file, the value will equal one of the
  138.      * TIFF_ constants defined in this class.  For future
  139.      * revisions of TIFF, higher values are possible.
  140.      *
  141.      */
  142.     public int getType() {
  143.         return type;
  144.     }
  145.     /**
  146.      * Returns the number of elements in the IFD.
  147.      */
  148.     public int getCount() {
  149.         return count;
  150.     }
  151.     /**
  152.      * Returns the data as an uninterpreted array of bytes.
  153.      * The type of the field must be one of TIFF_BYTE, TIFF_SBYTE,
  154.      * or TIFF_UNDEFINED;
  155.      *
  156.      * <p> For data in TIFF_BYTE format, the application must take
  157.      * care when promoting the data to longer integral types
  158.      * to avoid sign extension.
  159.      *
  160.      * <p> A ClassCastException will be thrown if the field is not
  161.      * of type TIFF_BYTE, TIFF_SBYTE, or TIFF_UNDEFINED.
  162.      */
  163.     public byte[] getAsBytes() {
  164.         return (byte[])data;
  165.     }
  166.     /**
  167.      * Returns TIFF_SHORT data as an array of chars (unsigned 16-bit
  168.      * integers).
  169.      *
  170.      * <p> A ClassCastException will be thrown if the field is not
  171.      * of type TIFF_SHORT.
  172.      */
  173.     public char[] getAsChars() {
  174.         return (char[])data;
  175.     }
  176.     /**
  177.      * Returns TIFF_SSHORT data as an array of shorts (signed 16-bit
  178.      * integers).
  179.      *
  180.      * <p> A ClassCastException will be thrown if the field is not
  181.      * of type TIFF_SSHORT.
  182.      */
  183.     public short[] getAsShorts() {
  184.         return (short[])data;
  185.     }
  186.     /**
  187.      * Returns TIFF_SLONG data as an array of ints (signed 32-bit
  188.      * integers).
  189.      *
  190.      * <p> A ClassCastException will be thrown if the field is not
  191.      * of type TIFF_SLONG.
  192.      */
  193.     public int[] getAsInts() {
  194.         return (int[])data;
  195.     }
  196.     /**
  197.      * Returns TIFF_LONG data as an array of longs (signed 64-bit
  198.      * integers).
  199.      *
  200.      * <p> A ClassCastException will be thrown if the field is not
  201.      * of type TIFF_LONG.
  202.      */
  203.     public long[] getAsLongs() {
  204.         return (long[])data;
  205.     }
  206.     /**
  207.      * Returns TIFF_FLOAT data as an array of floats. 
  208.      *
  209.      * <p> A ClassCastException will be thrown if the field is not
  210.      * of type TIFF_FLOAT.
  211.      */
  212.     public float[] getAsFloats() {
  213.         return (float[])data;
  214.     }
  215.     /**
  216.      * Returns TIFF_DOUBLE data as an array of doubles. 
  217.      *
  218.      * <p> A ClassCastException will be thrown if the field is not
  219.      * of type TIFF_DOUBLE.
  220.      */
  221.     public double[] getAsDoubles() {
  222.         return (double[])data;
  223.     }
  224.     /**
  225.      * Returns TIFF_SRATIONAL data as an array of 2-element arrays of ints.
  226.      *
  227.      * <p> A ClassCastException will be thrown if the field is not
  228.      * of type TIFF_SRATIONAL.
  229.      */
  230.     public int[][] getAsSRationals() {
  231.         return (int[][])data;
  232.     }
  233.     /**
  234.      * Returns TIFF_RATIONAL data as an array of 2-element arrays of longs.
  235.      *
  236.      * <p> A ClassCastException will be thrown if the field is not
  237.      * of type TIFF_RATTIONAL.
  238.      */
  239.     public long[][] getAsRationals() {
  240.         return (long[][])data;
  241.     }
  242.     /**
  243.      * Returns data in TIFF_BYTE, TIFF_SBYTE, TIFF_UNDEFINED, TIFF_SHORT,
  244.      * TIFF_SSHORT, or TIFF_SLONG format as an int.
  245.      *
  246.      * <p> TIFF_BYTE and TIFF_UNDEFINED data are treated as unsigned;
  247.      * that is, no sign extension will take place and the returned
  248.      * value will be in the range [0, 255].  TIFF_SBYTE data will
  249.      * be returned in the range [-128, 127].
  250.      *
  251.      * <p> A ClassCastException will be thrown if the field is not of
  252.      * type TIFF_BYTE, TIFF_SBYTE, TIFF_UNDEFINED, TIFF_SHORT,
  253.      * TIFF_SSHORT, or TIFF_SLONG.
  254.      */
  255.     public int getAsInt(int index) {
  256.         switch (type) {
  257.         case TIFF_BYTE: case TIFF_UNDEFINED:
  258.             return ((byte[])data)[index] & 0xff;
  259.         case TIFF_SBYTE:
  260.             return ((byte[])data)[index];
  261.         case TIFF_SHORT:
  262.             return ((char[])data)[index] & 0xffff;
  263.         case TIFF_SSHORT:
  264.             return ((short[])data)[index];
  265.         case TIFF_SLONG:
  266.             return ((int[])data)[index];
  267.         default:
  268.             throw new ClassCastException();
  269.         }
  270.     }
  271.     /**
  272.      * Returns data in TIFF_BYTE, TIFF_SBYTE, TIFF_UNDEFINED, TIFF_SHORT,
  273.      * TIFF_SSHORT, TIFF_SLONG, or TIFF_LONG format as a long.
  274.      *
  275.      * <p> TIFF_BYTE and TIFF_UNDEFINED data are treated as unsigned;
  276.      * that is, no sign extension will take place and the returned
  277.      * value will be in the range [0, 255].  TIFF_SBYTE data will
  278.      * be returned in the range [-128, 127].
  279.      *
  280.      * <p> A ClassCastException will be thrown if the field is not of
  281.      * type TIFF_BYTE, TIFF_SBYTE, TIFF_UNDEFINED, TIFF_SHORT,
  282.      * TIFF_SSHORT, TIFF_SLONG, or TIFF_LONG.
  283.      */
  284.     public long getAsLong(int index) {
  285.         switch (type) {
  286.         case TIFF_BYTE: case TIFF_UNDEFINED:
  287.             return ((byte[])data)[index] & 0xff;
  288.         case TIFF_SBYTE:
  289.             return ((byte[])data)[index];
  290.         case TIFF_SHORT:
  291.             return ((char[])data)[index] & 0xffff;
  292.         case TIFF_SSHORT:
  293.             return ((short[])data)[index];
  294.         case TIFF_SLONG:
  295.             return ((int[])data)[index];
  296.         case TIFF_LONG:
  297.             return ((long[])data)[index];
  298.         default:
  299.             throw new ClassCastException();
  300.         }
  301.     }
  302.     
  303.     /**
  304.      * Returns data in any numerical format as a float.  Data in
  305.      * TIFF_SRATIONAL or TIFF_RATIONAL format are evaluated by
  306.      * dividing the numerator into the denominator using
  307.      * double-precision arithmetic and then truncating to single
  308.      * precision.  Data in TIFF_SLONG, TIFF_LONG, or TIFF_DOUBLE
  309.      * format may suffer from truncation.
  310.      *
  311.      * <p> A ClassCastException will be thrown if the field is
  312.      * of type TIFF_UNDEFINED or TIFF_ASCII.
  313.      */
  314.     public float getAsFloat(int index) {
  315.         switch (type) {
  316.         case TIFF_BYTE:
  317.             return ((byte[])data)[index] & 0xff;
  318.         case TIFF_SBYTE:
  319.             return ((byte[])data)[index];
  320.         case TIFF_SHORT:
  321.             return ((char[])data)[index] & 0xffff;
  322.         case TIFF_SSHORT:
  323.             return ((short[])data)[index];
  324.         case TIFF_SLONG:
  325.             return ((int[])data)[index];
  326.         case TIFF_LONG:
  327.             return ((long[])data)[index];
  328.         case TIFF_FLOAT:
  329.             return ((float[])data)[index];
  330.         case TIFF_DOUBLE:
  331.             return (float)((double[])data)[index];
  332.         case TIFF_SRATIONAL:
  333.             int[] ivalue = getAsSRational(index);
  334.             return (float)((double)ivalue[0]/ivalue[1]);
  335.         case TIFF_RATIONAL:
  336.             long[] lvalue = getAsRational(index);
  337.             return (float)((double)lvalue[0]/lvalue[1]);
  338.         default:
  339.             throw new ClassCastException();
  340.         }
  341.     }
  342.     /**
  343.      * Returns data in any numerical format as a float.  Data in
  344.      * TIFF_SRATIONAL or TIFF_RATIONAL format are evaluated by
  345.      * dividing the numerator into the denominator using
  346.      * double-precision arithmetic.
  347.      *
  348.      * <p> A ClassCastException will be thrown if the field is of
  349.      * type TIFF_UNDEFINED or TIFF_ASCII.
  350.      */
  351.     public double getAsDouble(int index) {
  352.         switch (type) {
  353.         case TIFF_BYTE:
  354.             return ((byte[])data)[index] & 0xff;
  355.         case TIFF_SBYTE:
  356.             return ((byte[])data)[index];
  357.         case TIFF_SHORT:
  358.             return ((char[])data)[index] & 0xffff;
  359.         case TIFF_SSHORT:
  360.             return ((short[])data)[index];
  361.         case TIFF_SLONG:
  362.             return ((int[])data)[index];
  363.         case TIFF_LONG:
  364.             return ((long[])data)[index];
  365.         case TIFF_FLOAT:
  366.             return ((float[])data)[index];
  367.         case TIFF_DOUBLE:
  368.             return ((double[])data)[index];
  369.         case TIFF_SRATIONAL:
  370.             int[] ivalue = getAsSRational(index);
  371.             return (double)ivalue[0]/ivalue[1];
  372.         case TIFF_RATIONAL:
  373.             long[] lvalue = getAsRational(index);
  374.             return (double)lvalue[0]/lvalue[1];
  375.         default:
  376.             throw new ClassCastException();
  377.         }
  378.     }
  379.     /**
  380.      * Returns a TIFF_ASCII data item as a String.
  381.      *
  382.      * <p> A ClassCastException will be thrown if the field is not
  383.      * of type TIFF_ASCII.
  384.      */
  385.     public String getAsString(int index) {
  386.         return ((String[])data)[index];
  387.     }
  388.     /**
  389.      * Returns a TIFF_SRATIONAL data item as a two-element array
  390.      * of ints.
  391.      *
  392.      * <p> A ClassCastException will be thrown if the field is not
  393.      * of type TIFF_SRATIONAL.
  394.      */
  395.     public int[] getAsSRational(int index) {
  396.         return ((int[][])data)[index];
  397.     }
  398.     /**
  399.      * Returns a TIFF_RATIONAL data item as a two-element array
  400.      * of ints.
  401.      *
  402.      * <p> A ClassCastException will be thrown if the field is not
  403.      * of type TIFF_RATIONAL.
  404.      */
  405.     public long[] getAsRational(int index) {
  406.         return ((long[][])data)[index];
  407.     }
  408.     /**
  409.      * Compares this <code>TIFFField</code> with another
  410.      * <code>TIFFField</code> by comparing the tags.
  411.      *
  412.      * <p><b>Note: this class has a natural ordering that is inconsistent
  413.      * with <code>equals()</code>.</b>
  414.      *
  415.      * @throws IllegalArgumentException if the parameter is <code>null</code>.
  416.      * @throws ClassCastException if the parameter is not a
  417.      *         <code>TIFFField</code>.
  418.      */
  419.     public int compareTo(Object o) {
  420.         if(o == null) {
  421.             throw new IllegalArgumentException();
  422.         }
  423.         int oTag = ((TIFFField)o).getTag();
  424.         if(tag < oTag) {
  425.             return -1;
  426.         } else if(tag > oTag) {
  427.             return 1;
  428.         } else {
  429.             return 0;
  430.         }
  431.     }
  432. }