maketoc.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/rpf/MakeToc.java,v $
// $RCSfile: MakeToc.java,v $
// $Revision: 1.6.2.5 $
// $Date: 2005/09/15 14:03:39 $
// $Author: dietrick $
// 
// **********************************************************************

/*
 * The meat of this code is based on source code provided by The MITRE
 * Corporation, through the browse application source code.  Many
 * thanks to Nancy Markuson who provided BBN with the software, and to
 * Theron Tock, who wrote the software, and Daniel Scholten, who
 * revised it - (c) 1994 The MITRE Corporation for those parts, and
 * used/distributed with permission. 
 */
package com.bbn.openmap.layer.rpf;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.util.Vector;

import com.bbn.openmap.event.ProgressEvent;
import com.bbn.openmap.event.ProgressListener;
import com.bbn.openmap.event.ProgressSupport;
import com.bbn.openmap.io.BinaryBufferedFile;
import com.bbn.openmap.io.BinaryFile;
import com.bbn.openmap.util.Debug;
import com.bbn.openmap.util.ArgParser;
import com.bbn.openmap.LatLonPoint;
import com.bbn.openmap.proj.coords.DMSLatLonPoint;

/**
 * This is a class that will generate A.TOC files that the RpfLayer
 * requires. A.TOC files provide the RpfLayer with an idea of what
 * data is available to it, its geographic coverage, and chart type.
 * With the A.TOC contents, the RpfLayer is able to find which frames
 * are appropriate for a given projection location. It is very
 * important to have a valid A.TOC directory.
 * <P>
 * 
 * The RPF specification, MIL-STD-2411, has definitions for how frames
 * are to be laid out and found within a RPF directory. All RPF data
 * is supposed to lie under one RPF directory, and an A.TOC file,
 * describing all the files and their groupings, should be directly
 * within the RPF directory. That's why the RpfLayer needs a path to a
 * RPF directory - it's really looking for the A.TOC file, and knows
 * where to find it. It also needs a path to the RPF directory because
 * it needs to prepend that path to the paths to the files that the
 * A.TOC file knows about.
 * <P>
 * 
 * The A.TOC files that can be created with this MakeToc class can be
 * created to contain absolute frame paths. The MakeToc class can take
 * the paths to several RPF directories, and create a single A.TOC
 * file that preserves all of their current file paths. You have to
 * use alot of caution with this capability, however. These A.TOCs
 * containing absolute file paths will not work if the data is moved
 * to another machine, or if referenced by a machine with a different
 * type file system (i.e. Windows). They may not work for other
 * implementations of code that display RPF data - the code in this
 * package has been modified to test for absolute file names.
 * <P>
 * 
 * That said, absolute file names should be used instead of giving the
 * RpfLayer several RPF directories. The RpfTocHandler does much less
 * work when it is allowed to group coverages together to make bigger
 * areas.
 * <P>
 * 
 * This code was ported from C code provided in the original Mitre RPF
 * package that had limits to the number of frames that could make up
 * the areas. I'll be working to eliminate those limits, but I wanted
 * to get a working version of the code out there. I'm also planning
 * on modifying this class so that it can load the RpfTocHandler
 * directly, therefore eliminating the need for A.TOCs altogether when
 * there is more than one RPF directory.
 * <P>
 * 
 * <pre>
 * 
 *  
 *   
 *    
 *     
 *      
 *       
 *        
 *         Usage:  java com.bbn.openmap.layer.rpf.MakeToc (RPF dir path) (RPF dir path) ...
 *         
 *        
 *       
 *      
 *     
 *    
 *   
 *  
 * </pre>
 * 
 * This will create an A.TOC file in the current directory for the RPF
 * files in the RPF directory paths. Use:
 * 
 * <pre>
 * 
 *  
 *   
 *    
 *     
 *      
 *       
 *        
 *         java com.bbn.openmap.layer.rpf.MakeToc -help
 *         
 *        
 *       
 *      
 *     
 *    
 *   
 *  
 * </pre>
 * 
 * for other options.
 * 
 * <P>
 * NOTE: Make sure that the RPF directories and their contents are in
 * upper case. It's a spec requirement, although with CD copies and
 * FTP downloads, the file name cases sometimes get switched. Use
 * com.bbn.openmap.layer.rpf.ChangeCase to modify the file name cases.
 * Also, if there is more than one RPF directory in the path to the
 * image frames, use the absolute path option. Otherwise, the code
 * will focus on making the top-most RPF directory the one to key the
 * internal relative paths off of, and that might not be what you
 * want.
 * </P>
 * 
 * @see com.bbn.openmap.layer.rpf.ChangeCase
 */
public class MakeToc {

    /**
     * According to Dan Scholten's original code, this was 2 times the
     * max - changed from 30 on 6/17/94 to 200 for 81 JNC's in zone 1.
     * This might not be enough for world-wide coverage of larger
     * scale maps that are now available. This number may have to be
     * increased depending on how much data you need.
     */
    public final static int DEFAULT_MAX_SIDE = 200;

    public final static double EPS = 0.01;
    public final static double EPS2 = 0.0001;
    /** Output file name of the A.TOC file. */
    public final static String ATOC_FILENAME = "A.TOC";
    /** The boundary edge frame length for groups. */
    protected int maxSide = DEFAULT_MAX_SIDE;
    /** Flag to use relative frames paths - default is true. */
    protected boolean relativeFramePaths = true;
    /** The producer name for the frame files. Default is DMAAC. */
    protected String producer = "DMAAC";

    protected ProgressSupport progressSupport;

    /** An internal representation of a Frame file. */
    public class Frame {
        double left;
        double right;
        double top;
        double bottom;
        /* New DKS: for computing GEOREF #'s over polar region */
        double swlat;
        double swlon;
        double h_interval;
        double v_interval;
        double h_resolution;
        double v_resolution;
        String scale; // length 12
        char zone;
        boolean marked;
        int group;
        int x;
        int y;
        String filename;
        boolean cib;
        boolean cdted;

        public double EPS() {
            return (Math.abs(right - left) * MakeToc.EPS);
        };

        public String toString() {
            StringBuffer s = new StringBuffer();
            s.append("Frame - " + filename + "\n");
            s.append("  zone = " + zone + "\n");
            s.append("  marked = " + marked + "\n");
            s.append("  scale = " + scale + "\n");
            s.append("  group = " + group + "\n");

            if (Debug.debugging("maketocframe")) {
                s.append("  top = " + top + "\n");
                s.append("  bottom = " + bottom + "\n");
                s.append("  left = " + left + "\n");
                s.append("  right = " + right + "\n");
                s.append("  h_interval = " + h_interval + "\n");
                s.append("  v_interval = " + v_interval + "\n");
                s.append("  h_resolution = " + h_resolution + "\n");
                s.append("  v_resolution = " + v_resolution + "\n");
            }

            return s.toString();
        }
    }

    /** An internal representation of a boundary rectangle for frames. */
    public class Group {
        double[] horiz_pos;
        double[] vert_pos;
        int left;
        int right;
        int top;
        int bottom;
        String scale;
        char zone;
        double h_interval;
        double v_interval;
        double h_resolution;
        double v_resolution;
        boolean cib;
        boolean cdted;

        public Group() {
            horiz_pos = new double[maxSide];
            vert_pos = new double[maxSide];
        }

        public String toString() {
            StringBuffer s = new StringBuffer();
            s.append("Group - \n");
            s.append("  zone = " + zone + "\n");
            s.append("  scale = " + scale + "\n");
            s.append("  left = " + left + "\n");
            s.append("  right = " + right + "\n");
            s.append("  top = " + top + "\n");
            s.append("  bottom = " + bottom + "\n");
            s.append("  is cdted = " + cdted + "\n");
            s.append("  is cib = " + cib + "\n");
            return s.toString();
        }
    }

    public MakeToc() {
        progressSupport = new ProgressSupport(this);
    }

    /**
     * Create an A.TOC file.
     * 
     * @param argv The arguments should at least include a path to a
     *        RPF file root directory. Other options can be found by
     *        using a -help option.
     */
    public static void main(String[] argv) {
        Debug.init();
        boolean Dchum = false;

        ArgParser ap = new ArgParser("MakeToc");
        ap.add("absolute",
                "Use absolute paths in A.TOC - Use for multiple RPF Directories");
        ap.add("boundary", "Maximum frames on a boundary edge (Default 200)", 1);
        ap.add("dchum", "DCHUM files are included.");
        ap.add("log", "Pathname of log file to list A.TOC creation output.", 1);
        ap.add("output",
                "Path to directory to place A.TOC file. (Default is current directory)",
                1);
        ap.add("producer",
                "The producer of the frames (Default DMAAC).  Five letter code.",
                1);
        ap.add("verbose", "Print out progress");
        ap.add("extraverbose", "Print out ALL progress");
        ap.add("nw",
                "Don't put up swing progress window (Use this if you are getting weird exceptions)");
        ap.add("paths",
                "Space separated paths to RPF directory or directories.  Should be last.  If more than one directory is listed, then absolute paths are used in the A.TOC file.",
                ArgParser.TO_END);

        if (!ap.parse(argv)) {
            ap.printUsage();
            System.exit(0);
        }

        String outputFile = "." + File.separator
                + RpfTocHandler.RPF_TOC_FILE_NAME;

        String arg[];
        arg = ap.getArgValues("output");
        if (arg != null) {
            outputFile = arg[0] + File.separator
                    + RpfTocHandler.RPF_TOC_FILE_NAME;
        }

        arg = ap.getArgValues("log");
        if (arg != null) {
            String logfile = arg[0];
            Debug.directOutput(logfile, false, true);
            Debug.output("MakeToc: Creating log at " + logfile + " at "
                    + java.util.Calendar.getInstance().getTime());
        }

        arg = ap.getArgValues("dchum");
        if (arg != null) {
            Dchum = true;
        }

        arg = ap.getArgValues("verbose");
        if (arg != null) {
            Debug.put("maketoc");
        }

        arg = ap.getArgValues("extraverbose");
        if (arg != null) {
            Debug.put("maketoc");
            Debug.put("maketocdetail");
        }

        String[] paths = null;
        arg = ap.getArgValues("paths");
        if (arg != null) {
            paths = arg;
        } else {