src/GraphNode.java

   1 import java.util.Vector;
   2 import java.util.Hashtable;
   3 import java.util.Enumeration;
   4
   5 /**
   6  * GraphNode, used by Graph to keep track of the nodes
   7  * in a network and to make a routing table.
   8  *
   9  * @author "Anton Johansson" <anton.johansson@gmail.com>
  10  * @author "Victor Zamanian-Abasy" <zamanian87@gmail.com>
  11  */
  12 public class GraphNode implements Comparable {
  13    private int maxNeighbours;
  14    private Hashtable neighbours;
  15    private String name;
  16    private int x;
  17    private int y;
  18    private Double distanceToGoal;
  19    private boolean visited;
  20    private Double distance;
  21    private GraphNode parent;
  22
  23    /**
  24     * Creates a new GraphNode instance.
  25     *
  26     * @param name The name of the node.
  27     * @param maxNeighbours The maximum amount of
  28     * neighbours the node can have.
  29     */
  30    public GraphNode(String name, int x, int y, int maxNeighbours) {
  31       this.name = name;
  32       this.x = x;
  33       this.y = y;
  34       this.visited = false;
  35       this.maxNeighbours = maxNeighbours;
  36       neighbours = new Hashtable(maxNeighbours);
  37    }
  38
  39    /**
  40     * Adds a neighbour to this node.
  41     *
  42     * @param node The neighbour node to be added.
  43     * @param weight The weight of the potential edge between
  44     * this node and the new neighbour.
  45     */
  46    public void addNeighbour(GraphNode node, Double weight) {
  47       neighbours.put(node, /*(Integer)*/ weight);
  48    }
  49
  50    public void deleteNeighbour(GraphNode node) {
  51       neighbours.remove(node);
  52    }
  53
  54    /**
  55     * Inspects the weight of the potential edge between this
  56     * node and one of its neighbours.
  57     *
  58     * @param node The neighbour of this node.
  59     * @return The weight of the potential edge.
  60     */
  61    public Double getWeight(GraphNode node) {
  62       return (Double) neighbours.get(node);
  63    }
  64
  65    /**
  66     * Visists this node--sets its visited attribute to true.
  67     */
  68    public void visit() {
  69       this.visited = true;
  70    }
  71
  72    /**
  73     * Inspects whether this node has been visited or not.
  74     *
  75     * @return true if this node has been visited, else false.
  76     */
  77    public boolean isVisited() {
  78       return this.visited;
  79    }
  80
  81    /**
  82     * Inspects all the neighbours (nodes) of this node.
  83     *
  84     * @return A Vector with all neighbours.
  85     */
  86    public Enumeration getNeighbours() {
  87       return neighbours.keys();
  88    }
  89
  90    /**
  91     * Inspects the NAME address of this node.
  92     *
  93     * @return The NAME address of this node.
  94     */
  95    public String getName() {
  96       return this.name;
  97    }
  98
  99    /**
 100     * Sets the distance to this node from the root node in
 101     * the process of Dijkstras shortest-path algorithm.
 102     *
 103     * @param distance The distance to this node.
 104     */
 105    public void setDistance(Double distance) {
 106       this.distance = distance;
 107    }
 108
 109    /**
 110     * Inspects the distance from this node to the root node. See "setDistance."
 111     *
 112     * @return The distance from this node to the root node.
 113     */
 114    public Double getDistance() {
 115       return this.distance;
 116    }
 117
 118    /**
 119     * Sets this node's parent node. Used in Dijkstras algorithm.
 120     *
 121     * @param parent The parent to be set.
 122     */
 123    public void setParent(GraphNode parent) {
 124       this.parent = parent;
 125    }
 126
 127    /**
 128     * Inspects this node's parent.
 129     *
 130     * @return The parent node of this parent.
 131     */
 132    public GraphNode getParent() {
 133       return this.parent;
 134    }
 135
 136    /**
 137     * Access to this nodes x-coordinate.
 138     *
 139     * @return the x-coordinate of this node.
 140     */
 141    public int getX() {
 142       return this.x;
 143    }
 144
 145    /**
 146     * Access to this nodes y-coordinate.
 147     *
 148     * @return the y-coordinate of this node.
 149     */
 150    public int getY() {
 151       return this.y;
 152    }
 153
 154    /**
 155     * Calculate and return the distance to x- y-coordinates
 156     *
 157     * @param x the x value to calculate the distance to.
 158     * @param y the y value to calculate the distance to.
 159     */
 160    public void setDistanceToGoal(GraphNode goal) {
 161       this.distanceToGoal = Math.hypot((this.x - goal.getX()), (this.y - goal.getY()));
 162    }
 163
 164    /**
 165     * Retun the distance to Goal.
 166     *
 167     * @return the distance to goal.
 168     */
 169    public Double getDistanceToGoal() {
 170       return this.distanceToGoal;
 171    }
 172
 173    /**
 174     * Compares this node to another graph node.
 175     *
 176     * @param node The node to compare this node to.
 177     * @return 0 if the addresses match, a positive integer if
 178     * this node has a higher NAME address than the other node,
 179     * and a negative integer if this node has a lower NAME address
 180     * than the other node.
 181     */
 182    public int compareTo(Object node) {
 183        return distance.compareTo(((GraphNode) node).getDistance());
 184    }
 185
 186    public String toString() {
 187       String returnString = name + "\n";
 188       for (Enumeration e = getNeighbours(); e.hasMoreElements();) {
 189          GraphNode neighbour = (GraphNode) e.nextElement();
 190          returnString += "      " + neighbour.getName() + ", traveltime: " + this.getWeight(neighbour) +"\n";
 191       }
 192       return returnString;
 193    }
 194 }