ompoly.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/OMPoly.java,v $
// $RCSfile: OMPoly.java,v $
// $Revision: 1.10.2.7 $
// $Date: 2005/08/11 21:03:22 $
// $Author: dietrick $
//
// **********************************************************************

package com.bbn.openmap.omGraphics;

import java.awt.BasicStroke;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Paint;
import java.awt.Point;
import java.awt.geom.GeneralPath;
import java.io.Serializable;
import java.util.ArrayList;

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

/**
 * Graphic object that represents a polygon or polyline
 * (multi-line-segment-object).
 * <p>
 * 
 * The differentiator between polygons and polylines is the fill
 * color. If the fillPaint is equal to OMColor.clear, then the poly
 * will be considered a polyline. There are methods to override this
 * in the OMPoly class, but they do play around with the fillPaint,
 * depending on the order in which the methods are called. If you know
 * it's a polyline, call setIsPolygon(false) if you think that the
 * fillPaint could be set to anything other than the default,
 * OMColor.clear.
 * <P>
 * 
 * All of the OMGraphics are moving to having their internal
 * representation as java.awt.Shape objects. Unfortunately, this has
 * the side effect of slowing OMPolys down, because the way that the
 * projection classes handle transformations cause more objects to be
 * allocated and more loops to be run through. So, by default, the
 * OMPoly does NOT use Shape objects internally, to keep layers that
 * throw down many, many polys running quickly. If you want to do some
 * spatial analysis on an OMPoly, call setDoShapes(true) on it, then
 * generate(Projection), and then call getShapes() to get the
 * java.awt.Shape objects for the poly. You can then run the different
 * Shape spatial analysis methods on the Shape objects.
 * 
 * <h3>NOTES:</h3>
 * <ul>
 * <li>See the <a
 * href="../../../../com.bbn.openmap.proj.Projection.html#poly_restrictions">
 * RESTRICTIONS </a> on Lat/Lon polygons/polylines. Not following the
 * guidelines listed may result in ambiguous/undefined shapes! Similar
 * assumptions apply to the other vector graphics that we define:
 * circles, ellipses, rects, lines.
 * <li>LatLon OMPolys store latlon coordinates internally in radian
 * format for efficiency in projecting. Subclasses should follow this
 * model.
 * <li>Holes in the poly are not supported.
 * <p>
 * </ul>
 * <h3>TODO:</h3>
 * <ul>
 * <li>Polar filled-polygon correction for Cylindrical projections
 * (like OMCircle).
 * </ul>
 * 
 * @see OMCircle
 * @see OMRect
 * @see OMLine
 */
public class OMPoly extends OMAbstractLine implements Serializable {

    /**
     * Translation offsets. For RENDERTYPE_OFFSET, the xy points are
     * relative to the position of fixed latlon point.
     */
    public final static int COORDMODE_ORIGIN = 0;

    /**
     * Delta offsets. For RENDERTYPE_OFFSET, each xy point in the
     * array is relative to the previous point, and the first point is
     * relative to the fixed latlon point.
     */
    public final static int COORDMODE_PREVIOUS = 1;

    /**
     * Radians or decimal degrees. After construction and conversion,
     * this should always be radians.
     */
    protected int units = -1;// this should be set correctly at
    // construction

    /**
     * For RENDERTYPE_OFFSET, the latitude of the starting point of
     * the poly. Stored as radians!
     */
    protected float lat = 0.0f;

    /**
     * For RENDERTYPE_OFFSET, the longitude of the starting point of
     * the poly. Stored as radians!
     */
    protected float lon = 0.0f;

    /**
     * For RENDERTYPE_OFFSET, type of offset.
     * 
     * @see #COORDMODE_ORIGIN
     * @see #COORDMODE_PREVIOUS
     */
    protected int coordMode = COORDMODE_ORIGIN;

    /**
     * The x array of ints, representing pixels, used for x/y or
     * offset polys.
     */
    protected int[] xs = null;

    /**
     * The y array of ints, representing pixels, used for x/y or
     * offset polys.
     */
    protected int[] ys = null;

    /**
     * Poly is a polygon or a polyline. This is true if the fillColor
     * is not clear, false if it is.
     */
    protected boolean isPolygon = false;

    /** raw float lats and lons stored internally in radians. */
    protected float[] rawllpts = null;

    /**
     * Flag for telling the OMPoly to use the Shape objects to
     * represent itself internally. See intro for more info.
     */
    protected boolean doShapes = false;

    /**
     * Construct a default OMPoly.
     */
    public OMPoly() {
        super(RENDERTYPE_UNKNOWN, LINETYPE_UNKNOWN, DECLUTTERTYPE_NONE);
    }

    /**
     * Create an OMPoly from a list of float lat/lon pairs.
     * <p>
     * NOTES:
     * <ul>
     * <li>llPoints array is converted into radians IN PLACE for more
     * efficient handling internally if it's not already in radians!
     * For even better performance, you should send us an array
     * already in radians format!
     * <li>If you want the poly to be connected (as a polygon), you
     * need to ensure that the first and last coordinate pairs are the
     * same.
     * </ul>
     * 
     * @param llPoints array of lat/lon points, arranged lat, lon,
     *        lat, lon, etc.
     * @param units radians or decimal degrees. Use OMGraphic.RADIANS
     *        or OMGraphic.DECIMAL_DEGREES
     * @param lType line type, from a list defined in OMGraphic.
     */
    public OMPoly(float[] llPoints, int units, int lType) {
        this(llPoints, units, lType, -1);
    }

    /**
     * Create an OMPoly from a list of float lat/lon pairs.
     * <p>
     * NOTES:
     * <ul>
     * <li>llPoints array is converted into radians IN PLACE for more
     * efficient handling internally if it's not already in radians!
     * For even better performance, you should send us an array
     * already in radians format!
     * <li>If you want the poly to be connected (as a polygon), you
     * need to ensure that the first and last coordinate pairs are the
     * same.
     * </ul>
     * 
     * @param llPoints array of lat/lon points, arranged lat, lon,
     *        lat, lon, etc.
     * @param units radians or decimal degrees. Use OMGraphic.RADIANS
     *        or OMGraphic.DECIMAL_DEGREES
     * @param lType line type, from a list defined in OMGraphic.
     * @param nsegs number of segment points (only for
     *        LINETYPE_GREATCIRCLE or LINETYPE_RHUMB line types, and
     *        if &lt; 1, this value is generated internally)
     */
    public OMPoly(float[] llPoints, int units, int lType, int nsegs) {
        super(RENDERTYPE_LATLON, lType, DECLUTTERTYPE_NONE);
        setLocation(llPoints, units);
        this.nsegs = nsegs;
    }

    /**
     * Create an OMPoly from a list of xy pairs. If you want the poly
     * to be connected, you need to ensure that the first and last
     * coordinate pairs are the same.
     * 
     * @param xypoints array of x/y points, arranged x, y, x, y, etc.
     */
    public OMPoly(int[] xypoints) {
        super(RENDERTYPE_XY, LINETYPE_UNKNOWN, DECLUTTERTYPE_NONE);
        setLocation(xypoints);
    }

    /**
     * Create an x/y OMPoly. If you want the poly to be connected, you
     * need to ensure that the first and last coordinate pairs are the
     * same.
     * 
     * @param xPoints int[] of x coordinates
     * @param yPoints int[] of y coordinates
     */
    public OMPoly(int[] xPoints, int[] yPoints) {
        super(RENDERTYPE_XY, LINETYPE_UNKNOWN, DECLUTTERTYPE_NONE);

        setLocation(xPoints, yPoints);
    }

    /**
     * Create an x/y OMPoly at an offset from lat/lon. If you want the
     * poly to be connected, you need to ensure that the first and
     * last coordinate pairs are the same.
     * 
     * @param latPoint latitude in decimal degrees
     * @param lonPoint longitude in decimal degrees
     * @param xypoints int[] of x,y pairs
     * @param cMode offset coordinate mode
     */
    public OMPoly(float latPoint, float lonPoint, int[] xypoints, int cMode) {
        super(RENDERTYPE_OFFSET, LINETYPE_UNKNOWN, DECLUTTERTYPE_NONE);

        setLocation(latPoint, lonPoint, OMGraphic.DECIMAL_DEGREES, xypoints);
        coordMode = cMode;
    }

    /**
     * Create an x/y OMPoly at an offset from lat/lon. If you want the
     * poly to be connected, you need to ensure that the first and
     * last coordinate pairs are the same.
     * 
     * @param latPoint latitude in decimal degrees
     * @param lonPoint longitude in decimal degrees
     * @param xPoints int[] of x coordinates
     * @param yPoints int[] of y coordinates
     * @param cMode offset coordinate mode
     */
    public OMPoly(float latPoint, float lonPoint, int[] xPoints, int[] yPoints,
            int cMode) {
        super(RENDERTYPE_OFFSET, LINETYPE_UNKNOWN, DECLUTTERTYPE_NONE);

        setLocation(latPoint,
                lonPoint,
                OMGraphic.DECIMAL_DEGREES,
                xPoints,
                yPoints);
        coordMode = cMode;
    }

    /**
     * Set an OMPoly from a list of float lat/lon pairs.
     * <p>
     * NOTES:
     * <ul>
     * <li>llPoints array is converted into radians IN PLACE for more
     * efficient handling internally if it's not already in radians!
     * If you don't want the array to be changed, send in a copy.
     * <li>If you want the poly to be connected (as a polygon), you
     * need to ensure that the first and last coordinate pairs are the
     * same.
     * </ul>
     * This is for RENDERTYPE_LATLON polys.
     * 
     * @param llPoints array of lat/lon points, arranged lat, lon,
     *        lat, lon, etc.
     * @param units radians or decimal degrees. Use OMGraphic.RADIANS
     *        or OMGraphic.DECIMAL_DEGREES
     */
    public void setLocation(float[] llPoints, int units) {
        this.units = OMGraphic.RADIANS;
        if (units == OMGraphic.DECIMAL_DEGREES) {
            ProjMath.arrayDegToRad(llPoints);
        }
        rawllpts = llPoints;
        setNeedToRegenerate(true);
        setRenderType(RENDERTYPE_LATLON);
    }

    /**
     * Set an OMPoly from a list of xy pixel pairs. If you want the
     * poly to be connected, you need to ensure that the first and
     * last coordinate pairs are the same. This is for RENDERTYPE_XY
     * polys.
     * 
     * @param xypoints array of x/y points, arranged x, y, x, y, etc.
     */
    public void setLocation(int[] xypoints) {
        int end = xypoints.length >> 1;
        xs = new int[end];
        ys = new int[end];
        for (int i = 0, j = 0; i < end; i++, j += 2) {
            xs[i] = xypoints[j];
            ys[i] = xypoints[j + 1];
        }
        setNeedToRegenerate(true);
        setRenderType(RENDERTYPE_XY);
    }

    /**
     * Set an OMPoly from a x/y coordinates. If you want the poly to
     * be connected, you need to ensure that the first and last