shapefile.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/shape/ShapeFile.java,v $
// $RCSfile: ShapeFile.java,v $
// $Revision: 1.2.2.2 $
// $Date: 2005/08/09 21:17:47 $
// $Author: dietrick $
// 
// **********************************************************************

package com.bbn.openmap.layer.shape;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.Vector;

import com.bbn.openmap.util.Debug;

/**
 * Class representing an ESRI Shape File.
 * <p>
 * <H2>Usage:</H2>
 * <DT>java com.bbn.openmap.layer.shape.ShapeFile -v shapeFile</DT>
 * <DD>Verifies a shape file.</DD>
 * <p>
 * <DT>java com.bbn.openmap.layer.shape.ShapeFile -a destShapeFile
 * srcShapeFile</DT>
 * <DD>Appends records from srcShapeFile to destShapeFile.</DD>
 * <p>
 * <DT>java com.bbn.openmap.layer.shape.ShapeFile shapeFile</DT>
 * <DD>Prints information about the header and the number of records.
 * </DD>
 * <p>
 * 
 * @author Tom Mitchell <[e-mail]>
 * @author Ray Tomlinson
 * @author Geoffrey Knauth
 * @version $Revision: 1.2.2.2 $ $Date: 2005/08/09 21:17:47 $
 */
public class ShapeFile extends ShapeUtils {

    /** A Shape File's magic number. */
    public static final int SHAPE_FILE_CODE = 9994;

    /** The currently handled version of Shape Files. */
    public static final int SHAPE_FILE_VERSION = 1000;

    /** A default record size. Automatically increased on demand. */
    public static final int DEFAULT_RECORD_BUFFER_SIZE = 50000;

    /** The read/write class for shape files. */
    protected RandomAccessFile raf;

    /** The buffer that holds the 100 byte header. */
    protected byte header[];

    /** Holds the length of the file, in bytes. */
    protected long fileLength;

    /** Holds the version of the file, as an int. */
    protected int fileVersion;

    /** Holds the shape type of the file. */
    protected int fileShapeType;

    /** Holds the bounds of the file (four doubles). */
    protected ESRIBoundingBox fileBounds;

    /** A buffer for current record's header. */
    protected byte recHdr[];

    /** A buffer for the current record's data. */
    protected byte recBuf[];

    /**
     * Construct a <code>ShapeFile</code> from a file name.
     * 
     * @exception IOException if something goes wrong opening or
     *            reading the file.
     */
    public ShapeFile(String name) throws IOException {
        raf = new RandomAccessFile(name, "rw");
        recHdr = new byte[ShapeUtils.SHAPE_FILE_RECORD_HEADER_LENGTH];
        recBuf = new byte[DEFAULT_RECORD_BUFFER_SIZE];
        initHeader();
    }

    /**
     * Construct a <code>ShapeFile</code> from the given
     * <code>File</code>.
     * 
     * @param file A file object representing an ESRI Shape File
     * 
     * @exception IOException if something goes wrong opening or
     *            reading the file.
     */
    public ShapeFile(File file) throws IOException {
        this(file.getPath());
    }

    /**
     * Reads or writes the header of a Shape file. If the file is
     * empty, a blank header is written and then read. If the file is
     * not empty, the header is read.
     * <p>
     * After this function runs, the file pointer is set to byte 100,
     * the first byte of the first record in the file.
     * 
     * @exception IOException if something goes wrong reading or
     *            writing the shape file
     */
    protected void initHeader() throws IOException {
        int result = raf.read();
        if (result == -1) {
            // File is empty, write a new header into the file
            writeHeader();
        }
        readHeader();
    }

    /**
     * Writes a blank header into the shape file.
     * 
     * @exception IOException if something goes wrong writing the
     *            shape file
     */
    protected void writeHeader() throws IOException {
        header = new byte[SHAPE_FILE_HEADER_LENGTH];
        writeBEInt(header, 0, SHAPE_FILE_CODE);
        writeBEInt(header, 24, 50); // empty shape file size in 16 bit
        // words
        writeLEInt(header, 28, SHAPE_FILE_VERSION);
        writeLEInt(header, 32, SHAPE_TYPE_NULL);
        writeLEDouble(header, 36, 0.0);
        writeLEDouble(header, 44, 0.0);
        writeLEDouble(header, 52, 0.0);
        writeLEDouble(header, 60, 0.0);
        raf.seek(0);
        raf.write(header, 0, SHAPE_FILE_HEADER_LENGTH);
    }

    /**
     * Reads and parses the header of the file. Values from the header
     * are stored in the fields of this class.
     * 
     * @exception IOException if something goes wrong reading the file
     * @see #header
     * @see #fileVersion
     * @see #fileLength
     * @see #fileShapeType
     * @see #fileBounds
     */
    protected void readHeader() throws IOException {
        header = new byte[ShapeUtils.SHAPE_FILE_HEADER_LENGTH];
        raf.seek(0); // Make sure we're at the beginning of
        // the file
        raf.read(header, 0, ShapeUtils.SHAPE_FILE_HEADER_LENGTH);
        int fileCode = ShapeUtils.readBEInt(header, 0);
        if (fileCode != SHAPE_FILE_CODE) {
            throw new IOException("Invalid file code, "
                    + "probably not a shape file");
        }

        fileVersion = ShapeUtils.readLEInt(header, 28);
        if (fileVersion != SHAPE_FILE_VERSION) {
            throw new IOException("Unable to read shape files with version "
                    + fileVersion);
        }

        fileLength = ShapeUtils.readBEInt(header, 24);
        fileLength *= 2; // convert from 16-bit words to 8-bit
                            // bytes
        fileShapeType = ShapeUtils.readLEInt(header, 32);
        fileBounds = ShapeUtils.readBox(header, 36);
    }

    /**
     * Returns the length of the file in bytes.
     * 
     * @return the file length
     */
    public long getFileLength() {
        return fileLength;
    }

    /**
     * Returns the version of the file. The only currently supported
     * version is 1000 (which represents version 1).
     * 
     * @return the file version
     */
    public int getFileVersion() {
        return fileVersion;
    }

    /**
     * Returns the shape type of the file. Shape files do not mix
     * shape types; all the shapes are of the same type.
     * 
     * @return the file's shape type
     */
    public int getShapeType() {
        return fileShapeType;
    }

    /**
     * Sets the shape type of the file. If the file has a shape type
     * already, it cannot be set. If it does not have a shape type, it
     * is set and written to the file in the header.
     * <p>
     * Shape types are enumerated in the class ShapeUtils.
     * 
     * @param newShapeType the new shape type
     * @exception IOException if something goes wrong writing the file
     * @exception IllegalArgumentException if file already has a shape
     *            type
     * @see ShapeUtils
     */
    public void setShapeType(int newShapeType) throws IOException,
            IllegalArgumentException {
        if (fileShapeType == SHAPE_TYPE_NULL) {
            fileShapeType = newShapeType;
            long filePtr = raf.getFilePointer();
            writeLEInt(header, 32, fileShapeType);
            raf.seek(0);
            raf.write(header, 0, 100);
            raf.seek(filePtr);
        } else {
            throw new IllegalArgumentException("file already has a valid"
                    + " shape type: " + fileShapeType);
        }
    }

    /**
     * Returns the bounding box of this shape file. The bounding box
     * is the smallest rectangle that encloses all the shapes in the
     * file.
     * 
     * @return the bounding box
     */
    public ESRIBoundingBox getBoundingBox() {
        return fileBounds;
    }

    /**
     * Returns the next record from the shape file as an
     * <code>ESRIRecord</code>. Each successive call gets the next
     * record. There is no way to go back a record. When there are no
     * more records, <code>null</code> is returned.
     * 
     * @return a record, or null if there are no more records
     * @exception IOException if something goes wrong reading the file
     */