omrangerings.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/OMRangeRings.java,v $
// $RCSfile: OMRangeRings.java,v $
// $Revision: 1.3.2.3 $
// $Date: 2005/12/22 23:14:24 $
// $Author: dietrick $
// 
// **********************************************************************

package com.bbn.openmap.omGraphics;

import java.awt.Graphics;
import java.io.Serializable;

import com.bbn.openmap.LatLonPoint;
import com.bbn.openmap.proj.Length;
import com.bbn.openmap.proj.Projection;

/**
 * An object that manages a series of range circles. It is really an OMCircle
 * that manages a set of inner circles and an OMPOint. The location of these
 * inner circles depend on two new variables, the interval and intervalUnits. If
 * the intervalUnits are null, then the interval represents the number of inner
 * circles, not including the outer ring and the innermost point, that are
 * spaced evenly between them. If the intervalUnits are not null, then the
 * interval represents the number of intervalUnits where inner circles are
 * placed. For example, if the intervalUnits is Length.MILE, and the interval is
 * 5, then inner circles will be placed every 5 miles. If the intervalUnits is
 * null, then there will be 5 inner circles drawn between the center point and
 * the outer ring.
 * 
 * @see OMCircle
 */
public class OMRangeRings extends OMCircle implements Serializable {
    /** The inner ring of circles. */
    protected transient OMCircle[] subCircles = null;
    /** The labels for the circles. */
    protected transient OMText[] labels = null;

    /** By default, there are 3 inner rings, 4 total. */
    public final static int DEFAULT_INTERVAL = 4;
    /**
     * The number of rings, or the unit interval, depending on whether
     * intervalUnits is null or not.
     */
    protected int interval = DEFAULT_INTERVAL;
    /** The unit object specifying the interval meaning. */
    protected Length intervalUnits = null;
    /**
     * The DrawingAttributes object used to reflect the outer circle properties
     * to the inner circles.
     */
    protected DrawingAttributes drawingAttributes = new DrawingAttributes();
    /** The center point of the range rings. */
    protected OMPoint centerPoint;
    /** The default format. */
    public final static java.text.DecimalFormat DEFAULT_FORMAT = new java.text.DecimalFormat();
    /** Formatting for the labels with units. */
    protected java.text.NumberFormat form = DEFAULT_FORMAT;

    protected boolean drawLabels = true;

    /**
     * Creates an OMRangeRings with a Lat-lon center and a lat-lon axis.
     * Rendertype is RENDERTYPE_LATLON.
     * 
     * @param latPoint latitude of center point, decimal degrees
     * @param lonPoint longitude of center point, decimal degrees
     * @param radius distance in decimal degrees (converted to radians
     *        internally).
     */
    public OMRangeRings(float latPoint, float lonPoint, float radius) {
        this(new LatLonPoint(latPoint, lonPoint),
             radius,
             Length.DECIMAL_DEGREE,
             -1);
    }

    /**
     * Create an OMRangeRings with a lat/lon center and a physical distance
     * radius. Rendertype is RENDERTYPE_LATLON.
     * 
     * @param latPoint latitude of center of circle in decimal degrees
     * @param lonPoint longitude of center of circle in decimal degrees
     * @param radius distance
     * @param units com.bbn.openmap.proj.Length object.
     */
    public OMRangeRings(float latPoint, float lonPoint, float radius,
            Length units) {
        this(new LatLonPoint(latPoint, lonPoint), radius, units, -1);
    }

    /**
     * Create an OMRangeRings with a lat/lon center and a physical distance
     * radius. Rendertype is RENDERTYPE_LATLON.
     * 
     * @param latPoint latitude of center of circle in decimal degrees
     * @param lonPoint longitude of center of circle in decimal degrees
     * @param radius distance
     * @param units com.bbn.openmap.proj.Length object specifying units.
     * @param nverts number of vertices for the poly-circle (if &lt; 3, value is
     *        generated internally)
     */
    public OMRangeRings(float latPoint, float lonPoint, float radius,
            Length units, int nverts) {
        this(new LatLonPoint(latPoint, lonPoint), radius, units, nverts);
    }

    /**
     * Create an OMRangeRings with a lat/lon center and a physical distance
     * radius. Rendertype is RENDERTYPE_LATLON.
     * 
     * @param center LatLon center of circle
     * @param radius distance
     * @param units com.bbn.openmap.proj.Length object specifying units for
     *        distance.
     * @param nverts number of vertices for the poly-circle(if &lt; 3, value is
     *        generated internally)
     */
    public OMRangeRings(LatLonPoint center, float radius, Length units,
            int nverts) {
        super(center, radius, units, nverts);
        centerPoint = createCenterPoint();
        form.setMaximumFractionDigits(2);
    }

    protected OMPoint createCenterPoint() {
        return new OMPoint((float) center.getLatitude(), (float) center.getLongitude());
    }

    /**
     * Set the interval. If the interval units are null, then this interval
     * represents the number of circles within the external, defined circle. If
     * the interval units are not null, then this interval represents the unit
     * intervals where range rings are placed.
     */
    public void setInterval(int interval) {
        this.interval = interval;
        setNeedToRegenerate(true);
    }

    /** Convenience method to set both at one time. */
    public void setInterval(int interval, Length units) {
        setInterval(interval);
        setIntervalUnits(units);
    }

    /**
     * Get the interval number.
     */
    public int getInterval() {
        return interval;
    }

    /**
     * Set the interval units. If this is null, then the interval value will
     * represent the number of rings drawn within the defined outer ring. If
     * this is not null, then it represents the units of the interval where the
     * range rings are drawn.
     */
    public void setIntervalUnits(Length units) {
        intervalUnits = units;
        setNeedToRegenerate(true);
    }

    /**
     * Get the interval units.
     */
    public Length getIntervalUnits() {
        return intervalUnits;
    }

    /**
     * Flag for whether the rings should be labeled.
     */
    public void setDrawLabels(boolean dl) {
        drawLabels = dl;
    }

    public boolean getDrawLabels() {
        return drawLabels;
    }

    /**
     * Set the format for the number labels. If null, the defaule will be used.
     * This only applies to the labels with units.
     */
    public void setFormat(java.text.NumberFormat nf) {
        if (nf != null) {
            form = nf;
        } else {
            form = DEFAULT_FORMAT;
        }
    }

    /**
     * Get the format used for the labeling of unit rings.
     */
    public java.text.NumberFormat getFormat() {
        return form;
    }

    /**
     * Set the radius. This is meaningful only if the render type is
     * RENDERTYPE_LATLON. Note that while the radius is specified as decimal
     * degrees, it only means the distance along the ground that that number of
     * degrees represents at the equator, *NOT* a radius of a number of degrees
     * around a certain location. There is a difference.
     * 
     * @param radius float radius in decimal degrees
     */
    public void setRadius(float radius) {
        setRadius(radius, Length.DECIMAL_DEGREE);
    }

    /**
     * Set the radius with units. This is meaningful only if the render type is
     * RENDERTYPE_LATLON.
     * 
     * @param radius float radius
     * @param units Length specifying unit type.
     */
    public void setRadius(float radius, Length units) {
        this.radius = units.toRadians(radius);
        setNeedToRegenerate(true);
    }

    /**
     * Take the interval and intervalUnits, and then create the proper inner
     * circles.
     */
    public OMCircle[] createCircles() {
        OMCircle[] circles;
        OMText[] t;
        int i;
        float rad;
        String value;
        if (intervalUnits == null) {
            int noUnitInterval = interval - 1;
            circles = new OMCircle[noUnitInterval];
            t = new OMText[noUnitInterval];

            for (i = 0; i < noUnitInterval; i++) {
                rad = (float) ((i + 1) * radius / (noUnitInterval + 1));
                circles[i] = new OMCircle(center, rad, Length.RADIAN, -1);
                value = ((i + 1) + "/" + (noUnitInterval + 1));
                t[i] = new OMText(center.getLatitude()
                        + Length.DECIMAL_DEGREE.fromRadians(rad), center.getLongitude(), value, OMText.JUSTIFY_CENTER);
            }
        } else {
            float realDistanceInterval = intervalUnits.toRadians(interval);
            int number = (int) (radius / realDistanceInterval);
            circles = new OMCircle[number];
            t = new OMText[number + 1];
            for (i = 0; i < number; i++) {
                rad = (float) ((i + 1) * realDistanceInterval);
                circles[i] = new OMCircle(center, rad, Length.RADIAN, -1);
                value = (form.format((double) intervalUnits.fromRadians(rad))
                        + " " + intervalUnits.getAbbr());
                t[i] = new OMText(center.getLatitude()
                        + Length.DECIMAL_DEGREE.fromRadians(rad), center.getLongitude(), value, OMText.JUSTIFY_CENTER);
            }
            value = (form.format((double) intervalUnits.fromRadians(radius))
                    + " " + intervalUnits.getAbbr());
            t[i] = new OMText(center.getLatitude()
                    + Length.DECIMAL_DEGREE.fromRadians(radius), center.getLongitude(), value, OMText.JUSTIFY_CENTER);
        }
        labels = t;
        return circles;
    }

    /**
     * Prepare the circles for rendering.
     * 
     * @param proj Projection
     * @return true if generate was successful
     */
    public boolean generate(Projection proj) {
        if (getNeedToRegenerate() == true) {
            if (interval > 0) {
                subCircles = createCircles();
            } else {
                subCircles = null;
            }
        }

        centerPoint = createCenterPoint();
        centerPoint.generate(proj);

        setRenderType(RENDERTYPE_LATLON); // Can't be anything else.
        int i;
        if (subCircles != null) {
            for (i = 0; i < subCircles.length; i++) {
                subCircles[i].generate(proj);
                labels[i].generate(proj);
            }

            // do the one for the outer ring if there are units.
            if (labels.length > i) {
                labels[i].generate(proj);
            }
        }

        return super.generate(proj);
    }

    /**
     * Paint the circles.
     * 
     * @param g Graphics context to render into
     */
    public void render(Graphics g) {
        super.render(g);
        drawingAttributes.setFrom(this);

        if (subCircles != null) {
            // Draw from the larger to the smaller, so the lines of
            // the smaller circles will appear on top of the bigger
            // ones.
            for (int i = subCircles.length - 1; i >= 0; i--) {
                drawingAttributes.setTo(subCircles[i]);
                drawingAttributes.setTo(labels[i]);
                labels[i].setLinePaint(drawingAttributes.getLinePaint());
                subCircles[i].render(g);
                if (drawLabels) {
                    labels[i].render(g);
                }
            }
            // do the one for the outer ring if there are units.
            if (labels.length > subCircles.length && drawLabels) {
                drawingAttributes.setTo(labels[subCircles.length]);
                labels[subCircles.length].setLinePaint(drawingAttributes.getLinePaint());
                labels[subCircles.length].render(g);
            }
        }
        if (centerPoint != null) {
            drawingAttributes.setTo(centerPoint);
            centerPoint.render(g);
        }
    }

    /**
     * Return the shortest distance from the circle to an XY-point.
     * 
     * @param x X coordinate of the point.
     * @param y Y coordinate fo the point.
     * @return float distance from circle to the point
     */
    public float distance(int x, int y) {
        float dist = normalizeDistanceForLineWidth(super.distance(x, y));

        // Not sure whether the inner circles should be queried for
        // distance measurements.
        float tmpDist;
        // if (dist != 0 && subCircles != null) {
        // for (int i = 0; i < subCircles.length; i++) {
        // tmpDist = subCircles[i].distance(x, y);
        // if (tmpDist == 0) return tmpDist;

        // if (tmpDist < dist) {
        // dist = tmpDist;
        // }
        // }
        // }
        tmpDist = centerPoint.distance(x, y);
        if (tmpDist < dist) {
            dist = tmpDist;
        }

        return dist;
    }
}