public PortalWaypoints GetPortalWaypoints
(Guid sourceRegionID,
Guid sourceWaypointID,
Guid sinkRegionID,
ConnectionType[] avoidConnectionTypes)
{
// for regionEdge, we need to handle following two cases:
// case 1. R1/W1 -> R2/W2
// case 2. R2/W2 -> R1/W1
// When we parse the XML file, we may store either one of these two
// cases into C# structure with its bi-direction, connectiontype,
// and source properties.
// While this edge is queried, we should serve both (R1, R2) and
// (R2, R1) cases with corresponding portal waypoints.
PortalWaypoints portalWaypoints = new PortalWaypoints();
RegionEdge regionEdge =
GetRegionEdgeMostNearSourceWaypoint(sourceRegionID,
sourceWaypointID,
sinkRegionID,
avoidConnectionTypes);
portalWaypoints._portalWaypoint1 = regionEdge._waypoint1;
portalWaypoints._portalWaypoint2 = regionEdge._waypoint2;
return(portalWaypoints);
}
public RegionWaypointPoint GiveNeighborWaypointInNeighborRegion
(Guid sourceRegionID,
Guid sourceWaypointID,
Guid sinkRegionID)
{
RegionWaypointPoint regionWaypointPoint = new RegionWaypointPoint();
ConnectionType[] emptyAvoid = new ConnectionType[0];
RegionEdge regionEdge =
GetRegionEdgeMostNearSourceWaypoint(sourceRegionID,
sourceWaypointID,
sinkRegionID,
emptyAvoid);
regionWaypointPoint._waypointID = regionEdge._waypoint2;
regionWaypointPoint._regionID = regionEdge._region2;
return(regionWaypointPoint);
}
public Graph <Guid, string> GenerateRegionGraph
(ConnectionType[] avoidConnectionTypes)
{
Graph <Guid, string> graph = new Graph <Guid, string>();
foreach (KeyValuePair <Guid, Region> regionItem in _regions)
{
graph.AddNode(regionItem.Key);
}
foreach (KeyValuePair <Tuple <Guid, Guid>,
List <RegionEdge> > regionEdgeItem in _edges)
{
Guid node1 = regionEdgeItem.Key.Item1;
Guid node2 = regionEdgeItem.Key.Item2;
uint node1Key = graph.Where(node => node.Item.Equals(node1))
.Select(node => node.Key).First();
uint node2Key = graph.Where(node => node.Item.Equals(node2))
.Select(node => node.Key).First();
int node1EdgeDistance = Int32.MaxValue;
int node1EdgeIndex = -1;
int node2EdgeDistance = Int32.MaxValue;
int node2EdgeIndex = -1;
for (int i = 0; i < regionEdgeItem.Value.Count(); i++)
{
RegionEdge edgeItem = regionEdgeItem.Value[i];
if (!avoidConnectionTypes.Contains(edgeItem._connectionType))
{
if (
DirectionalConnection.BiDirection ==
edgeItem._biDirection ||
(DirectionalConnection.OneWay ==
edgeItem._biDirection && 1 == edgeItem._source))
{
int edgeDistance =
System.Convert.ToInt32(edgeItem._distance);
if (edgeDistance < node1EdgeDistance)
{
node1EdgeDistance = edgeDistance;
node1EdgeIndex = i;
}
}
if (DirectionalConnection.BiDirection ==
edgeItem._biDirection ||
(DirectionalConnection.OneWay ==
edgeItem._biDirection && 2 == edgeItem._source))
{
int edgeDistance =
System.Convert.ToInt32(edgeItem._distance);
if (edgeDistance < node2EdgeDistance)
{
node2EdgeDistance = edgeDistance;
node2EdgeIndex = i;
}
}
}
}
if (-1 != node1EdgeIndex)
{
graph.Connect(node1Key,
node2Key,
node1EdgeDistance,
String.Empty);
}
if (-1 != node2EdgeIndex)
{
graph.Connect(node2Key,
node1Key,
node2EdgeDistance,
String.Empty);
}
}
return(graph);
}
private RegionEdge GetRegionEdgeMostNearSourceWaypoint
(Guid sourceRegionID,
Guid sourceWaypointID,
Guid sinkRegionID,
ConnectionType[] avoidConnectionTypes)
{
RegionEdge regionEdgeItem = new RegionEdge();
Waypoint sourceWaypoint =
_navigraphs[sourceRegionID]._waypoints[sourceWaypointID];
// compare the normal case (R1, R2)
Tuple <Guid, Guid> edgeKeyFromNode1 =
new Tuple <Guid, Guid>(sourceRegionID, sinkRegionID);
int distance = Int32.MaxValue;
int indexEdge = -1;
if (_edges.ContainsKey(edgeKeyFromNode1))
{
for (int i = 0; i < _edges[edgeKeyFromNode1].Count(); i++)
{
RegionEdge edgeItem = _edges[edgeKeyFromNode1][i];
if (!avoidConnectionTypes.Contains(edgeItem._connectionType))
{
if (DirectionalConnection.BiDirection ==
edgeItem._biDirection ||
(DirectionalConnection.OneWay ==
edgeItem._biDirection &&
1 == edgeItem._source))
{
Waypoint sinkWaypoint =
_navigraphs[sourceRegionID].
_waypoints[edgeItem._waypoint1];
double distanceFromSource =
GetDistance(sourceWaypoint._lon,
sourceWaypoint._lat,
sinkWaypoint._lon,
sinkWaypoint._lat);
int edgeDistance =
System.Convert.ToInt32(distanceFromSource);
if (edgeDistance < distance)
{
distance = edgeDistance;
indexEdge = i;
}
}
}
}
}
if (-1 != indexEdge)
{
regionEdgeItem = _edges[edgeKeyFromNode1][indexEdge];
return(regionEdgeItem);
}
// compare the reverse case (R2, R1) because normal case (R1, R2)
// cannot find regionEdge
Tuple <Guid, Guid> edgeKeyFromNode2 =
new Tuple <Guid, Guid>(sinkRegionID, sourceRegionID);
if (_edges.ContainsKey(edgeKeyFromNode2))
{
for (int i = 0; i < _edges[edgeKeyFromNode2].Count(); i++)
{
RegionEdge edgeItem = _edges[edgeKeyFromNode2][i];
if (!avoidConnectionTypes.Contains
(edgeItem._connectionType))
{
if (DirectionalConnection.BiDirection ==
edgeItem._biDirection ||
(DirectionalConnection.OneWay ==
edgeItem._biDirection &&
2 == edgeItem._source))
{
Waypoint sinkWaypoint =
_navigraphs[sinkRegionID].
_waypoints[edgeItem._waypoint1];
double distanceFromSource =
GetDistance(sourceWaypoint._lon,
sourceWaypoint._lat,
sinkWaypoint._lon,
sinkWaypoint._lat);
int edgeDistance =
System.Convert.ToInt32(distanceFromSource);
if (edgeDistance < distance)
{
distance = edgeDistance;
indexEdge = i;
}
}
}
}
}
if (-1 != indexEdge)
{
// need to reverse the resulted regionEdge from (R1/W1, R2/W2)
//pair to (R2/W2, R1/W1) pair before returning to caller
regionEdgeItem._region1 =
_edges[edgeKeyFromNode2][indexEdge]._region2;
regionEdgeItem._region2 =
_edges[edgeKeyFromNode2][indexEdge]._region1;
regionEdgeItem._waypoint1 =
_edges[edgeKeyFromNode2][indexEdge]._waypoint2;
regionEdgeItem._waypoint2 =
_edges[edgeKeyFromNode2][indexEdge]._waypoint1;
regionEdgeItem._biDirection =
_edges[edgeKeyFromNode2][indexEdge]._biDirection;
if (2 == _edges[edgeKeyFromNode2][indexEdge]._source)
{
regionEdgeItem._source = 1;
}
regionEdgeItem._distance =
_edges[edgeKeyFromNode2][indexEdge]._distance;
if (System.Convert.ToInt32
(_edges[edgeKeyFromNode2][indexEdge]._direction) + 4 < 8)
{
regionEdgeItem._direction = (CardinalDirection)
(4 + _edges[edgeKeyFromNode2][indexEdge]._direction);
}
else
{
regionEdgeItem._direction =
(CardinalDirection)
(4 + _edges[edgeKeyFromNode2][indexEdge]._direction - 8);
}
regionEdgeItem._connectionType =
_edges[edgeKeyFromNode2][indexEdge]._connectionType;
return(regionEdgeItem);
}
return(regionEdgeItem);
}
public InstructionInformation GetInstructionInformation(
int currentNavigationStep,
Guid currentRegionID,
Guid currentWaypointID,
Guid previousRegionID,
Guid previousWaypointID,
Guid nextRegionID,
Guid nextWaypointID,
ConnectionType[] avoidConnectionTypes)
{
InstructionInformation information = new InstructionInformation();
information._floor = _regions[nextRegionID]._floor;
information._regionName = _regions[nextRegionID]._name;
if (!currentRegionID.Equals(nextRegionID))
{
// currentWaypoint and nextWaypoint are in different regions
if (!_regions[currentRegionID].
_floor.Equals(_regions[nextRegionID]._floor))
{
// currentWaypoint and nextWaypoint are in different regions
// with different floors
if (_regions[nextRegionID]._floor >
_regions[currentRegionID]._floor)
{
information._turnDirection = TurnDirection.Up;
}
else
{
information._turnDirection = TurnDirection.Down;
}
RegionEdge currentEdge =
GetRegionEdgeMostNearSourceWaypoint(currentRegionID,
currentWaypointID,
nextRegionID,
avoidConnectionTypes);
information._connectionType = currentEdge._connectionType;
information._distance = System.Convert
.ToInt32(currentEdge._distance);
}
else
{
// currentWaypoint and nextWaypoint are across regions
// but on the same floor
// When step==0, it means that the turn direction is first
// direction.
if (0 == currentNavigationStep)
{
// currentWaypoint is the first waypoing from the
// beginning need to refine the turndirection in this
// case
information._turnDirection =
TurnDirection.FirstDirection;
RegionEdge currentEdge =
GetRegionEdgeMostNearSourceWaypoint
(currentRegionID,
currentWaypointID,
nextRegionID,
avoidConnectionTypes);
information._relatedDirectionOfFirstDirection =
currentEdge._direction;
information._connectionType =
currentEdge._connectionType;
information._distance = System.Convert
.ToInt32(currentEdge._distance);
}
else
{
if (!previousRegionID.Equals(currentRegionID))
{
// previouWaypoint and currentWaypoint are acrss
// regions
if (!_regions[previousRegionID]._floor.Equals(
_regions[currentRegionID]._floor))
{
if (!currentRegionID.Equals(nextRegionID))
{
information._turnDirection =
TurnDirection.FirstDirection;
RegionEdge regionEdge =
GetRegionEdgeMostNearSourceWaypoint
(currentRegionID,
currentWaypointID,
nextRegionID,
avoidConnectionTypes);
information._connectionType =
regionEdge._connectionType;
information._distance =
System.Convert.ToInt32
(regionEdge._distance);
information.
_relatedDirectionOfFirstDirection
= regionEdge._direction;
}
else
{
information._turnDirection =
TurnDirection.FirstDirection;
WaypointEdge currentEdge =
GetWaypointEdgeInRegion
(currentRegionID,
currentWaypointID,
nextWaypointID,
avoidConnectionTypes);
information._connectionType =
currentEdge._connectionType;
information.
_relatedDirectionOfFirstDirection =
currentEdge._direction;
information._distance =
System.Convert
.ToInt32(currentEdge._distance);
}
// previousWaypoint and currentWaypoint are on
// different floor need to refine the
// turndirection in this case
}
else
{
// previousWaypoint and currentWaypoint are on the same floor
RegionEdge prevEdge =
GetRegionEdgeMostNearSourceWaypoint
(previousRegionID,
previousWaypointID,
currentRegionID,
avoidConnectionTypes);
CardinalDirection prevEdgeDirection =
prevEdge._direction;
RegionEdge currentEdge =
GetRegionEdgeMostNearSourceWaypoint
(currentRegionID,
currentWaypointID,
nextRegionID,
avoidConnectionTypes);
CardinalDirection currentEdgeDirection =
currentEdge._direction;
int prevDirection =
System.Convert.ToInt32(prevEdgeDirection);
int currentDirection =
System.Convert.ToInt32(currentEdgeDirection);
if (currentDirection - prevDirection >= 0)
{
information._turnDirection =
(TurnDirection)
(currentDirection - prevDirection);
}
else
{
information._turnDirection =
(TurnDirection)
(currentDirection - prevDirection + 8);
}
information._connectionType =
currentEdge._connectionType;
information._distance =
System.Convert
.ToInt32(currentEdge._distance);
}
}
else
{
// previousWaypoint and currentWaypoint are in the
// same region
WaypointEdge prevEdge =
GetWaypointEdgeInRegion(previousRegionID,
previousWaypointID,
currentWaypointID,
avoidConnectionTypes);
CardinalDirection prevEdgeDirection =
prevEdge._direction;
RegionEdge currentEdge =
GetRegionEdgeMostNearSourceWaypoint
(currentRegionID,
currentWaypointID,
nextRegionID,
avoidConnectionTypes);
CardinalDirection currentEdgeDirection =
currentEdge._direction;
int prevDirection =
System.Convert.ToInt32(prevEdgeDirection);
int currentDirection =
System.Convert.ToInt32(currentEdgeDirection);
if (currentDirection - prevDirection >= 0)
{
information._turnDirection =
(TurnDirection)
(currentDirection - prevDirection);
}
else
{
information._turnDirection =
(TurnDirection)
(currentDirection - prevDirection + 8);
}
information._connectionType =
currentEdge._connectionType;
information._distance =
System.Convert.ToInt32(currentEdge._distance);
}
}
}
}
else
{
// currentWaypoint and nextWaypoint are in the same region
if (0 == currentNavigationStep)
{
// first waypoint from the beginning
// need to refine the turndirection in this case
information._turnDirection = TurnDirection.FirstDirection;
WaypointEdge currentEdge =
GetWaypointEdgeInRegion(currentRegionID,
currentWaypointID,
nextWaypointID,
avoidConnectionTypes);
information._connectionType = currentEdge._connectionType;
information._relatedDirectionOfFirstDirection =
currentEdge._direction;
information._distance = System.Convert
.ToInt32(currentEdge._distance);
}
else
{
Console.WriteLine("current = next case");
if (!previousRegionID.Equals(currentRegionID))
{
Console.WriteLine("previous != current case");
// currentWaypoint and nextWaypoint are in the same
// region.
// previouWaypoint and currentWaypoint are acrss regions
if (!_regions[previousRegionID]._floor.Equals(
_regions[currentRegionID]._floor))
{
// previousWaypoint and currentWaypoint are on
// different floor need to refine the turndirection
// in this case
information._turnDirection =
TurnDirection.FirstDirection;
WaypointEdge currentEdge =
GetWaypointEdgeInRegion(currentRegionID,
currentWaypointID,
nextWaypointID,
avoidConnectionTypes);
information._connectionType =
currentEdge._connectionType;
information._relatedDirectionOfFirstDirection =
currentEdge._direction;
information._distance =
System.Convert
.ToInt32(currentEdge._distance);
}
else
{
// previousWaypoint and currentWaypoint are on the
// same floor
RegionEdge prevEdge =
GetRegionEdgeMostNearSourceWaypoint
(previousRegionID,
previousWaypointID,
currentRegionID,
avoidConnectionTypes);
CardinalDirection prevEdgeDirection =
prevEdge._direction;
WaypointEdge currentEdge =
GetWaypointEdgeInRegion(currentRegionID,
currentWaypointID,
nextWaypointID,
avoidConnectionTypes);
CardinalDirection currentEdgeDirection =
currentEdge._direction;
int prevDirection =
System.Convert.ToInt32(prevEdgeDirection);
int currentDirection =
System.Convert.ToInt32(currentEdgeDirection);
if (currentDirection - prevDirection >= 0)
{
information._turnDirection =
(TurnDirection)
(currentDirection - prevDirection);
}
else
{
information._turnDirection =
(TurnDirection)
(currentDirection - prevDirection + 8);
}
information._connectionType =
currentEdge._connectionType;
information._distance =
System.Convert.ToInt32(currentEdge._distance);
}
}
else
{
Console.WriteLine("previous = current case");
// currentWaypoint and nextWaypoint are in the same
// region
// previousWaypoint and currentWaypoint are in the same
// region
WaypointEdge prevEdge =
GetWaypointEdgeInRegion(previousRegionID,
previousWaypointID,
currentWaypointID,
avoidConnectionTypes);
CardinalDirection prevEdgeDirection =
prevEdge._direction;
WaypointEdge currentEdge =
GetWaypointEdgeInRegion(currentRegionID,
currentWaypointID,
nextWaypointID,
avoidConnectionTypes);
CardinalDirection currentEdgeDirection =
currentEdge._direction;
int prevDirection =
System.Convert.ToInt32(prevEdgeDirection);
int currentDirection =
System.Convert.ToInt32(currentEdgeDirection);
if (currentDirection - prevDirection >= 0)
{
information._turnDirection =
(TurnDirection)
(currentDirection - prevDirection);
}
else
{
information._turnDirection =
(TurnDirection)
(currentDirection - prevDirection + 8);
}
information._connectionType =
currentEdge._connectionType;
information._distance =
System.Convert.ToInt32(currentEdge._distance);
}
}
}
return(information);
}
public int GetDistanceOfLongHallway(RegionWaypointPoint currentGuid,
int nextStep,
List <RegionWaypointPoint> allRoute,
ConnectionType[] avoidConnectionType)
{
int distance = 0;
if (nextStep <= 0)
{
nextStep = 1;
}
for (int i = nextStep - 1; i < allRoute.Count(); i++)
{
if (allRoute[i]._regionID != allRoute[i + 1]._regionID)
{
if (_regions[allRoute[i]._regionID]._floor ==
_regions[allRoute[i + 1]._regionID]._floor)
{
RegionEdge regionEdge =
GetRegionEdgeMostNearSourceWaypoint
(allRoute[i].
_regionID, allRoute[i].
_waypointID, allRoute[i + 1].
_regionID, avoidConnectionType);
distance = System.Convert.ToInt32(regionEdge._distance);
}
else
{
break;
}
}
else
{
WaypointEdge waypointEdge =
GetWaypointEdgeInRegion(allRoute[i]._regionID,
allRoute[i]._waypointID,
allRoute[i + 1]._waypointID,
avoidConnectionType);
distance =
distance + System.Convert.ToInt32(waypointEdge._distance);
if (i + 2 >= allRoute.Count())
{
break;
}
else
{
WaypointEdge currentWaypointEdge =
GetWaypointEdgeInRegion(allRoute[i]._regionID,
allRoute[i]._waypointID,
allRoute[i + 1]._waypointID,
avoidConnectionType);
WaypointEdge nextWaypointEdge =
GetWaypointEdgeInRegion(allRoute[i + 1]._regionID,
allRoute[i + 1]._waypointID,
allRoute[i + 2]._waypointID,
avoidConnectionType);
if (currentWaypointEdge._direction
!= nextWaypointEdge._direction)
{
break;
}
}
}
}
return(distance);
}
