// **********************************************************************// // <copyright>// //  BBN Technologies//  10 Moulton Street//  Cambridge, MA 02138//  (617) 873-8000// //  Copyright (C) BBNT Solutions LLC. All rights reserved.// // </copyright>// **********************************************************************// // $Source:// /cvs/distapps/openmap/src/openmap/com/bbn/openmap/tools/roads/Road.java,v// $// $RCSfile: Road.java,v $// $Revision: 1.1.2.4 $// $Date: 2005/08/12 21:47:05 $// $Author: dietrick $// // **********************************************************************package com.bbn.openmap.tools.roads;import java.awt.Point;import java.io.Serializable;import java.util.logging.Logger;import com.bbn.openmap.LatLonPoint;import com.bbn.openmap.omGraphics.OMGraphicList;import com.bbn.openmap.proj.GreatCircle;public class Road implements RoadObject, Serializable {    Logger logger = Logger.getLogger(this.getClass().getName());    /**     * The points along the road. The first and last points are always     * Intersections.     */    private Waypoint[] points;    /**     * The lines between the points.     */    private RoadLine[] lines;    /**     * The class of this road. A Road's class implies what kind of     * road it is. For now this governs its visual appearance of color     * and width.     */    private RoadClass roadClass;    private boolean isRoute = false;;    private boolean blocked = false;    /**     * The id of this road.     */    private int id;    /**     * The name of this road.     */    private String name;    /**     * True if this road has been modified (points added or removed).     */    private boolean modified = false;    /**     * The RoadLayer we belong to so we can invoke its services.     */    private transient RoadLayer roadLayer;    /**     * Selection flag for this road.     */    private boolean selected = false;    /**     * Blink flag for this road.     */    private boolean blinkState = false;    /**     * Create a road between two Intersections. The detailed segments     * between the intersections may be filled in later.     *      * @param id a unique, integer identifier of this road.     * @param name a name for this road.     * @param from the intersection from which this road leaves.     * @param to the intersection to which this road goes.     * @param roadClass the class of this road.     * @param roadLayer the RoadLayer we belong to.     */    public Road(int id, String name, Intersection from, Intersection to,            RoadClass roadClass, RoadLayer roadLayer) {        this.id = id;        this.name = name;        this.roadLayer = roadLayer;        points = new Waypoint[2];        setIntersections(from, to);        this.roadClass = roadClass;        createLines();        modified = false;    }    public float getLengthInKilometers() {        float kilometers = 0.0f;        LatLonPoint prevPoint = points[0].getLocation();        // logger.warning ("" + this + " pt 0 " + points[0] + " pt 1 "        // + points[1] + " getSecondInter " + getSecondIntersection        // ());        for (int i = 1; i < points.length; i++) {            LatLonPoint thisPoint = points[i].getLocation();            kilometers += GreatCircle.spherical_distance(prevPoint.getLatitude(),                    prevPoint.getLongitude(),                    thisPoint.getLatitude(),                    thisPoint.getLongitude());            prevPoint = thisPoint;        }        return kilometers;    }    public float getTraverseHours() {        if (isBlocked())            return Float.MAX_VALUE;        return getLengthInKilometers() / getRoadClass().getConvoySpeed();    }    public LatLonPoint getLocationAtKilometer(float kilometers) {        LatLonPoint prevPoint = points[0].getLocation();        float prevLat = prevPoint.getLatitude();        float prevLon = prevPoint.getLongitude();        for (int i = 1; i < points.length; i++) {            LatLonPoint thisPoint = points[i].getLocation();            float thisLat = thisPoint.getLatitude();            float thisLon = thisPoint.getLongitude();            float thisLength = GreatCircle.spherical_distance(prevLat,                    prevLon,                    thisLat,                    thisLon);            if (thisLength >= kilometers) {                float fraction = kilometers / thisLength;                float deltaLat = thisLat - prevLat;                float deltaLon = thisLon - prevLon;                if (deltaLon < -180f)                    deltaLon += 360f;                else if (deltaLon > 180f)                    deltaLon -= 360f;                return new LatLonPoint(prevLat + fraction * deltaLat, prevLon                        + fraction * deltaLon);            }            kilometers -= thisLength;            prevPoint = thisPoint;            prevLat = thisLat;            prevLon = thisLon;        }        return prevPoint;    }    private void createLines() {        lines = new RoadLine[points.length - 1];        for (int i = 0; i < lines.length; i++) {            lines[i] = new RoadLine(this, i);        }        blinkLines();    }    private void blinkLines() {        for (int i = 0; i < lines.length; i++)            lines[i].blink(blinkState);    }    /**     * Set the state of the modified flag. Setting the modified flag     * to false also sets the modified flag of all the points to false     * as well.     *      * @param newValue the new setting.     */    public void setModified(boolean newValue) {        modified = newValue;        if (newValue == false) {            for (int i = 0; i < points.length; i++)                points[i].setModified(false);        }    }    /**     * Get the state of the modified flag.     *      * @return true if the road or its points have been modified.     */    public boolean getModified() {        if (modified)            return true;        for (int i = 0; i < points.length; i++)            if (points[i].getModified())                return true;        return false;    }    public void block() {        blocked = true;        updateLines();    }    public void unblock() {        blocked = false;        updateLines();    }    public boolean isBlocked() {        return blocked;    }    public void blink(boolean newState) {        blinkState = newState;        if (lines != null)            blinkLines();        blinkPoints();    }    /**     * Accessor for the ID property.     *      * @return the road ID.     */    public int getID() {        return id;    }    public String getName() {        return name;    }    public void setName(String newName) {        name = newName;    }    public RoadClass getRoadClass() {        return roadClass;    }    public void setRoadClass(RoadClass newClass) {        roadClass = newClass;        setModified(true);        updateLines();    }    public String getRoadClassName() {        return roadClass.getName().toString();    }    public void isRoute(boolean yes) {        isRoute = yes;        updateLines();    }    public boolean isRoute() {        return isRoute;    }    public RoadLayer getRoadLayer() {        return roadLayer;    }    public void setIntersections(Intersection from, Intersection to) {        if (from == null) {            logger.warning("from is null.");            Thread.dumpStack();        }        if (to == null) {            logger.warning("to is null.");            Thread.dumpStack();        }        points[0] = from;        points[points.length - 1] = to;        checkPoints();        createLines();        setModified(true);    }    public void setRoadPoints(RoadPoint[] innerPoints) {        Waypoint[] oldPoints = points;        points = new Waypoint[2 + innerPoints.length];        points[0] = oldPoints[0];        System.arraycopy(innerPoints, 0, points, 1, innerPoints.length);        points[points.length - 1] = oldPoints[oldPoints.length - 1];        if (points[points.length - 1] == null) {            logger.warning("to is null.");            Thread.dumpStack();        }        checkPoints();        createLines();        // blinkPoints();        setModified(true);    }    public void checkPoints() {        for (int i = 0; i < points.length; i++) {            if (points[i] == null) {                logger.warning("found null point at " + i);                Thread.dumpStack();            }        }    }    public RoadPoint[] getRoadPoints() {        RoadPoint[] innerPoints = new RoadPoint[points.length - 2];        System.arraycopy(points, 1, innerPoints, 0, innerPoints.length);        return innerPoints;    }    public void insertRoadPointAt(RoadPoint wp, int ix) {        Waypoint[] oldPoints = points;        points = new Waypoint[1 + oldPoints.length];        System.arraycopy(oldPoints, 0, points, 0, ix);        points[ix] = wp;        if (wp == null) {            logger.warning("wp is null.");            Thread.dumpStack();        }        checkPoints();        System.arraycopy(oldPoints, ix, points, ix + 1, oldPoints.length - ix);        createLines();        // blinkPoints();        setModified(true);    }    public void deleteRoadPoint(RoadPoint rp) {        for (int ix = 1; ix < points.length - 1; ix++) {            if (points[ix] == rp) {                Waypoint[] oldPoints = points;                points = new Waypoint[oldPoints.length - 1];                System.arraycopy(oldPoints, 0, points, 0, ix);                System.arraycopy(oldPoints,                        ix + 1,                        points,                        ix,                        oldPoints.length - ix - 1);                createLines();                setModified(true);                return;            }        }        checkPoints();    }    public Intersection getFirstIntersection() {        return (Intersection) points[0];    }    public Intersection getSecondIntersection() {        return (Intersection) points[points.length - 1];    }    public Intersection getOtherIntersection(Intersection intersection) {        if (intersection == points[0])            return (Intersection) points[points.length - 1];        return (Intersection) points[0];    }    public void changeIntersection(Intersection oldIntersection,                                   Intersection newIntersection) {        if (oldIntersection == points[0]) {            setIntersections(newIntersection, getSecondIntersection());        } else if (oldIntersection == points[points.length - 1]) {            setIntersections(getFirstIntersection(), newIntersection);        }        checkPoints();    }    public Waypoint getWaypoint(int ix) {        return points[ix];    }    public Waypoint[] getPoints() {        return points;    }    public RoadPoint[] getPointsBefore(RoadPoint wp) {        for (int i = 1; i < points.length - 1; i++) {            if (points[i] == wp) {                RoadPoint[] answer = new RoadPoint[i - 1];                System.arraycopy(points, 1, answer, 0, answer.length);                return answer;            }        }        return new RoadPoint[0];    }    public RoadPoint[] getPointsAfter(RoadPoint wp) {        for (int i = 1; i < points.length - 1; i++) {            if (points[i] == wp) {                RoadPoint[] answer = new RoadPoint[points.length - i - 2];                System.arraycopy(points, i + 1, answer, 0, answer.length);                return answer;            }        }        RoadPoint[] answer = new RoadPoint[points.length - 2];        System.arraycopy(points, 1, answer, 0, answer.length);        return answer;    }    private void blinkPoints() {        for (int i = 1; i < points.length - 1; i++) {            points[i].blink(blinkState);        }    }    /**     * Mark this Road as needing a new visual representation.     */    public synchronized void updateLines() {        for (int i = 0; i < lines.length; i++)            lines[i].update();    }    public void moveTo(Point loc) {}    public synchronized void render(OMGraphicList gl, boolean projectionIsNew) {        if (roadLayer.isEditing()) {            for (int i = 1; i < points.length - 1; i++) {                points[i].render(gl, projectionIsNew);            }        }        for (int i = 0; i < lines.length; i++)            lines[i].render(gl, projectionIsNew);    }    public String toString() {        return name + " from " + getFirstIntersection() + " to "                + getSecondIntersection() + " " + points.length + " points.";    }    public boolean isSelected() {        return selected;    }    public void setSelected(boolean selected) {        this.selected = selected;    }}