omrasterobject.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/OMRasterObject.java,v $
// $RCSfile: OMRasterObject.java,v $
// $Revision: 1.8.2.4 $
// $Date: 2005/01/10 16:59:45 $
// $Author: dietrick $
// 
// **********************************************************************

package com.bbn.openmap.omGraphics;

import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Point;
import java.awt.Toolkit;
import java.awt.geom.AffineTransform;
import java.awt.image.AreaAveragingScaleFilter;
import java.awt.image.BufferedImage;
import java.awt.image.FilteredImageSource;
import java.awt.image.ImageConsumer;
import java.awt.image.ImageFilter;
import java.awt.image.ImageObserver;
import java.awt.image.ImageProducer;
import java.awt.image.MemoryImageSource;
import java.awt.image.PixelGrabber;
import java.awt.image.RenderedImage;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

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

/**
 * The OMRasterObject is the parent class for OMRaster and OMBitmap
 * objects. It manages some of the same functions that both classes
 * require in order to create image pixel data from bytes or integers.
 * 
 * <P>
 * An ImageFilter may be applied to OMRasterObjects. These can be
 * scale filters, color filters, or maybe (?hopefully?) projection
 * filters. These filters won't change the original image data, and
 * the original can be reconstructed by resetting the filter to null,
 * and generating the object.
 * <P>
 * 
 * For all classes in the OMRasterObject family, a java.awt.Shape
 * object is created for the border of the image. This Shape object is
 * used for distance calculations. If the OMRasterObject is
 * selected(), however, this Shape will be rendered with the OMGraphic
 * parameters that are set in the OMGraphic.
 */
public abstract class OMRasterObject extends OMGraphic implements Serializable,
        ImageObserver {

    /**
     * The direct colormodel, for OMRasters, means the integer values
     * passed in as pixels, already reflect the RGB color values each
     * pixel should display.
     */
    public final static int COLORMODEL_DIRECT = 0;
    /**
     * The indexed colormodel, for OMRasters, means that the byte
     * array passed in for the pixels has to be resolved with a
     * colortable in order to create a integer array of RGB pixels.
     */
    public final static int COLORMODEL_INDEXED = 1;
    /**
     * The ImageIcon colormodel means that the image is externally
     * set, and we just want to to display the image at the given
     * location.
     */
    public final static int COLORMODEL_IMAGEICON = 2;
    /** If scaling the image, use the slower, smoothing algorithm. */
    public final static int SMOOTH_SCALING = 0;
    /**
     * If scaling the image, use the faster, replicating/clipping
     * algorithm.
     */
    public final static int FAST_SCALING = 1;
    /**
     * colorModel helps figure out what kind of updates are necessary,
     * by knowing what kind of image we're dealing with. For the
     * images created with a ImageIcon, the attribute updates that
     * don't relate to position will not take affect.
     */
    protected int colorModel = COLORMODEL_DIRECT;
    /**
     * The pixels are used for the image that is drawn on the window.
     * The pixels are either passed in as an int[] in some
     * constructors of the OMRaster, or it is constructed in the
     * OMBitmap and in OMRasters that have a colortable.
     */
    protected int[] pixels = null;

    /**
     * Horizontal location of the upper left corner of the image, or
     * the x offset from the lon for that corner, in pixels.
     */
    protected int x = 0;

    /**
     * Vertical location of the upper left corner of the image, or the
     * y offset from the lat for that corner, in pixels.
     */
    protected int y = 0;

    /**
     * The latitude of the upper left corner for the image, in decimal
     * degrees.
     */
    protected float lat = 0.0f;

    /**
     * The longitude of the upper left corner for the image, in
     * decimal degrees.
     */
    protected float lon = 0.0f;

    /**
     * The width of the image, in pixels. This always reflects the
     * width of the original image, even if a filter is applied to the
     * image.
     */
    protected int width = 0;

    /**
     * The height of the image, in pixels. This always reflects the
     * height of the original image, even if a filter is applied to
     * the image.
     */
    protected int height = 0;

    /**
     * The byte info for the image. OMBitmaps use each bit as an
     * indication to use the lineColor or the fillColor for each pixel
     * (like a XBitmap). OMRasters only use the bits when the image
     * being created follows the indexed colormodel. Then, the bits
     * hold the colortable indexes that each pixel needs to have a
     * color substituted in later.
     */
    protected byte[] bits = null;

    /** The bitmap is drawn to the graphics. */
    protected transient Image bitmap = null;

    /**
     * Projected window pixel location of the upper left corner of the
     * image.
     */
    protected Point point1 = null;

    /**
     * Projected window pixel location of the lower right corner of
     * the image.
     */
    protected Point point2 = null;

    /**
     * The width of the image after scaling, if you want the image to
     * be a different size than the source.
     */
    protected int filteredWidth = 0;

    /**
     * The height of the image after scaling, if you want the image to
     * be a different size than the source.
     */
    protected int filteredHeight = 0;

    /** The image filter to use on the constructed image. */
    protected ImageFilter imageFilter = null;

    /**
     * Set if the projection has had attributes change that require a
     * repositioning of the image, not a regeneration.
     */
    protected boolean needToReposition = true;

    /**
     * Pixel height of the current projection. Used for efficient
     * zoom-in scaling.
     */
    int projHeight;

    /**
     * Pixel width of the current projection. Used for efficient
     * zoom-in scaling.
     */
    int projWidth;

    /** the angle by which the image is to be rotated, in radians */
    protected double rotationAngle;

    protected boolean DEBUG = false;

    /**
     * A Contructor that sets the graphic type to raster, render type
     * to unknown, line type to unknown, and the declutter type to
     * none.
     */
    public OMRasterObject() {
        super(RENDERTYPE_UNKNOWN, LINETYPE_UNKNOWN, DECLUTTERTYPE_NONE);
        DEBUG = Debug.debugging("omraster");
    }

    /**
     * A Contructor that sets the graphic type, render type, line type
     * and the declutter type to the values you pass in. See OMGraphic
     * for the definitions of these attributes.
     * 
     * @param rType render type
     * @param lType line type
     * @param dcType declutter type
     */
    public OMRasterObject(int rType, int lType, int dcType) {
        super(rType, lType, dcType);
        DEBUG = Debug.debugging("omraster");
    }

    /**
     * The color model is set based on the constructor. This setting
     * controls what parameter changes are posiible for different
     * models of images.
     * 
     * @param cm the colormode that describes how the colors are being
     *        set - COLORMODEL_DIRECT, COLORMODEL_INDEXED, or
     *        COLORMODEL_IMAGEICON.
     */
    protected void setColorModel(int cm) {
        colorModel = cm;
    }

    /**
     * Get the color model type of the image.
     * 
     * @return COLORMODEL_DIRECT, COLORMODEL_INDEXED, or
     *         COLORMODEL_IMAGEICON.
     */
    public int getColorModel() {
        return colorModel;
    }

    /**
     * Set the flag for the object that lets the render method (which
     * draws the object) know that the object needs to be repositioned
     * first.
     */
    public void setNeedToReposition(boolean value) {
        needToReposition = value;
    }

    /** Return the reposition status. */
    public boolean getNeedToReposition() {
        return needToReposition;
    }

    /**
     * Set the angle by which the image is to rotated.
     * 
     * @param angle the number of radians the image is to be rotated.
     *        Measured clockwise from horizontal.
     */
    public void setRotationAngle(double angle) {
        this.rotationAngle = angle;
        setNeedToRegenerate(true);
    }

    /**
     * Get the current rotation of the image.
     * 
     * @return the image rotation.
     */
    public double getRotationAngle() {
        return rotationAngle;
    }

    /**
     * Compute the raster objects pixels, based on the color model and
     * the byte values.
     * 
     * @return true if everything goes OK (height*width =
     *         pixel.length, etc.).
     */
    protected abstract boolean computePixels();

    /**
     * Called from within render(). This method should call rotate()
     * on the provided Graphics2D object, setting the rotation angle
     * and the rotation point. By default, the rotation angle is
     * whatever is set in the OMRasterObject, and the rotation point
     * is the offset point plus half the image width in the horizonal
     * direction, and half the image in the vertical direction.
     */
    protected void rotate(Graphics2D g) {
        int w = width;
        int h = height;

        if (shape != null) {
            java.awt.Rectangle rect = shape.getBounds();
            w = (int) rect.getWidth();
            h = (int) rect.getHeight();
        }

        ((Graphics2D) g).rotate(rotationAngle, point1.x + w / 2, point1.y + h
                / 2);
    }

    /**
     * Render the raster on the java.awt.Graphics
     * 
     * @param g java.awt.Graphics to draw the image on.
     */
    public void render(Graphics g) {
        if (getNeedToRegenerate() || getNeedToReposition() || !isVisible()) {
            if (DEBUG) {
                Debug.output("OMRasterObject.render(): need to regenerate or not visible!");
            }
            return;
        }

        //copy the graphic, so our transform doesn't cascade to
        // others...
        g = g.create();

        // Just a little check to find out if someone is rushing
        // things. If a Image isn't fully loaded, the getWidth will
        // return -1. This is just a courtesy notification in case
        // someone isn't seeing their image, and don't know why.
        if (colorModel == COLORMODEL_IMAGEICON && (getWidth() == -1)) {