dtedcachemanager.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/dted/DTEDCacheManager.java,v $
// $RCSfile: DTEDCacheManager.java,v $
// $Revision: 1.4.2.3 $
// $Date: 2005/01/14 16:49:18 $
// $Author: dietrick $
// 
// **********************************************************************

package com.bbn.openmap.layer.dted;

import com.bbn.openmap.util.Debug;

import com.bbn.openmap.omGraphics.OMGraphicList;
import com.bbn.openmap.omGraphics.OMRaster;
import com.bbn.openmap.proj.EqualArc;
import com.bbn.openmap.LatLonPoint;

/**
 * The DTEDCacheManager is the object you need if you want to retrieve
 * DTED files en masse for display. You set it up with the paths to
 * the files, and then ask it for an OMGraphicList that contains the
 * frames for a geographical area.
 * <P>
 * The DTEDCacheManager also manages objects called DTEDCacheHandlers.
 * Cache handlers have their own set of frames, figure out which
 * frames are needed to fill the screen, and ask each frame for the
 * rasters (subframes). The situation gets pretty tricky when the
 * screen has the equator and/or the dateline on it, and a different
 * cache handler is needed for each quadrant of the earth. This
 * situation is relatively rare, though, and the DTEDCacheManager
 * automatically checks for these situations and creates the cache
 * handlers needed.
 * <P>
 * There are two calls to the Cache that you need to use. The
 * constructor sets up the cache with the location of the data on your
 * system. The getRectangle() call returns an OMGraphicList of objects
 * to draw, that cover the area asked for.
 */
public class DTEDCacheManager {
    /**
     * The size of the smaller caches, when more cachehandlers are
     * needed to cover the equator and the dateline.
     */
    public final static int SMALL_CACHE_SIZE = 20;
    /** A box is a earth quadrant. */
    public final static int MAX_NUM_BOXES = 4;

    /**
     * The cache handlers needed to cover the screen. Need one for
     * each earth quadrant, and for each DTED directory, in case
     * coverage is spread out over different sources.
     */
    protected DTEDCacheHandler[] caches = new DTEDCacheHandler[MAX_NUM_BOXES];

    protected DTEDFrameSubframeInfo subframeInfo;
    protected String[] dtedDirPaths;
    protected String[] dted2DirPaths;

    // for cache constructors
    protected int numColors;
    protected int opaqueness = DTEDFrameColorTable.DEFAULT_OPAQUENESS;
    protected int cacheSize = DTEDCacheHandler.FRAME_CACHE_SIZE;

    /**
     * Constructor that uses the default paths and the default number
     * of colors.
     */
    public DTEDCacheManager() {
        this(null,
             DTEDFrameColorTable.DTED_COLORS,
             DTEDFrameColorTable.DEFAULT_OPAQUENESS);
    }

    /**
     * Constructor that lets you set the paths of the DTED
     * directories, where the data is located.
     * 
     * @param DTEDPaths pathnames to the DTED directories.
     */
    public DTEDCacheManager(String[] DTEDPaths) {
        this(DTEDPaths,
             DTEDFrameColorTable.DTED_COLORS,
             DTEDFrameColorTable.DEFAULT_OPAQUENESS);
    }

    /**
     * Constructor that lets you set the paths of the DTED
     * directories, where the data is located, as well as the number
     * of colors you want used in the graphics.
     * 
     * @param DTEDPaths pathnames to the DTED level 0 and 1
     *        directories.
     * @param num_colors number of colors to be used in the graphics.
     * @param opaque the opaqueness of the dted images, 0 - 255 (0 is
     *        clear)
     */
    public DTEDCacheManager(String[] DTEDPaths, int num_colors, int opaque) {
        dtedDirPaths = DTEDPaths;
        numColors = num_colors;
        opaqueness = opaque;
    }

    /**
     * Constructor that lets you set the paths of the DTED
     * directories, where the data is located, as well as the number
     * of colors you want used in the graphics.
     * 
     * @param DTEDPaths pathnames to the DTED level 0 and 1
     *        directories.
     * @param DTED2Paths pathnames to the DTED level 2 directories.
     * @param num_colors number of colors to be used in the graphics.
     * @param opaque the opaqueness of the dted images, 0 - 255 (0 is
     *        clear)
     */
    public DTEDCacheManager(String[] DTEDPaths, String[] DTED2Paths,
            int num_colors, int opaque) {
        dtedDirPaths = DTEDPaths;
        dted2DirPaths = DTED2Paths;
        numColors = num_colors;
        opaqueness = opaque;
    }

    /**
     * Used to set the DTED directory paths.
     * 
     * @param paths DTED Level 0 and 1 directory paths.
     */
    public void setDtedDirPaths(String[] paths) {
        dtedDirPaths = paths;
        resetCaches();
    }

    /**
     * Used to set the DTED directory paths.
     * 
     * @param paths DTED Level 0 and 1 directory paths.
     * @param paths2 DTED Level 2 directory paths.
     */
    public void setDtedDirPaths(String[] paths, String[] paths2) {
        dtedDirPaths = paths;
        dted2DirPaths = paths2;
        resetCaches();
    }

    /**
     * Reset the DTEDCacheHandler array so the handlers will get created on the
     * next frame request.
     */
    public void resetCaches() {
        caches = new DTEDCacheHandler[MAX_NUM_BOXES];
    }

    /**
     * Set the number of frames that the caches should contain. If
     * negative or zero, the cache calculates the cache size based on
     * the projection.
     */
    public void setCacheSize(int size) {
        cacheSize = size;
    }

    /**
     * Get the number of frames that the caches should contain. If
     * negative or zero, the cache is calculating the cache size based
     * on the projection.
     */
    public int getCacheSize() {
        return cacheSize;
    }

    /**
     * Get an elevation at a point. Always uses the main cache to load
     * the frame and get the data.
     * 
     * @param lat latitude of point in decimal degrees.
     * @param lon longitude of point in decimal degrees.
     */
    public int getElevation(float lat, float lon) {
        if (caches[0] == null) {
            caches[0] = new DTEDCacheHandler(dtedDirPaths, dted2DirPaths, numColors, opaqueness);
            caches[0].setSubframeInfo(subframeInfo);
        }
        return caches[0].getElevation(lat, lon);
    }

    public void setSubframeInfo(DTEDFrameSubframeInfo dfsi) {
        subframeInfo = dfsi;
        for (int i = 0; i < MAX_NUM_BOXES; i++) {
            if (caches[i] != null)
                caches[i].setSubframeInfo(dfsi);
        }
    }

    public DTEDFrameSubframeInfo getSubframeInfo() {
        return subframeInfo;
    }

    /**
     * The call to the cache that lets you choose what kind of
     * information is returned. This function also figures out what
     * part of the earth is covered on the screen, and creates
     * auxillary cache handlers as needed.
     * 
     * @param proj The projection of the screen (CADRG).
     * @return List of rasters to display.
     */
    public OMGraphicList getRectangle(EqualArc proj) {

        float[] lat = new float[3];
        float[] lon = new float[3];

        // This next bit of mumbo jumbo is to handle the equator and
        // dateline: Worst case, crossing both, treat each area
        // separately, so it is the same as handling four requests for
        // data - above and below the equator, and left and right of
        // the dateline. Normal case, there is only one box. Two
        // boxes if crossing only one of the boundaries.

        int xa = 2;
        int ya = 2;
        int lat_minus = 2;
        int lon_minus = 2;
        // Set up checks for equator and dateline
        LatLonPoint ll1 = proj.getUpperLeft();
        LatLonPoint ll2 = proj.getLowerRight();

        lat[0] = ll1.getLatitude();
        lon[0] = ll1.getLongitude();
        lat[1] = ll2.getLatitude();
        lon[1] = ll2.getLongitude();
        lat[2] = ll2.getLatitude();
        lon[2] = ll2.getLongitude();

        if (lon[0] > 0 && lon[2] < 0) {
            lon[1] = -179.999f; // put a little breather on the
            // dateline
            lon_minus = 1;
        }
        if (lat[0] > 0 && lat[2] < 0) {
            lat[1] = -0.0001f; // put a little breather on the equator
            lat_minus = 1;
        }

        if (Debug.debugging("dteddetail")) {
            Debug.output("For :");
            Debug.output("lat[0] " + lat[0]);
            Debug.output("lon[0] " + lon[0]);
            Debug.output("lat[1] " + lat[1]);
            Debug.output("lon[1] " + lon[1]);
            Debug.output("lat[2] " + lat[2]);
            Debug.output("lon[2] " + lon[2]);
            Debug.output("lat_minus = " + lat_minus);
            Debug.output("lon_minus = " + lon_minus);
        }

        /*
         * Look at all the paths if needed. Worst case, there are four
         * boxes on the screen. Best case, there is one. The things
         * that create boxes and dictates how large they are are the
         * equator and the dateline. When the screen straddles one or
         * both of these lat/lon lines, lon_minus and lat_minus get
         * adjusted, causing two or four different calls to the
         * tochandler to get the data above/below the equator, and
         * left/right of the dateline. Plus, each path gets checked
         * until the required boxes are filled.
         */

        if (caches[0] == null) {
            caches[0] = new DTEDCacheHandler(dtedDirPaths, dted2DirPaths, numColors, opaqueness, cacheSize);
            caches[0].setSubframeInfo(subframeInfo);
        }

        caches[0].setProjection(proj,
                lat[ya - lat_minus],
                lon[xa - lon_minus],
                lat[ya],
                lon[xa]);

        // Dateline split
        if (lon_minus == 1) {
            if (caches[1] == null) {
                caches[1] = new DTEDCacheHandler(dtedDirPaths, dted2DirPaths, numColors, opaqueness, cacheSize);
                caches[1].setSubframeInfo(subframeInfo);
            }

            caches[1].setProjection(proj,
                    lat[ya - lat_minus],
                    lon[0],
                    lat[ya],
                    -1f * lon[1]); // -1 to make it 180
        } else
            caches[1] = null;

        // Equator Split
        if (lat_minus == 1) {
            if (caches[2] == null) {
                caches[2] = new DTEDCacheHandler(dtedDirPaths, dted2DirPaths, numColors, opaqueness, cacheSize);
                caches[2].setSubframeInfo(subframeInfo);
            }

            caches[2].setProjection(proj, lat[0], lon[xa - lon_minus], -1f
                    * lat[1], // flip breather
                    lon[xa]);
        } else
            caches[2] = null;

        // Both!!
        if (lon_minus == 1 && lat_minus == 1) {
            if (caches[3] == null) {
                caches[3] = new DTEDCacheHandler(dtedDirPaths, dted2DirPaths, numColors, opaqueness, cacheSize);
                caches[3].setSubframeInfo(subframeInfo);
            }

            caches[3].setProjection(proj, lat[0], lon[0], -1f * lat[1],//  flip
                    // breather
                    -1f * lon[1]);// -1 to make it 180, not -180
        } else
            caches[3] = null;

        OMGraphicList graphics = new OMGraphicList();

        if (Debug.debugging("dted"))
            Debug.output("--- DTEDCacheManager: getting images: ---");

        for (int nbox = 0; nbox < MAX_NUM_BOXES; nbox++) {
            if (caches[nbox] != null) {
                OMRaster image = caches[nbox].getNextImage();
                while (image != null) {
                    graphics.add(image);
                    image = caches[nbox].getNextImage();
                }
            }
        }
        return graphics;
    }

    public void setNumColors(int numberOfColors) {
        numColors = numberOfColors;
    }

    public int getNumColors() {
        return numColors;
    }

    public void setOpaqueness(int setting) {
        opaqueness = setting;
    }

    public int getOpaqueness() {
        return opaqueness;
    }
}