magicplanetimagecomponent.java

来自「OpenMap是一个基于JavaBeansTM的开发工具包。利用OpenMap你」· Java 代码 · 共 1,090 行 · 第 1/3 页

// **********************************************************************
//
//<copyright>
//
//BBN Technologies, a Verizon Company
//10 Moulton Street
//Cambridge, MA 02138
//[phone]
//
//Copyright (C) BBNT Solutions LLC. All rights reserved.
//
//</copyright>
//**********************************************************************
//
//$Source:
///cvs/darwars/ambush/aar/src/com/bbn/ambush/mission/MissionHandler.java,v
//$
//$RCSfile: MagicPlanetImageComponent.java,v $
//$Revision: 1.1.2.4 $
//$Date: 2006/09/15 14:11:37 $
//$Author: dietrick $
//
//**********************************************************************

package com.bbn.openmap.image;

import java.awt.Paint;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.DecimalFormat;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Properties;

import javax.swing.JOptionPane;
import javax.swing.Timer;

import com.bbn.openmap.Environment;
import com.bbn.openmap.I18n;
import com.bbn.openmap.LatLonPoint;
import com.bbn.openmap.Layer;
import com.bbn.openmap.LayerHandler;
import com.bbn.openmap.MapBean;
import com.bbn.openmap.OMComponent;
import com.bbn.openmap.event.LayerEvent;
import com.bbn.openmap.event.LayerListener;
import com.bbn.openmap.proj.LLXY;
import com.bbn.openmap.proj.Projection;
import com.bbn.openmap.util.Debug;
import com.bbn.openmap.util.PropUtils;

/**
 * The MagicPlanetImageComponent is an OpenMap Component designed to create
 * images for Global Imagination's MagicPlanet Globe. This component, when added
 * to an OpenMap MapHandler, will find the LayerHandler so it can find out when
 * the Layer given to the MapBean change, so it knows which ones to use when
 * creating an image file. This component also connects to the MapBean as a
 * PropertyChangeListener to find out when the ocean color has changed. The
 * MagicPlanet software (Storyteller) has the option of displaying images stored
 * in a particular directory, either displaying the latest (lexically) image or
 * cycling through a set of images in the directory to create a movie on the
 * globe.
 * <p>
 * 
 * The class has options that change the format of the images created, where the
 * images are stored, how often they are created, and the scale of the images.
 * The scale of the image dictates its pixel size, since the proportion of the
 * projection has to be constant for it to work on the globe. The projection
 * used for the images is always the OpenMap LLXY projection, that's what the
 * MagicPlanet expects.
 * <p>
 * 
 * The properties for this component are:
 * 
 * <pre>
 *                outputDirectory=path_to_directory_for_writing_images
 *                
 *                # Milliseconds between image creation, 60000 is the default, representing 1 minute
 *                updateInterval=60000
 *                
 *                # Milliseconds after the timer is created before the MagicPlanetImageComponent takes
 *                # its first image and starts updating according to the updateInterval.  Default is 0,
 *                # so the first image is taken as soon as the component finds the layers.
 *                initialDelay=180000
 *                
 *                # The scale of the image, it determines the size of the image.  This 
 *                # may be important for certain layers to show particular details.  
 *                # The default is 60000000F, which represents an image approximately 2kx1k
 *                scale=60000000F
 *                
 *                # Property to tell the component to create a new image and reset the timer if the 
 *                # layers on the MapBean change.  True by default.
 *                autoUpdate=true
 *                
 *                # Property to tell the component to remove old images, default is true
 *                cleanup=true
 *                
 *                # Property to set the wait time before deleting old images, represented 
 *                # in milliseconds. The default is 86400000, representing one day. 
 *                cleanupInterval=86400000
 *                
 *                # Properties for setting the pixel width and height of the images. These properties 
 *                # provide a more precise way to control the image size, and tell the component to 
 *                # scale the image created with the scale setting set above.  The closer you get 
 *                # the scale to provide you the image size you want, the higher quality image 
 *                # you will have.  The default values for these properties are -1, which tells
 *                # the component to not change the size of the image resulting from the scale setting.
 *                width=-1 
 *                height=-1
 *                
 *                # Property to set the name of the last image written in a file, so other programs 
 *                # can more easily figure out what it was.  The property should reflect the path 
 *                # to the file to be written, which will contain 'MagicPlanet.lastFile=YYYYMMDDhhmmss.ext',
 *                # where YYYYMMDDhhmmss are year, month, day, hour, minute and second the file was created, 
 *                # and ext is the extension for the image type.  This information, combined with the directory 
 *                # information stored above, will let you know where the file is.  If this property is not set, 
 *                # no text file will be written.
 *                lastImageFile=path_to_text_file 
 *                
 *                # Property that describes a system command that should be run each time an image is created.
 *                # The property should contain exactly what would be typed into a command line for a script 
 *                # to be run, in the same environment this component is being run in.  There are special arguments
 *                # that can be inserted into this property string that the component will use to replace the current
 *                # image file name:
 *                #
 *                # %FILEPATH% gets replaced with the complete path of the new image file.
 *                # %FILENAME% gets replaced with the file name if the image file.
 *                # %FILENAME_WITHOUT_EXTENSION% gets replaced with the file name without a '.' or anything after that.
 *                #
 *                # The default is no value being set for the script, which means nothing will happen.  Here is an example for
 *                # creating a .dds file from the current image, using nvidiea's nvdxt script.
 *                postProcessingScript=&quot;c:/Program Files/NVIDIA Corporation/NVIDIA DDS Utilities/nvdxt.exe&quot; -swap -dxt1c -file %FILEPATH% -output c:/%FILENAME_WITHOUT_EXTENSION%.dds
 * </pre>
 * 
 * @author dietrick
 */
public class MagicPlanetImageComponent extends OMComponent implements
        LayerListener, PropertyChangeListener, ActionListener {

    public final static String OutputDirectoryProperty = "outputDirectory";

    public final static String UpdateIntervalProperty = "updateInterval";

    public final static String InitialDelayProperty = "initialDelay";

    public final static String ScaleProperty = "scale";

    public final static String AutoUpdateProperty = "autoUpdate";

    public final static String CleanupProperty = "cleanup";

    public final static String CleanupIntervalProperty = "cleanupInterval";

    public final static String HeightProperty = "height";

    public final static String WidthProperty = "width";

    public final static String LastImageFileProperty = "lastImageFile";

    public final static String PostProcessingScriptProperty = "postProcessingScript";

    public final static String LAST_IMAGE_FILE_KEY = "MagicPlanet.lastFile";

    public final static String REPLACE_FILEPATH_MARKER = "%FILEPATH%";

    public final static String REPLACE_FILENAME_MARKER = "%FILENAME%";

    public final static String REPLACE_FILENAME_WOEXT_MARKER = "%FILENAME_WITHOUT_EXTENSION%";

    protected boolean DEBUG = false;

    // Kept in case replacements are added to the application, so we
    // remember who to disconnect from.
    protected LayerHandler layerHandler;

    protected MapBean mapBean;

    /**
     * Parent directory for images.
     */
    protected String outputDirectoryString;

    protected int updateInterval = 60000;

    protected int initialDelay = 0;

    protected float scale = 60000000F; // Produces 2k x 1k image

    protected Projection proj;

    protected Paint background;

    protected Layer[] layers;

    protected boolean autoUpdate = true;

    protected ImageFormatter imageFormatter = new SunJPEGFormatter();

    protected boolean cleanup = true;

    protected int cleanupInterval = 86400000; // one day

    protected int height = -1;// unscaled, go with scale

    protected int width = -1; // unscaled, go with scale

    protected String lastImageFile = null;

    protected String postProcessingScript = null;

    protected Timer timer;

    public MagicPlanetImageComponent() {
        DEBUG = Debug.debugging("magicplanet");
    }

    /**
     * MapHandlerChild method extended through the OMComponent hierarchy. This
     * is the method called by the MapHandler with objects added to the
     * MapHandler.
     */
    public void findAndInit(Object someObj) {
        if (someObj instanceof LayerHandler) {
            setLayerHandler((LayerHandler) someObj);
        }

        if (someObj instanceof MapBean) {
            setMapBean((MapBean) someObj);
        }
    }

    /**
     * MapHandlerChild method extended through the OMComponent hierarchy. This
     * is the method called by the MapHandler with objects removed from the
     * MapHandler.
     */
    public void findAndUndo(Object someObj) {
        if (someObj instanceof LayerHandler && someObj == getLayerHandler()) {
            setLayerHandler(null);
        }

        if (someObj instanceof MapBean && someObj == getMapBean()) {
            setMapBean(null);
        }
    }

    /**
     * Get the timer being used for automatic updates. May be null if a timer is
     * not set.
     */
    public Timer getTimer() {
        return timer;
    }

    /**
     * If you want the layer to update itself at certain intervals, you can set
     * the timer to do that. Set it to null to disable it. If the current timer
     * is not null, the graphic loader is removed as an ActionListener. If the
     * new one is not null, the graphic loader is added as an ActionListener.
     */
    public void setTimer(Timer t) {
        if (timer != null) {
            timer.removeActionListener(this);
            timer.stop();
        }

        timer = t;
        if (timer != null) {
            timer.addActionListener(this);
        }
    }

    /**
     * Creates a timer with the current updateInterval and calls setTimer().
     */
    public void createTimer() {
        Timer t = new Timer(updateInterval, null);
        t.setInitialDelay(initialDelay);
        setTimer(t);
    }

    /**
     * The delay between timer pulses, in milliseconds.
     */
    public void setUpdateInterval(int delay) {
        updateInterval = delay;
        if (timer != null) {
            timer.setDelay(updateInterval);
            if (timer.isRunning()) {
                timer.restart();
            }
        }
    }

    public int getUpdateInterval() {
        return updateInterval;
    }

    public int getInitialDelay() {
        return initialDelay;
    }

    public void setInitialDelay(int initialDelay) {
        this.initialDelay = initialDelay;
    }

    /*
     * Called when the timer kicks off.
     * 
     * @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
     */
    public void actionPerformed(ActionEvent e) {
        if (false && DEBUG) {
            Debug.output("MPIC.actionPerformed("
                    + e.getSource().getClass().getName() + ")");
        }
        createImage();
    }

    /**
     * @return the object currently known as the LayerHandler by this object.
     */
    protected LayerHandler getLayerHandler() {
        return layerHandler;
    }

    /**
     * Set the LayerHandler, become a LayerListener object to it to know when
     * the layers on the MapBean change. If there is already a LayerHandler
     * known to this component, this component will remove itself as a listener
     * to the previous LayerHandler.
     * 
     * @param lh LayerHandler.
     */
    protected void setLayerHandler(LayerHandler lh) {
        if (layerHandler != null) {
            layerHandler.removeLayerListener(this);
        }

        layerHandler = lh;

        if (layerHandler != null) {
            layerHandler.addLayerListener(this);
            // calling setLayers() will kick off an image creation.
            // Don't want that right now, just setting the layers for
            // initialization purposes, we'll let events or timer
            // create the image.
            layers = layerHandler.getMapLayers();

            Timer timer = getTimer();
            if (timer == null) {
                createTimer();
            }

        }
    }