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

package com.bbn.openmap.omGraphics;

import java.awt.Color;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.Serializable;

import javax.swing.ImageIcon;

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

/**
 * The OMRaster object lets you create multi-colored images. An image
 * is a two dimensional array of pixel values that correspond to some
 * color values. The pixels are used from the top left, across each
 * row to the right, down to the bottom row.
 * <p>
 * There are two colormodels that are implemented in OMRaster - the
 * direct colormodel and the indexed colormodel. The direct colormodel
 * is implemented when the pixel values contain the actual
 * java.awt.Color values for the image. The indexed colormodel is
 * implemented when the pixel values are actually indexes into an
 * array of java.awt.Colors. NOTE: The direct colormodel OMRaster is
 * faster to display, because it doesn't need to take the time to
 * resolve the colortable values into pixels.
 * <P>
 * 
 * For direct colormodel images: If you pass in a null pix or a pix
 * with a zero length, the object will create the pixels for you but
 * will not general a renderable version of the object. You will need
 * to call render before generate after the pixels have been set. This
 * feature is for cached rasters, where the content may be changed
 * later. Use this (null pix) if you are building images in a cache,
 * for tiled mapping data or something else where the data is not yet
 * known. The memory for the pixels will be allocated, and then they
 * can be set with image data later when a database is accessed.
 * <P>
 * 
 * For ImageIcon OMRasters: Using an ImageIcon to create an OMRaster
 * gives you the ability to put an image on the screen based on an
 * ImageIcon made from file or URL. The OMRaster uses this ImageIcon
 * as is - there is no opportunity to change any parameters of this
 * image. So set the colors, transparency, etc. before you create the
 * OMRaster.
 * <P>
 * 
 * For indexed colormodel images: If you pass in an empty byte array,
 * a byte array will be created based on the width and height. You
 * will have to resolve empty colortables and set the pixels later.
 * Use this method (null bytes) if you are building images in a cache,
 * for tiled mapping data or something else where the data is not yet
 * known. The memory for the pixels will be allocated, and then they
 * can be set with image data later when a database is accessed.
 * 
 * There is the ability to add a filter to the image, to change it's
 * appearance for rendering. The most common filter, which is included
 * as a kind of default, is the scale filter. Filtering the
 * OMRasterObject replaces the bitmap variable, which is the internal
 * java.awt.Image used for rendering. For OMRasters created with
 * pixels, or with the colortable and the colortable index, the
 * original data is left intact, and can be recreated later, or
 * rescaled on the fly, because the internal bitmap will be recreated
 * prior to rescaling. For OMRasters created by ImageIcons or Images,
 * though, you'll need to hold on to the original Image. The internal
 * version is replaced by the filtered version.
 * 
 * @see OMRasterObject
 */
public class OMRaster extends OMRasterObject implements Serializable {

    /**
     * The integer colors that are needed in a java colortable. The
     * Color[] that gets passed into some of the constructors goes to
     * build this, but this array is really used to build the image
     * pixel array.
     */
    protected int[] colors = null;

    /**
     * The transparency of the image. If this is set to anything less
     * than 255, this value is used for all colors in the image. If it
     * is set to 255, then the alpha value in each Color regulates the
     * transparency of the image. The value of this variable should
     * stay in the range: <code>0 &lt;= transparent &lt;= 255</code>
     */
    protected int transparent = 255;

    /**
     * Constuct a blank OMRaster, to be filled in with setX calls.
     */
    public OMRaster() {
        super(RENDERTYPE_UNKNOWN, LINETYPE_UNKNOWN, DECLUTTERTYPE_NONE);
    }

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

    /**
     * Creates an OMRaster images, Lat/Lon placement with a direct
     * colormodel.
     * 
     * @param lt latitude of the top of the image.
     * @param ln longitude of the left 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.
     * @see #setPixel
     */
    public OMRaster(float lt, float ln, int w, int h, int[] pix) {

        super(RENDERTYPE_LATLON, LINETYPE_UNKNOWN, DECLUTTERTYPE_NONE);
        setColorModel(COLORMODEL_DIRECT);
        lat = lt;
        lon = ln;
        width = w;
        height = h;
        pixels = pix;

        if (pixels == null || pixels.length == 0)
            pixels = new int[height * width];
    }

    /**
     * Create an OMRaster image, XY placement with a direct
     * colormodel.
     * 
     * @param x1 window location of the left side of the image.
     * @param y1 window location of the top 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.
     * @see #setPixel
     */
    public OMRaster(int x1, int y1, int w, int h, int[] pix) {

        super(RENDERTYPE_XY, LINETYPE_UNKNOWN, DECLUTTERTYPE_NONE);
        setColorModel(COLORMODEL_DIRECT);
        x = x1;
        y = y1;
        width = w;
        height = h;
        pixels = pix;

        if (pixels == null || pixels.length == 0)
            pixels = new int[height * width];
    }

    /**
     * Create an OMRaster, Lat/lon placement with XY offset with a
     * direct colormodel.
     * 
     * @param lt latitude of the top of the image, before the offset.
     * @param ln longitude of the left side of the image, before the
     *        offset.
     * @param offset_x1 number of pixels to move image to the right.
     * @param offset_y1 number of pixels to move image down.
     * @param w width of the image, in pixels.
     * @param h height of the image, in pixels.
     * @param pix color values for the pixels.
     * @see #setPixel
     */
    public OMRaster(float lt, float ln, int offset_x1, int offset_y1, int w,
            int h, int[] pix) {

        super(RENDERTYPE_OFFSET, LINETYPE_UNKNOWN, DECLUTTERTYPE_NONE);
        setColorModel(COLORMODEL_DIRECT);
        lat = lt;
        lon = ln;
        x = offset_x1;
        y = offset_y1;
        width = w;
        height = h;
        pixels = pix;

        if (pixels == null || pixels.length == 0) {
            pixels = new int[height * width];
        }
    }

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

    /**
     * Create an OMRaster, Lat/Lon placement with an ImageIcon.
     * 
     * @param lt latitude of the top of the image.
     * @param ln longitude of the left side of the image.
     * @param ii ImageIcon used for the image.
     */
    public OMRaster(float lt, float ln, ImageIcon ii) {
        this(lt, ln, ii.getImage());
    }

    /**
     * Create an OMRaster, Lat/Lon placement with an Image.
     * 
     * @param lt latitude of the top of the image.
     * @param ln longitude of the left side of the image.
     * @param ii Image used for the image.
     */
    public OMRaster(float lt, float ln, Image ii) {
        super(RENDERTYPE_LATLON, LINETYPE_UNKNOWN, DECLUTTERTYPE_NONE);
        setColorModel(COLORMODEL_IMAGEICON);
        lat = lt;
        lon = ln;
        setImage(ii);
    }

    /**
     * Create an OMRaster image, X/Y placement with an ImageIcon.
     * 
     * @param x1 window location of the left side of the image.
     * @param y1 window location of the top of the image.
     * @param ii ImageIcon used for the image.
     */
    public OMRaster(int x1, int y1, ImageIcon ii) {
        this(x1, y1, ii.getImage());
    }

    /**
     * Create an OMRaster image, X/Y placement with an Image.
     * 
     * @param x1 window location of the left side of the image.
     * @param y1 window location of the top of the image.
     * @param ii Image used for the image.
     */
    public OMRaster(int x1, int y1, Image ii) {
        super(RENDERTYPE_XY, LINETYPE_UNKNOWN, DECLUTTERTYPE_NONE);
        setColorModel(COLORMODEL_IMAGEICON);
        x = x1;
        y = y1;
        setImage(ii);
    }

    /**
     * Create an OMRaster, Lat/Lon with X/Y placement with an
     * ImageIcon.
     * 
     * @param lt latitude of the top of the image, before the offset.
     * @param ln longitude of the left side of the image, before the
     *        offset.
     * @param offset_x1 number of pixels to move image to the right.
     * @param offset_y1 number of pixels to move image down.
     * @param ii ImageIcon used for the image.
     */
    public OMRaster(float lt, float ln, int offset_x1, int offset_y1,
            ImageIcon ii) {
        this(lt, ln, offset_x1, offset_y1, ii.getImage());
    }

    /**
     * Create an OMRaster, Lat/Lon with X/Y placement with an Image.
     * Make sure that the Image is complete( if being loaded over the
     * internet) and ready to be drawn. Otherwise, you have to figure
     * out when the Image is complete, so that you can get the layer
     * to paint it! Use the ImageIcon constructor if you don't mind
     * blocking to wait for the pixels to arrive.
     * 
     * @param lt latitude of the top of the image, before the offset.
     * @param ln longitude of the left side of the image, before the
     *        offset.
     * @param offset_x1 number of pixels to move image to the right.
     * @param offset_y1 number of pixels to move image down.
     * @param ii Image used for the image.
     */
    public OMRaster(float lt, float ln, int offset_x1, int offset_y1, Image ii) {

        super(RENDERTYPE_OFFSET, LINETYPE_UNKNOWN, DECLUTTERTYPE_NONE);
        setColorModel(COLORMODEL_IMAGEICON);
        lat = lt;
        lon = ln;
        x = offset_x1;
        y = offset_y1;
        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 lt latitude of the top of the image.
     * @param ln longitude of the left 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.
     * @see #setPixel
     */
    public OMRaster(float lt, float ln, int w, int h, byte[] bytes,
            Color[] colorTable, int trans) {

        super(RENDERTYPE_LATLON, LINETYPE_UNKNOWN, DECLUTTERTYPE_NONE);
        setColorModel(COLORMODEL_INDEXED);
        lat = lt;
        lon = ln;
        width = w;
        height = h;
        bits = bytes;
        transparent = trans;
        if (colorTable != null) {
            setColors(colorTable);
        }

        if (bits != null && bits.length != 0) {
            if (colorTable != null && colors.length != 0) {
                computePixels();
            }
        } else {
            bits = new byte[height * width];
        }
    }

    /**
     * XY placement with a indexed colormodel, which is using a
     * colortable and a byte array to contruct the int[] pixels.
     * 
     * @param x1 window location of the left side of the image.
     * @param y1 window location of the top 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.
     * @see #setPixel
     */
    public OMRaster(int x1, int y1, int w, int h, byte[] bytes,
            Color[] colorTable, int trans) {

        super(RENDERTYPE_XY, LINETYPE_UNKNOWN, DECLUTTERTYPE_NONE);
        setColorModel(COLORMODEL_INDEXED);
        x = x1;
        y = y1;
        width = w;
        height = h;
        bits = bytes;
        transparent = trans;
        if (colorTable != null) {
            setColors(colorTable);
        }

        if (bits != null && bits.length != 0) {
            if (colorTable != null && colors.length != 0) {
                computePixels();
            }
        } else {
            bits = new byte[height * width];
        }
    }

    /**
     * Lat/lon placement with XY offset with a indexed colormodel,
     * which is using a colortable and a byte array to construct the
     * int[] pixels.
     * 
     * @param lt latitude of the top of the image, before the offset.
     * @param ln longitude of the left side of the image, before the
     *        offset.
     * @param offset_x1 number of pixels to move image to the right.
     * @param offset_y1 number of pixels to move image down.
     * @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.
     * @see #setPixel
     */
    public OMRaster(float lt, float ln, int offset_x1, int offset_y1, int w,
            int h, byte[] bytes, Color[] colorTable, int trans) {

        super(RENDERTYPE_OFFSET, LINETYPE_UNKNOWN, DECLUTTERTYPE_NONE);
        setColorModel(COLORMODEL_INDEXED);
        lat = lt;
        lon = ln;
        x = offset_x1;
        y = offset_y1;
        width = w;
        height = h;
        transparent = trans;
        bits = bytes;
        if (colorTable != null) {
            setColors(colorTable);
        }

        if (bits != null && bits.length != 0) {
            if (colorTable != null && colors.length != 0) {
                computePixels();
            }
        } else {
            bits = new byte[height * width];
        }
    }

    //////////////////////////////////////////////////////
    /**
     * Just a simple check to see if the x, y pair actually fits into