terrainlayer.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/terrain/TerrainLayer.java,v $
// $RCSfile: TerrainLayer.java,v $
// $Revision: 1.6.2.4 $
// $Date: 2005/08/09 21:17:47 $
// $Author: dietrick $
// 
// **********************************************************************

package com.bbn.openmap.layer.terrain;

/*  Java Core  */
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;

import javax.swing.Box;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JSlider;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

import com.bbn.openmap.dataAccess.dted.DTEDFrameCache;
import com.bbn.openmap.event.MapMouseListener;
import com.bbn.openmap.event.SelectMouseMode;
import com.bbn.openmap.layer.OMGraphicHandlerLayer;
import com.bbn.openmap.omGraphics.OMGraphicList;
import com.bbn.openmap.proj.Projection;
import com.bbn.openmap.util.Debug;
import com.bbn.openmap.util.PaletteHelper;

/**
 * The Terrain Layer is an example of creating a layer that acts as a
 * tool that defines and area (via user gestures) and presents a
 * result of the analysis of the data. In this case, Elevation data is
 * used in two different ways. The Profile tool lets you draw a line
 * on the map, and then uses DTED data to create a GIF image that
 * shows the terrain profile along the drawn line. The LOS
 * (line-of-sight) tool lets you define a circle, and then calculates
 * the places on the ground that are within sight of the center of the
 * circle. The result is shown with the visible points being colored
 * green, and all other points being clear. The LOS tool lets you use
 * a height slider on its palette to define additional height at the
 * point, representing a tower, building, or location of an aircraft.
 * 
 * <P>
 * The tools require you to be in the gesture mode of OpenMap.
 * 
 * <P>
 * The TerrainLayer needs a DTEDFrameCache. It can be added to the
 * layer programmatically, or the layer will find it if the
 * DTEDFrameCache is added to the MapHandler. To do that in the
 * OpenMap application, add the DTEDFrameCache to the
 * openmap.components property in the openmap.properties file.
 * 
 * <pre>
 * 
 *  #----------------------------------------------------------------------
 *  # Properties file for TerrainLayer
 *  #----------------------------------------------------------------------
 *  # The default tool to use for the terrain layer.  Can be PROFILE or
 *  LOS.  terrain.default.mode=PROFILE
 *  #----------------------------------------------------------------------
 *  # End of properties file for TerrainLayer
 *  #----------------------------------------------------------------------
 *  
 * </pre>
 * 
 * @see com.bbn.openmap.dataAccess.dted.DTEDFrameCache
 */
public class TerrainLayer extends OMGraphicHandlerLayer implements
        ActionListener, MapMouseListener {
    /** The cache that knows how to handle DTED requests. */
    public DTEDFrameCache frameCache;

    /** Which tool is being used. */
    protected int mode;
    /** The code number for the profile tool. */
    public final static int PROFILE = 0;
    /** The code number for the perspective tool (unimplemented). */
    public final static int PERSPECTIVE = 1;
    /** The code number for the LOS tool. */
    public final static int LOS = 2;
    /** The current tool being used. */
    public TerrainTool currentTool;
    public ProfileGenerator profileTool;
    public LOSGenerator LOSTool;

    public static final String defaultModeProperty = "default.mode";

    public final static String clearCommand = "clearTool";
    public final static String createCommand = "createTool";

    /**
     * The default constructor for the Layer. All of the attributes
     * are set to their default values.
     */
    public TerrainLayer() {
        setName("Terrain");
        init();
    }

    /** Creates new tools. */
    public void init() {
        profileTool = new ProfileGenerator(this);
        LOSTool = new LOSGenerator(this);
        setProjectionChangePolicy(new com.bbn.openmap.layer.policy.ListResetPCPolicy(this));
    }

    /**
     * Sets the default values for the variables, if the properties
     * are not found, or are invalid. Usually not a good idea.
     */
    protected void setDefaultValues() {
        mode = PROFILE;
    }

    public void setFrameCache(DTEDFrameCache dfc) {
        frameCache = dfc;
    }

    public DTEDFrameCache getFrameCache() {
        return frameCache;
    }

    /**
     * Set all the TerrainLayer properties from a proerties object
     * 
     * @param prefix a string that gets set to indiviualize the
     *        properties to a specific layer.
     * @param properties the proerties object
     */
    public void setProperties(String prefix, java.util.Properties properties) {

        super.setProperties(prefix, properties);
        setDefaultValues();
        prefix = com.bbn.openmap.util.PropUtils.getScopedPropertyPrefix(prefix);

        try {

            String defaultModeString = properties.getProperty(prefix
                    + defaultModeProperty);
            if (defaultModeString.equalsIgnoreCase("LOS"))
                setMode(LOS);
            //          else if (defaultModeString.equalsIgnoreCase("PROFILE"))
            //              defaultMode = PROFILE;
            else
                setMode(PROFILE);
        } catch (NullPointerException e) {
            System.err.println("TerrainLayer: Caught NullPointerException loading resources.");
            System.err.println("TerrainLayer: Using default resources.");
            setDefaultValues();
            setMode(mode);
        }
    }

    /**
     * Prepares the graphics for the layer. This is where the
     * getRectangle() method call is made on the dted.
     * <p>
     * Occasionally it is necessary to abort a prepare call. When this
     * happens, the map will set the cancel bit in the LayerThread,
     * (the thread that is running the prepare). If this Layer needs
     * to do any cleanups during the abort, it should do so, but
     * return out of the prepare asap.
     */
    public synchronized OMGraphicList prepare() {

        if (isCancelled()) {
            Debug.message("dted", getName()
                    + "|TerrainLayer.prepare(): aborted.");
            return null;
        }

        Projection projection = getProjection();

        if (projection == null) {
            System.err.println("Terrain Layer needs to be added to the MapBean before it can be used!");
            return new OMGraphicList();
        }

        Debug.message("basic", getName() + "|TerrainLayer.prepare(): doing it");

        // Setting the OMGraphicsList for this layer. Remember, the
        // OMGraphicList is made up of OMGraphics, which are generated
        // (projected) when the graphics are added to the list. So,
        // after this call, the list is ready for painting.
        
        profileTool.setScreenParameters(projection);
        LOSTool.setScreenParameters(projection);
        return currentTool.getGraphics();
    }

    //----------------------------------------------------------------------
    // GUI
    //----------------------------------------------------------------------

    /** The user interface palette for the Terrain layer. */
    protected Box palette = null;
    private String profileCommand = "setModeToProfile";
    private String losCommand = "setModeToLos";

    /** Creates the interface palette. */
    public java.awt.Component getGUI() {

        if (palette == null) {
            if (Debug.debugging("terrain"))
                System.out.println("TerrainLayer: creating Terrain Palette.");

            palette = Box.createVerticalBox();

            //          palette = new JPanel();
            //          palette.setLayout(new GridLayout(0, 1));

            // The Terrain Level selector
            JPanel modePanel = PaletteHelper.createPaletteJPanel("Tool Mode");
            ButtonGroup modes = new ButtonGroup();

            ActionListener al = new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    String ac = e.getActionCommand();
                    if (ac.equalsIgnoreCase(losCommand)) {
                        setMode(LOS);
                    } else {
                        setMode(PROFILE);
                    }
                }
            };

            JRadioButton profileModeButton = new JRadioButton("Profile");
            profileModeButton.addActionListener(al);
            profileModeButton.setActionCommand(profileCommand);
            JRadioButton losModeButton = new JRadioButton("LOS");
            losModeButton.addActionListener(al);
            losModeButton.setActionCommand(losCommand);

            modes.add(profileModeButton);
            modes.add(losModeButton);

            switch (mode) {
            case LOS:
                losModeButton.setSelected(true);
                break;
            case PROFILE:
            default:
                profileModeButton.setSelected(true);
            }

            modePanel.add(profileModeButton);
            modePanel.add(losModeButton);

            // The LOS Height Adjuster
            JPanel centerHeightPanel = PaletteHelper.createPaletteJPanel("LOS Center Object Height");
            JSlider centerHeightSlide = new JSlider(JSlider.HORIZONTAL, 0/* min */, 500/* max */, 0/* inital */);
            java.util.Hashtable dict = new java.util.Hashtable();
            dict.put(new Integer(0), new JLabel("0 ft"));
            dict.put(new Integer(500), new JLabel("500 ft"));
            centerHeightSlide.setLabelTable(dict);
            centerHeightSlide.setPaintLabels(true);
            centerHeightSlide.setMajorTickSpacing(50);
            centerHeightSlide.setPaintTicks(true);
            centerHeightSlide.setSnapToTicks(false);
            centerHeightSlide.addChangeListener(new ChangeListener() {
                public void stateChanged(ChangeEvent ce) {
                    JSlider slider = (JSlider) ce.getSource();
                    if (slider.getValueIsAdjusting()) {
                        fireRequestInfoLine("TerrainLayer - center height value = "
                                + slider.getValue());
                        LOSTool.setLOSobjectHeight(slider.getValue());
                    }
                }
            });
            centerHeightPanel.add(centerHeightSlide);

            JPanel profileControlPanel = PaletteHelper.createPaletteJPanel("Tool Commands");
            JButton clearButton = new JButton("Clear/Reset Tool");
            clearButton.setActionCommand(clearCommand);
            clearButton.addActionListener(this);
            JButton createButton = new JButton("Create");
            createButton.setActionCommand(createCommand);
            createButton.addActionListener(this);

            profileControlPanel.add(clearButton);
            profileControlPanel.add(createButton);

            JButton redraw = new JButton("Redraw Terrain Layer");
            redraw.setActionCommand(RedrawCmd);
            redraw.addActionListener(this);

            palette.add(modePanel);
            palette.add(centerHeightPanel);
            palette.add(profileControlPanel);
            //          palette.add(redraw);
        }

        return palette;
    }

    //----------------------------------------------------------------------
    // ActionListener interface implementation
    //----------------------------------------------------------------------

    /**
     * The reaction handler for the buttons being pressed on the
     * palette.
     */
    public void actionPerformed(ActionEvent e) {
        super.actionPerformed(e);
        String ac = e.getActionCommand();
        if (ac.equalsIgnoreCase(RedrawCmd)) {
            doPrepare();
        } else {
            currentTool.getState().actionPerformed(e);
        }
    }

    //----------------------------------------------------------------------
    // MapMouseListener interface implementation
    //----------------------------------------------------------------------

    public synchronized MapMouseListener getMapMouseListener() {
        return this;
    }

    /**
     * Tells the MouseDelegator which Mouse Modes we're interested in
     * receiving events from. In this case, just the "Gestures" mode.
     */
    public String[] getMouseModeServiceList() {
        String[] services = { SelectMouseMode.modeID };
        return services;
    }

    public boolean mousePressed(MouseEvent e) {
        return currentTool.getState().mousePressed(e);
    }

    public boolean mouseReleased(MouseEvent e) {
        return currentTool.getState().mouseReleased(e);
    }

    public boolean mouseClicked(MouseEvent e) {
        return currentTool.getState().mouseClicked(e);
    }

    public void mouseEntered(MouseEvent e) {}

    public void mouseExited(MouseEvent e) {}

    public boolean mouseDragged(MouseEvent e) {
        return currentTool.getState().mouseDragged(e);
    }

    public boolean mouseMoved(MouseEvent e) {
        return false;
    }

    public void mouseMoved() {}

    /**
     * Little math utility that both tools use, that just implements
     * the pathagorean theorem to do the number of pixels between two
     * screen points.
     */
    public static int numPixelsBetween(int x1, int y1, int x2, int y2) {
        return (int) Math.sqrt(Math.pow((double) (x1 - x2), 2.0)
                + Math.pow((double) (y1 - y2), 2.0));
    }

    /** Set the current tool to be used. */
    public void setMode(int m) {
        mode = m;
        if (currentTool != null)
            currentTool.reset();
        if (m == PROFILE) {
            currentTool = profileTool;
            //        System.out.println("Changing mode to PROFILE");
        }
        if (m == LOS) {
            currentTool = LOSTool;
            //        System.out.println("Changing mode to LOS");
        }
        if (currentTool != null) {
            currentTool.reset();
            setList(currentTool.getGraphics());
        }
    }

    public int getMode() {
        return mode;
    }

    public void findAndInit(Object someObj) {
        if (someObj instanceof DTEDFrameCache) {
            setFrameCache((DTEDFrameCache) someObj);
        }
    }

    public void findAndUndo(Object someObj) {
        if (someObj == getFrameCache()) {
            setFrameCache(null);
        }
    }

}