root/trunk/BusNode.java

/**
 * <p>Title: Bus Node </p>
 *
 * <p>Description:
 * To explain how bus nodes work, each bus node represents a whole route. For
 * a search to consider riding a bus, this is how it works....
 *
 * PhysicalNode(GetOn) -> BusNode -> PhysicalNode(GetOff)
 *
 * PhysicalNode(GetOn) is the physical location where you get on the bus
 * PhysicalNode(GetOff) is the physical location where you get off the bus
 *
 * DeltaGCost PhysicalNode(GetOn) -> BusNode is equal to the time to wait to
 * get on the bus
 *
 * DeltaGCost BusNode -> PhysicalNode(GetOff) is equal to the time it takes for
 * the bus to transit from the stop at PhysicalNode(GetOn) to the stop at
 * PhysicalNode(GetOff)
 *
 * HCost (BusNode) -> To make our implementation fit validity in A* search, I have
 * the HCost computed to be the same as the HCost for PhysicalNode(GetOn)</p>
 *
 * <p>Copyright: Copyright (c) 2005</p>
 *
 * <p>Group: Special Interest Group for Software Engineering</p>
 *
 *
 * @author not attributable
 * @version 1.0
 */

import java.io.*;
import java.awt.geom.*;

public class BusNode extends Node implements Serializable
{
    //map from a busEdge object to an ID in the bus schedule.
    int[] mappingIds;

    //the bus schedule object will keep track of ALL bus schedules
    DummyBusSchedule busSchedules;

    public BusNode(int pId) {
        super(pId);
        //
    }

    public BusNode(int pId, DummyBusSchedule pSched, String pRouteIdentifier, int length)
    {
        super(pId);
        busSchedules = pSched;
        super.setDescription(pRouteIdentifier);
        mappingIds = new int[length];
    }

    public BusNode(String pRouteIdentifier, int pId)
    {
        super(pId);
        super.setDescription(pRouteIdentifier);
    }

    public int GetNodeIndex(int nodeId)
    {
        for(int i = 0; i < mappingIds.length; i++)
        {
            if(mappingIds[i] == nodeId)
            {
                return i;
            }
        }
        return -1;
    }


    public void BindPhyisicalNodeToIndex(int nodeId, int index)
    {
        mappingIds[index] = nodeId;
    }

    public int RouteLength()
    {
        return mappingIds.length;
    }

    public String RouteIdentifier(int index)
    {
        //HACK:
        return "";
    }

    public Cost ComputeWaitTime(Node busRideOrigination, Cost gCostOrigination, Search s)
    {
        //store the from id into the cost object so it can be retrieved
        // when computing transit time

        //the returned cost object will be the g cost for the bus node
        int originationIndex = this.GetNodeIndex(busRideOrigination.id);
        Cost gCostBusNode = busSchedules.eWaitTimeForRoute(this.id, originationIndex, gCostOrigination);
        gCostBusNode.physicalNodeGotOntoBus = busRideOrigination;
        return gCostBusNode;
    }

    public Cost ComputeTransitTime(Node busRideDestination, Cost gCostBusNode, Search s)
    {
        //TODO: what if no from edge given for sure?

        //Edgeid of from is stored in cost.
        int fromIndex = this.GetNodeIndex(gCostBusNode.physicalNodeGotOntoBus.id);
        int toIndex = this.GetNodeIndex(busRideDestination.id);
        return busSchedules.eTransTimeFor(this.id, fromIndex, toIndex, gCostBusNode);
    }

    public Cost computeHCost(Search S, Node previousNode)
    {
            // I really think this is will very often overestimate the h-cost,
            // which is bad - since we don't know, it's better to return 0.
            // I'll leave it for now because I don't have time to test changes,
            // and because this whole class is a bit of a hack anyway.
            // -- Tom
            return previousNode.computeHCost(S, this);
    }
}