dcwthematicindex.java

openmap java写的开源数字地图程序. 用applet实现,可以像google map 那样放大缩小地图.

// **********************************************************************
// 
// <copyright>
// 
//  BBN Technologies
//  10 Moulton Street
//  Cambridge, MA 02138
//  [phone]
// 
//  Copyright (C) BBNT Solutions LLC. All rights reserved.
// 
// </copyright>
// **********************************************************************
// 
// $Source: /cvs/distapps/openmap/src/openmap/com/bbn/openmap/layer/vpf/DcwThematicIndex.java,v $
// $RCSfile: DcwThematicIndex.java,v $
// $Revision: 1.3.2.2 $
// $Date: 2005/08/09 21:17:52 $
// $Author: dietrick $
// 
// **********************************************************************

package com.bbn.openmap.layer.vpf;

import java.io.IOException;
import java.io.EOFException;
import java.util.*;

import com.bbn.openmap.io.*;
import com.bbn.openmap.util.Debug;

/** Read a VPF thematic index file. (VPF *.?ti files) */
public class DcwThematicIndex {
    /** the file we read from */
    private BinaryFile inputFile = null;
    /** read from file - length of header */
    final private int headerSize;
    /** read from file - number of indexes (codes) */
    final private int numberOfCodes;
    /** read from file - total number of rows indexed */
    final private int numberOfRows;
    /** read from file - type of index */
    final private char typeOfIndex; // T hematic
    /** read from file - field type of index */
    final private char fieldTypeOfIndex;
    /** read from file - number of elements composing the index value */
    final private int numberOfDataElement;
    /** read from file - the type of the index */
    final private char dataTypeSpecifier;
    /** read from file - the table indexed */
    final private String tableIndexed;
    /** read from file - the column indexed */
    final private String columnIndexed;
    /** read from file (vpf 2407 only) - are the codes sorted */
    final private boolean sorted;
    /** the list of index records */
    private IndexRecord[] indexData;
    /** the name of the file being read */
    //     final protected File filename;
    final protected String filename;
    /** the byte order of the file */
    protected boolean byteOrder;

    /**
     * A utility class used to record index records.
     */
    public static class IndexRecord implements Comparable {
        /** the index (code) */
        final Object index;
        /** the offset of the data */
        final int offset;
        /** the number of values - 0 means the offset is the only value */
        final int numvals;

        /**
         * Construct an index record
         * 
         * @param index the index object
         * @param offset the offset of the data
         * @param numvals the number of values
         */
        public IndexRecord(Object index, int offset, int numvals) {
            this.index = index;
            this.offset = offset;
            this.numvals = numvals;
        }

        public int compareTo(Object obj) {
            Object realobj = (obj instanceof IndexRecord) ? ((IndexRecord) obj).index
                    : obj;
            return ((Comparable) index).compareTo(realobj);
        }
    }

    /**
     * Construct an index, assumes this is pre-VPF2407 format.
     * 
     * @param filename the file to oped
     * @param border the byteorder
     */
    public DcwThematicIndex(String filename, boolean border)
            throws FormatException {
        this(filename, border, false);
    }

    /**
     * Construct an index, assumes this is pre-VPF2407 format.
     * 
     * @param filename the file to oped
     * @param border the byteorder
     * @param vpf2407 true for MILSTD-2407 format thematic index.
     *        false will properly read a VPF2407 format index, but
     *        will ignore one header field (sorted). true will
     *        improperly read old-style data.
     */
    public DcwThematicIndex(String filename, boolean border, boolean vpf2407)
            throws FormatException {

        this.filename = filename;
        byteOrder = border;

        reopen(0);

        if (Debug.debugging("vpfserver")) {
            System.out.println("DTI: opened the file " + filename);
        }

        try {
            headerSize = inputFile.readInteger();
            numberOfCodes = inputFile.readInteger();
            numberOfRows = inputFile.readInteger();
            typeOfIndex = inputFile.readChar();
            fieldTypeOfIndex = inputFile.readChar();
            numberOfDataElement = inputFile.readInteger();
            dataTypeSpecifier = inputFile.readChar();
            tableIndexed = trim(inputFile.readFixedLengthString(12)).toLowerCase();
            columnIndexed = trim(inputFile.readFixedLengthString(25)).toLowerCase();
            sorted = (inputFile.readChar() == 'S') && vpf2407;
            inputFile.seek(60); //skips 3 unused bytes

            indexData = new IndexRecord[numberOfCodes];

            if (Debug.debugging("vpfserver")) {
                System.out.println("HeaderSize = " + headerSize);
                System.out.println("Number of Codes = " + numberOfCodes);
                System.out.println("Number of Rows = " + numberOfRows);
                System.out.println("Type of Index = " + typeOfIndex);
                //              if (typeOfIndex != 'T')
                //                  System.out.println(" *** Strange - dcw spec says it
                // will be T ***");
                System.out.println("Field Type of Index = " + fieldTypeOfIndex);
                System.out.println("Number of Data Element = "
                        + numberOfDataElement);
                System.out.println("Data Type Specifier = " + dataTypeSpecifier);
                System.out.println("Table Indexed  = " + tableIndexed);
                System.out.println("Column Indexed = " + columnIndexed);
                System.out.println("Sorted = " + sorted);
            }

            StringBuffer pr = new StringBuffer();
            for (int i = 0; i < numberOfCodes; i++) {
                indexData[i] = new IndexRecord(readIndexField(fieldTypeOfIndex,
                        numberOfDataElement), inputFile.readInteger(), inputFile.readInteger());

                if (Debug.debugging("vpfserver")) {
                    pr = new StringBuffer("i = " + i);
                    pr.append("; val = " + indexData[i].index.toString());
                    pr.append("; offset = " + indexData[i].offset);
                    pr.append("; number of elts = " + indexData[i].numvals);
                    if (i < 40) {
                        System.out.println(pr.toString());
                    }
                }
            }

            if (!sorted) {
                Arrays.sort(indexData);
            }

            if (Debug.debugging("vpfserver") && (numberOfCodes > 40)) {
                System.out.println(pr.toString());
            }

            Debug.message("vpfserver", "*** Finished Header Read ***");

            if (Debug.debugging("vpfserver")) {
                if ((typeOfIndex == 'T') || (typeOfIndex == 'I')) {
                    Debug.output("Normal Inverted Index Format");
                } else if ((typeOfIndex == 'B') || (typeOfIndex == 'G')) {
                    Debug.output("Scary Bitmap Index Format");
                } else {
                    throw new FormatException("Unidentied TMI format");
                }

                Object[] indexes = getValueIndexes();
                // We just know that these values are tile IDs.
                for (int j = 0; j < indexes.length; j++) {
                    // int[] row = get(indexes[j]);
                    // If you want to do some scary printout, code it
                    // up here.
                }
            }
            close();
        } catch (EOFException e) {
            throw new FormatException("Hit Premature EOF in thematic index");
        } catch (IOException i) {
            throw new FormatException("Encountered IO Exception: "
                    + i.getMessage());
        }
    }

    /**
     * Returns the set of values indexed by this thematic index.
     * 
     * @return the set of values indexed
     */
    public Object[] getValueIndexes() {
        Object[] values = null;

        if (indexData != null) {
            values = new Object[indexData.length];

            for (int i = 0; i < indexData.length; i++) {
                values[i] = indexData[i].index;
            }
        }
        return values;
    }

    /**
     * Returns the list of rows listed for this index
     * 
     * @return an array of rows
     * @param valueIndex the value to look up
     */
    public synchronized int[] get(Object valueIndex) throws FormatException {