omscalingraster.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/omGraphics/OMScalingRaster.java,v $
// $RCSfile: OMScalingRaster.java,v $
// $Revision: 1.3.2.8 $
// $Date: 2005/08/09 21:17:45 $
// $Author: dietrick $
// 
// **********************************************************************

package com.bbn.openmap.omGraphics;

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.geom.AffineTransform;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import java.io.Serializable;

import javax.swing.ImageIcon;

import com.bbn.openmap.proj.Projection;
import com.bbn.openmap.util.Debug;

/**
 * This is an extension to OMRaster that automatically scales itelf to
 * match the current projection. It is only lat/lon based, and takes
 * the coordinates of the upper left and lower right corners of the
 * image. It does straight scaling - it does not force the image
 * projection to match the map projection! So, your mileage may vary -
 * you have to understand the projection of the image, and know how it
 * fits the projection type of the map. Of course, at larger scales,
 * it might not matter so much.
 * 
 * This class was inspired by, and created from parts of the
 * ImageLayer submission from Adrian Lumsden@sss, on 25-Jan-2002. Used
 * the scaling and trimming code from that submission. That code was
 * also developed with assistance from Steve McDonald at
 * SiliconSpaceships.com.
 * 
 * @see OMRaster
 * @see OMRasterObject
 */
public class OMScalingRaster extends OMRaster implements Serializable {

    /**
     * The latitude of the lower right corner for the image, in
     * decimal degrees.
     */
    protected float lat2 = 0.0f;

    /**
     * The longitude of the lower right corner for the image, in
     * decimal degrees.
     */
    protected float lon2 = 0.0f;

    /**
     * This the original version of the image, which we keep around
     * for rescaling later.
     */
    protected BufferedImage sourceImage = null;

    /**
     * The rectangle in screen co-ordinates that the scaled image
     * projects to after clipping.
     */
    protected Rectangle clipRect;

    /**
     * Constuct a blank OMRaster, to be filled in with set calls.
     */
    public OMScalingRaster() {
        super();
    }

    ///////////////////////////////////// INT PIXELS - DIRECT
    // COLORMODEL

    /**
     * Creates an OMRaster images, Lat/Lon placement with a direct
     * colormodel image.
     * 
     * @param ullat latitude of the top of the image.
     * @param ullon longitude of the left side of the image.
     * @param lrlat latitude of the bottom of the image.
     * @param lrlon longitude of the right side of the image.
     * @param w width of the image, in pixels.
     * @param h height of the image, in pixels.
     * @param pix color values for the pixels.
     */
    public OMScalingRaster(float ullat, float ullon, float lrlat, float lrlon,
            int w, int h, int[] pix) {

        super(ullat, ullon, w, h, pix);
        lat2 = lrlat;
        lon2 = lrlon;
    }

    ////////////////////////////////////// IMAGEICON

    /**
     * Create an OMRaster, Lat/Lon placement with an ImageIcon.
     * 
     * @param ullat latitude of the top of the image.
     * @param ullon longitude of the left side of the image.
     * @param lrlat latitude of the bottom of the image.
     * @param lrlon longitude of the right side of the image.
     * @param ii ImageIcon used for the image.
     */
    public OMScalingRaster(float ullat, float ullon, float lrlat, float lrlon,
            ImageIcon ii) {
        this(ullat, ullon, lrlat, lrlon, ii.getImage());
    }

    /**
     * Create an OMRaster, Lat/Lon placement with an Image.
     * 
     * @param ullat latitude of the top of the image.
     * @param ullon longitude of the left side of the image.
     * @param lrlat latitude of the bottom of the image.
     * @param lrlon longitude of the right side of the image.
     * @param ii Image used for the image.
     */
    public OMScalingRaster(float ullat, float ullon, float lrlat, float lrlon,
            Image ii) {
        super();
        setRenderType(OMGraphic.RENDERTYPE_LATLON);
        setColorModel(COLORMODEL_IMAGEICON);

        lat = ullat;
        lon = ullon;
        lat2 = lrlat;
        lon2 = lrlon;
        setImage(ii);
    }

    ////////////////////////////////////// BYTE PIXELS with
    // COLORTABLE

    /**
     * Lat/Lon placement with a indexed colormodel, which is using a
     * colortable and a byte array to contruct the int[] pixels.
     * 
     * @param ullat latitude of the top of the image.
     * @param ullon longitude of the left side of the image.
     * @param lrlat latitude of the bottom of the image.
     * @param lrlon longitude of the right side of the image.
     * @param w width of the image, in pixels.
     * @param h height of the image, in pixels.
     * @param bytes colortable index values for the pixels.
     * @param colorTable color array corresponding to bytes
     * @param trans transparency of image.
     */
    public OMScalingRaster(float ullat, float ullon, float lrlat, float lrlon,
            int w, int h, byte[] bytes, Color[] colorTable, int trans) {

        super(ullat, ullon, w, h, bytes, colorTable, trans);
        lat2 = lrlat;
        lon2 = lrlon;
    }

    /**
     * Creates a BufferedImage version of the image. A new
     * BufferedImage object is created, and the image is copied into
     * it. You can get rid of the input image after calling this
     * method. The OMRaster variables height, width and bitmap are set
     * here to the values for the new BufferedImage.
     * 
     * @param image the input image.
     */
    public void setImage(Image image) {
        if (DEBUG) {
            Debug.output("OMScalingRaster.setImage: " + image);
        }

        if (image == null) {
            return;
        }

        if (!(image instanceof BufferedImage)) {
            sourceImage = new BufferedImage(image.getWidth(this), image.getHeight(this), BufferedImage.TYPE_INT_ARGB);
            Graphics2D g2D = sourceImage.createGraphics();
            g2D.drawImage(image, 0, 0, this);
        } else {
            sourceImage = (BufferedImage) image;
        }

        width = sourceImage.getWidth();
        height = sourceImage.getHeight();

        // Just in case rendering tries to happen.
        bitmap = sourceImage;
    }

    /**
     * Since the image doesn't necessarily need to be regenerated when
     * it is merely moved, raster objects have this function, called
     * from generate() and when a placement attribute is changed.
     * 
     * @return true if enough information is in the object for proper
     *         placement.
     * @param proj projection of window.
     */
    protected boolean position(Projection proj) {

        if (proj == null) {
            if (DEBUG) {
                Debug.error("OMScalingRaster: null projection in position!");
            }
            return false;
        }

        point1 = proj.forward(lat, lon);
        point2 = proj.forward(lat2, lon2);

        setNeedToReposition(false);
        return true;
    }

    /**
     * Prepare the graphics for rendering. For all image types, it
     * positions the image relative to the projection. For direct and
     * indexed colormodel images, it creates the ImageIcon used for
     * drawing to the window (internal to object). For indexed
     * colormodel images, it also calls computePixels, to resolve the
     * colortable and the bytes to create the image pixels.
     * 
     * @param proj Projection used to position the image on the
     *        window.
     * @return true if the image is ready to paint.
     */
    public boolean generate(Projection proj) {
        this.shape = null;
        
        // Position sets the position for the OMRaster!!!!
        if (!position(proj)) {
            if (DEBUG) {
                Debug.error("OMRaster.generate(): positioning failed!");
            }
            return false;
        }

        if (colorModel != COLORMODEL_IMAGEICON) {
            // If the sourceImage hasn't been created, and needs to
            // be, then just do what we normally do in OMRaster.
            if (sourceImage == null || getNeedToRegenerate()) {
                if (DEBUG) {
                    Debug.output("OMScalingRaster: generating image");
                }
                super.generate(proj);
                // bitmap is set to a BufferedImage
                setImage(bitmap);
            }
        }

        // point1 and point2 are already set in position()

        // We assume that the image doesn't cross the dateline, and
        // that p1 is upper left corner, and p2 is lower right.
        // scaleTo modifies the internal bitmap image for display.
        scaleTo(proj);

        if (bitmap != null) {
            // generate shape that is a boundary of the generated
            // image.
            // We'll make it a GeneralPath rectangle.
            int w = bitmap.getWidth(this);
            int h = bitmap.getHeight(this);

            setShape(createBoxShape(point1.x, point1.y, w, h));

            setNeedToRegenerate(false);