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" <victor.zamanian@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 distanceTraveled;
  21    private GraphNode parent;
  22    private Double evalFuncVal;
  23
  24    /**
  25     * Creates a new GraphNode instance.
  26     *
  27     * @param name The name of the node.
  28     * @param maxNeighbours The maximum amount of
  29     * neighbours the node can have.
  30     */
  31    public GraphNode(String name, int x, int y, int maxNeighbours) {
  32       this.name = name;
  33       this.x = x;
  34       this.y = y;
  35       this.visited = false;
  36       this.maxNeighbours = maxNeighbours;
  37       this.evalFuncVal = Double.MIN_VALUE;
  38       neighbours = new Hashtable(maxNeighbours);
  39    }
  40
  41    /**
  42     * Adds a neighbour to this node.
  43     *
  44     * @param node The neighbour node to be added.
  45     * @param weight The weight of the potential edge between
  46     * this node and the new neighbour.
  47     */
  48    public void addNeighbour(GraphNode node, Object edge) {
  49       neighbours.put(node, edge);
  50    }
  51
  52    public void deleteNeighbour(GraphNode node) {
  53       neighbours.remove(node);
  54    }
  55
  56    /**
  57     * Inspects the weight of the potential edge between this
  58     * node and one of its neighbours.
  59     *
  60     * @param node The neighbour of this node.
  61     * @return The weight of the potential edge.
  62     */
  63    public Object getEdge(GraphNode node) {
  64       return neighbours.get(node);
  65    }
  66
  67    /**
  68     * Visists this node--sets its visited attribute to true.
  69     */
  70    public void visit() {
  71       this.visited = true;
  72    }
  73
  74    /**
  75     * Inspects whether this node has been visited or not.
  76     *
  77     * @return true if this node has been visited, else false.
  78     */
  79    public boolean isVisited() {
  80       return this.visited;
  81    }
  82
  83    /**
  84     * Inspects all the neighbours (nodes) of this node.
  85     *
  86     * @return An Enumeration of all neighbours of this node..
  87     */
  88    public Enumeration getNeighbours() {
  89       return neighbours.keys();
  90    }
  91
  92    /**
  93     * Inspects the NAME address of this node.
  94     *
  95     * @return The NAME address of this node.
  96     */
  97    public String getName() {
  98       return this.name;
  99    }
 100
 101    /**
 102     * Sets the distance to this node from the root node in
 103     * the process of Dijkstras shortest-path algorithm.
 104     *
 105     * @param distance The distance to this node.
 106     */
 107    public void setDistanceTraveled(Double distanceTraveled) {
 108       this.distanceTraveled = distanceTraveled;
 109    }
 110
 111    /**
 112     * Inspects the distance from this node to the root node. See "setDistance."
 113     *
 114     * @return The distance from this node to the root node.
 115     */
 116    public Double getDistanceTraveled() {
 117       return this.distanceTraveled;
 118    }
 119
 120    /**
 121     * Sets this node's parent node. Used in Dijkstras algorithm.
 122     *
 123     * @param parent The parent to be set.
 124     */
 125    public void setParent(GraphNode parent) {
 126       this.parent = parent;
 127    }
 128
 129    /**
 130     * Inspects this node's parent.
 131     *
 132     * @return The parent node of this parent.
 133     */
 134    public GraphNode getParent() {
 135       return this.parent;
 136    }
 137
 138    /**
 139     * Access to this nodes x-coordinate.
 140     *
 141     * @return the x-coordinate of this node.
 142     */
 143    public int getX() {
 144       return this.x;
 145    }
 146
 147    /**
 148     * Access to this nodes y-coordinate.
 149     *
 150     * @return the y-coordinate of this node.
 151     */
 152    public int getY() {
 153       return this.y;
 154    }
 155
 156    /**
 157     * Calculate and return the distance to x- y-coordinates
 158     *
 159     * @param node the Node to calculate distance to
 160     * @return distance to the node provided
 161     */
 162    public void setDistanceToGoal(GraphNode goal) {
 163       this.distanceToGoal = Math.hypot((this.x - goal.getX()),
 164                                        (this.y - goal.getY()));
 165    }
 166
 167    /**
 168     * Retun the distance to Goal.
 169     *
 170     * @return the distance to goal.
 171     */
 172    public Double getDistanceToGoal() {
 173       return this.distanceToGoal;
 174    }
 175
 176    public void setEvalFuncVal(Double evalFuncVal) {
 177       this.evalFuncVal = evalFuncVal;
 178    }
 179
 180    public Double getEvalFuncVal() {
 181       return this.evalFuncVal;
 182    }
 183
 184    /**
 185     * Compares this node to another graph node.
 186     *
 187     * @param node The node to compare this node to.
 188     * @return 0 if the addresses match, a positive integer if
 189     * this node has a higher NAME address than the other node,
 190     * and a negative integer if this node has a lower NAME address
 191     * than the other node.
 192     */
 193    public int compareTo(Object node) {
 194       return this.evalFuncVal.compareTo(((GraphNode) node).getEvalFuncVal());
 195    }
 196
 197    public String toString() {
 198       String returnString = name + "\n";
 199       for (Enumeration e = getNeighbours(); e.hasMoreElements();) {
 200          GraphNode neighbour = (GraphNode) e.nextElement();
 201          returnString += "      " + neighbour.getName()
 202             + ", traveltime: " + this.getEdge(neighbour) +"\n";
 203       }
 204       return returnString;
 205    }
 206 }