public int Add(GraphEdge newItem)
{
GraphEdge edgeToAdd = newItem;
edgeToAdd.Next = Head;
Head = edgeToAdd;
return size++;
}
public void AddNode(Vector3 neighborPoint, ref GraphNode currentNode, ref Queue<GraphNode> q )
{
RaycastHit hitInfo;
Vector3 rayDirection = Vector3.zero;
#if USE_XZ
rayDirection = new Vector3(0, -1, 0);
#else
rayDirection = new Vector3(0, 0, 1);
#endif //USE_XZ
int layerMask = 1 << 8;
layerMask = ~layerMask;
if ( Physics.Raycast(neighborPoint, rayDirection, out hitInfo, Mathf.Infinity, layerMask) )
{
if (hitInfo.transform.tag == "Ground")
{
GraphNode newNode = new GraphNode(mNumOfNodes, hitInfo.point); // make a new node for this point
GraphEdge newEdge = new GraphEdge(currentNode.GetIndex(), newNode.GetIndex()); // creat a new edge
int index = 0;
bool nodeFound = false;
while ( !nodeFound && index <= mNumOfNodes )
{
//Debug.Log (index + " out of " + NavigationGraph.Length + " thinks there's only" + mNumOfNodes);
nodeFound = ( NavigationGraph[index] == hitInfo.point );
++index;
}
if ( !nodeFound ) // if we have not found this node before, add it
{
Nodes.Add(newNode);
NavigationGraph[mNumOfNodes] = hitInfo.point;
++mNumOfNodes;
q.Enqueue(newNode);
}
else
{
newEdge.SetToIndex(index-1);
}
// If the raycast hit then we will always want to add the edge, since we want edges
// in both directions and there won't ever be duplicates.
// check if there is a clear path to add an edge
Vector3 heightOffset = Vector3.zero;
#if USE_XZ
heightOffset = new Vector3(0, 0.5f, 0);
#else
heightOffset = new Vector3(0, 0, -0.5f);
#endif // USE_XZ
if ( !Physics.Linecast(currentNode.GetPosition() + heightOffset, newNode.GetPosition() + heightOffset, out hitInfo, layerMask) )
{
Edges.Add(newEdge);
currentNode.AddEdge(newEdge);
}
}
}
}
public ObstacleDebugInfo(GraphEdge edge, Vector2?intersection, float dot, Vector2 avoidStrength, Vector2 translation)
{
Point1 = edge.Point1 + translation;
Point2 = edge.Point2 + translation;
Intersection = intersection;
Dot = dot;
AvoidStrength = avoidStrength;
}
public async Task <GraphGetRp> GetGraphExperience(int productId, DatePeriodValue period)
{
GraphGetRp result = new GraphGetRp();
var product = await this._dbContext.FullLoadProductWithSourceItems(productId, period.Start, period.End);
result.Name = product.Name;
result.Id = product.Id.Value;
result.Avatar = product.Avatar;
foreach (var journey in product.Journeys)
{
var measure = journey.Measure();
var snode = new GraphNode
{
Id = string.Format("journey_{0}", journey.Id),
Avatar = journey.Avatar,
Name = string.Format("{0} [ {1} | {2} ]", journey.Name,
Math.Round(journey.ExperienceSlo, 2),
Math.Round(measure.Experience, 2)),
Value = measure.Experience,
Group = "journeys",
Slo = journey.ExperienceSlo,
Budget = measure.ExperienceErrorBudget
};
result.Nodes.Add(snode);
foreach (var map in journey.FeatureMap)
{
var featureMeasure = map.Feature.Measure();
var Id = string.Format("feature_{0}", map.Feature.Id);
var fnode = result.Nodes.SingleOrDefault(c => c.Id == Id);
if (fnode == null)
{
fnode = new GraphNode
{
Id = Id,
Avatar = map.Feature.Avatar,
Name = map.Feature.Name,
Value = featureMeasure.Experience,
Group = "features"
};
result.Nodes.Add(fnode);
}
var fedge = new GraphEdge()
{
From = snode.Id,
To = fnode.Id,
Value = QualityUtils.MeasureBudget(fnode.Value, journey.ExperienceSlo),
Tags = new Dictionary <string, object>()
{
{ "Latency", fnode.Value }
}
};
result.Edges.Add(fedge);
}
}
return(result);
}
public List <int> CalculateBFS(int sourceNode, int targetNode)
{
//@Depth first search, unlikely to find best path
List <int> m_path = new List <int>();
for (int y = 0; y < 64; y++)
{
for (int x = 0; x < 64; x++)
{
m_path.Add(-1);//= null value
}
}
List <bool> m_visited = new List <bool>();
for (int y = 0; y < 64; y++)
{
for (int x = 0; x < 64; x++)
{
m_visited.Add(false);
}
}
Queue <GraphEdge> m_graphEdges = new Queue <GraphEdge>();
//Add all adjacent to the source node and mark as visited
m_visited[sourceNode] = true;
foreach (GraphEdge edge in m_nodes[sourceNode].m_edges)
{
m_graphEdges.Enqueue(edge);
}
uint iteration = 0;
//While there are elements in our stack
while (m_graphEdges.Count > 0)
{
iteration++;
GraphEdge edge = m_graphEdges.Dequeue();
m_path[edge.m_to] = edge.m_from;
m_visited[edge.m_to] = true;
if (edge.m_to == targetNode)
{
return(m_path);
}
else
{
//Add all new adjacent edges to the stack
foreach (GraphEdge edges in m_nodes[edge.m_to].m_edges)
{
if ((m_visited[edges.m_to] == false) && !m_graphEdges.Contains(edges))
{
m_graphEdges.Enqueue(edges);
}
}
}
}
//If we got here, there is no path;
return(null);
}
public bool Check(NavGraph graph, int sourceNode, int targetNode)
{
graphNodes = graph.Nodes;
nodeCosts[sourceNode] = 0f;
GetAdjacentEdges(sourceNode, graphNodes, graphNodes[targetNode]);
while (edgeQueue.Count() != 0)
{
GraphEdge tempEdge = edgeQueue.Dequeue();
traversedEdges.Add(tempEdge);
if (nodeCosts[tempEdge.To] > nodeCosts[tempEdge.From] + tempEdge.GetCost())
{
nodeRoute[tempEdge.To] = tempEdge.From;
nodeCosts[tempEdge.To] = nodeCosts[tempEdge.From] + tempEdge.GetCost() + manhattanDist(graphNodes[tempEdge.To], graphNodes[tempEdge.From]);
if (tempEdge.To == targetNode)
{
targetNodeFound = true;
continue;
}
}
for (int i = 0; i < graphNodes[tempEdge.To].adjacencyList.Count; i++)
{
bool canAdd = true;
if (traversedEdges.Contains(graphNodes[tempEdge.To].adjacencyList[i]))
{
canAdd = false;
}
else if (edgeQueue.data.Contains(graphNodes[tempEdge.To].adjacencyList[i]))
{
canAdd = false;
}
if (canAdd == true)
{
float priority = manhattanDist(graphNodes[tempEdge.To], graphNodes[targetNode]); //should set the value to be based off of the manhattan distance
graphNodes[tempEdge.To].adjacencyList[i].edgeCost = priority;
nodeCosts[tempEdge.To] = nodeCosts[tempEdge.From] + tempEdge.GetCost();
edgeQueue.Enqueue(graphNodes[tempEdge.To].adjacencyList[i]);
}
}
}
if (targetNodeFound == true)
{
int currentNode = targetNode;
Path.Add(currentNode);
while (currentNode != sourceNode)
{
currentNode = nodeRoute[currentNode];
Path.Add(currentNode);
}
return(true);
}
return(false);
}
private string GenHtmlString(string istrSchemaName)
{
var node = new GraphNode();
var edge = new GraphEdge();
var returnGraphDot = "";
returnGraphDot += GraphStart;
returnGraphDot += node.istrGraphNode;
returnGraphDot += edge.istrGraphEdge;
var clusterIncrement = 0;
if (istrSchemaName.IsNullOrEmpty())
{
TablesAndColumns.Select(x => x.istrSchemaName).DistinctBy(x => x).ToList().ForEach(x1 =>
{
TablesAndColumns.Select(x => x.istrSchemaName).DistinctBy(x => x).ToList().ForEach(SchemaName =>
{
returnGraphDot += "subgraph cluster_" + clusterIncrement + " {\t label=" + SchemaName +
";\t";
returnGraphDot += "bgcolor=" + "\"" + RandomColor() + "\";";
TablesAndColumns.Where(x => x.istrSchemaName.Equals(SchemaName)).ForEach(x =>
{
x.keyValuePairs.ForEach(x2 =>
{
returnGraphDot += new TableSvg(x2.Key, x2.Value).GetTableHtml();
});
});
returnGraphDot += "\t}\t";
clusterIncrement++;
});
});
}
else
{
TablesAndColumns.Select(x => x.istrSchemaName.Equals(istrSchemaName)).DistinctBy(x => x).ToList()
.ForEach(x1 =>
{
TablesAndColumns.Select(x => x.istrSchemaName).DistinctBy(x => x).ToList().ForEach(
SchemaName =>
{
returnGraphDot += "subgraph cluster_" + clusterIncrement + " {\t label=" +
SchemaName + ";\t";
returnGraphDot += "bgcolor=" + "\"" + RandomColor() + "\";";
TablesAndColumns.Where(x => x.istrSchemaName.Equals(SchemaName)).ForEach(x =>
{
x.keyValuePairs.ForEach(x2 =>
{
returnGraphDot += new TableSvg(x2.Key, x2.Value).GetTableHtml();
});
});
returnGraphDot += "\t}\t";
clusterIncrement++;
});
});
}
return(returnGraphDot);
}
public static void RemoveEdge(GraphEdge edge)
{
GraphNode source = Graph.GetNode(edge.source);
source.RemoveEdge(edge.target);
GraphNode target = Graph.GetNode(edge.target);
target.RemoveEdge(edge.source);
}
public void DeleteEdge(GraphEdge edge)
{
GraphNode source = GetNode(edge.source);
source.DeleteEdge(edge.target);
GraphNode target = GetNode(edge.target);
target.DeleteEdge(edge.source);
}
/// <summary>
/// Gets the node importance.
/// </summary>
/// <param name="currentNodeId">The current node identifier.</param>
/// <param name="graphEdge">The graph edge.</param>
/// <returns></returns>
private double GetNodeImportance(int currentNodeId, GraphEdge <int> graphEdge)
{
var pheromoneAmount = GetPheromoneAmount(currentNodeId, graphEdge.DestinationId);
var pheromone = Math.Pow(pheromoneAmount, PheromoneInfluence);
var edgeCost = Math.Pow(graphEdge.Cost, EdgeCostInfluence);
return(pheromone * edgeCost);
}
public bool RemoveEdge(Graph <T> graph, GraphEdge <T> edge)
{
if (edge == null)
{
return(false);
}
return(graph.Edges.Remove(edge));
}
private void InitializeGraph(int V, int E)
{
InitializeGraph(V);
Edges = new GraphEdge[E];
for (int i = 0; i < E; i++)
{
Edges[i] = new GraphEdge();
}
}
public SpawnPosition(GraphEdge graphEdge, Vector2 normal, LevelObjectPrefab.SpawnPosType spawnPosType, Alignment alignment)
{
GraphEdge = graphEdge;
Normal = normal;
SpawnPosType = spawnPosType;
Alignment = alignment;
Length = Vector2.Distance(graphEdge.Point1, graphEdge.Point2);
}
public GraphEdge CreateEdge(int fromId, int toId)
{
GameObject node = nodesAvailable[fromId].gameObject;
GameObject e = Instantiate(edgePrefab, node.transform.position, Quaternion.identity);
GraphEdge edge = e.GetComponent <GraphEdge>();
edge.SetEdge(nodesAvailable[fromId], nodesAvailable[toId], true);
return(edge);
}
// http://math.stackexchange.com/questions/142112/how-to-construct-a-k-regular-graph
// k-regular graph on n vertices.
public static void Graph()
{
HashSet <GraphEdge> edges = new HashSet <GraphEdge>();
int k = 24, n = 350;
//int k = 7, n = 24;
if (k % 2 == 0)
{
int increment = n / (k + 1);
increment = 1;
for (int i = 0; i < n; i++)
{
for (int j = 1; j <= k / 2; j++)
{
int t1 = Clamp(i + j * increment, n);
int t2 = Clamp(i - j * increment, n);
GraphEdge e1 = new GraphEdge(i, t1);
GraphEdge e2 = new GraphEdge(i, t2);
edges.Add(e1);
edges.Add(e2);
}
}
}
else
{
int m = k / 2;
for (int i = 0; i < n; i++)
{
for (int j = 1; j <= m; j++)
{
int t1 = Clamp(i + j, n);
int t2 = Clamp(i - j, n);
GraphEdge e1 = new GraphEdge(i, t1);
GraphEdge e2 = new GraphEdge(i, t2);
edges.Add(e1);
edges.Add(e2);
}
int t3 = Clamp(i + n / 2, n);
edges.Add(new GraphEdge(i, t3));
}
}
using (StreamWriter sw = File.CreateText("733.csv"))
{
foreach (GraphEdge e in edges)
{
sw.WriteLine(string.Format("master{0};master{1}", e.V1, e.V2));
}
}
}
private void Search()
{
var pq = new Heap <GraphNode>(m_Graph.NumNodes(), Compare);
pq.Add(m_Graph.GetNode(m_iSource));
m_CostToThisNode[m_iSource] = 0;
m_SearchFrontier[m_iSource] = new GraphEdge();
while (pq.Count > 0)
{
//get the lowest cost node from the queue. Don't forget, the return value
//is a *node index*, not the node itself. This node is the node not already
//on the SPT that is the closest to the source node
int nextClosestNode = pq.RemoveFirst().Index;
//move this edge from the search frontier to the shortest path tree
m_ShortestPathTree[nextClosestNode] = m_SearchFrontier[nextClosestNode];
if (nextClosestNode == m_iTarget)
{
m_bFound = true;
return;
}
//now to relax the edges. For each edge connected to the next closest node
var edgeList = m_Graph.GetEdgesAt(nextClosestNode);
var edgeNode = edgeList.First;
while (edgeNode != null)
{
var edgeNodeVal = edgeNode.Value;
float newCost = m_CostToThisNode[nextClosestNode] + edgeNodeVal.Cost;
//if this edge has never been on the frontier make a note of the cost
//to reach the node it points to, then add the edge to the frontier
//and the destination node to the PQ.
if (m_SearchFrontier[edgeNodeVal.To] == null)
{
m_CostToThisNode[edgeNodeVal.To] = newCost;
pq.Add(m_Graph.GetNode(edgeNodeVal.To));
m_SearchFrontier[edgeNodeVal.To] = edgeNodeVal;
}
//else test to see if the cost to reach the destination node via the
//current node is cheaper than the cheapest cost found so far. If
//this path is cheaper we assign the new cost to the destination
//node, update its entry in the PQ to reflect the change, and add the
//edge to the frontier
else if (newCost < m_CostToThisNode[edgeNodeVal.To] && m_ShortestPathTree[edgeNodeVal.To] == null)
{
m_CostToThisNode[edgeNodeVal.To] = newCost;
//because the cost is less than it was previously, the PQ must be
//resorted to account for this
pq.UpdateItem(m_Graph.GetNode(edgeNodeVal.To));
m_SearchFrontier[edgeNodeVal.To] = edgeNodeVal;
}
edgeNode = edgeNode.Next;
}
}
}
public void FindEdgeNodeTest()
{
Graph <object, object> g = new Graph <object, object>();
GraphEdge <object, object> ge = g.FindGraphEdge(new object());
Assert.IsNull(ge);
ge = g.FindGraphEdge(null);
Assert.IsNull(ge);
}
public List <int> CalculateDFS(int sourceNode, int targetNode)
{
//@Breadth first search, inefficient to search
List <int> m_path = new List <int>();
for (int y = 0; y < 64; y++)
{
for (int x = 0; x < 64; x++)
{
m_path.Add(-1);//= null value
}
}
List <bool> m_visited = new List <bool>();
for (int y = 0; y < 64; y++)
{
for (int x = 0; x < 64; x++)
{
m_visited.Add(false);
}
}
Stack <GraphEdge> m_graphEdges = new Stack <GraphEdge>();
//Add all adjacent to the source node and mark as visited
m_visited[sourceNode] = true;
foreach (GraphEdge edge in m_nodes[sourceNode].m_edges)
{
m_graphEdges.Push(edge);
}
//While there are elements in our stack
while (m_graphEdges.Count > 0)
{
GraphEdge edge = m_graphEdges.Pop();
m_path[edge.m_to] = edge.m_from;
m_visited[edge.m_to] = true;
if (edge.m_to == targetNode)
{
return(m_path);
}
else
{
//Add all new adjacent edges to the stack
foreach (GraphEdge edges in m_nodes[edge.m_to].m_edges)
{
if (m_visited[edges.m_to] == false)
{
m_graphEdges.Push(edges);
}
}
}
}
//If we got here, there is no path;
return(null);
}
void BuildEdges(GraphNode me, ArrayList others)
{
foreach (GraphNode gn in others)
{
GraphEdge ge = Instantiate(edge) as GraphEdge;
ge.ShowColor(false);
ge.SetPositions(me.transform.position, gn.transform.position);
me.edges.Add(ge);
gn.edges.Add(ge);
}
}
public bool Equals(GraphEdge p)
{
// If parameter is null return false:
if ((object)p == null)
{
return(false);
}
// Return true if the fields match:
return((m_iFrom == p.m_iFrom) && (m_iTo == p.m_iTo));
}
public override bool Equals(object obj)
{
if (obj == null || GetType() != obj.GetType())
{
return(false);
}
GraphEdge edge = (GraphEdge)obj;
return(this == edge);
}
private bool AddEdge(GraphEdge newEdge, List <GraphEdge> edges)
{
if (newEdge == null)
{
return(false);
}
edges.Add(newEdge);
return(true);
}
/// <summary>
/// Add edge to the graph
/// </summary>
public void AddEdge(GraphEdge edge)
{
if (GetEdge(edge.from.index, edge.to.index) == null)
{
edges.Add(edge);
}
else
{
Debug.LogWarning("Edge " + edge.from.index + " - " + edge.to.index + " has already been added.");
}
}
static void SetTargetEdge()
{
GraphEdge edge = GetSelectedGraphEdge();
if (edge == null)
{
Debug.LogError("[jxd] Edge isn't selected!");
return;
}
s_TargetEdge = edge;
}
// Add an edge (but don't add duplicate edges)
public void AddIncidentEdge(GraphEdge e)
{
foreach (GraphEdge edge in incidentEdges)
{
if (edge.ToString() == e.ToString())
{
return;
}
}
incidentEdges.Add(e);
}
public Graph GetTree()
{
// initialize the graph that will hold the MST
Graph mst = new KevinGraph();
// initialize the priority queue that will hold the vertices outside the MST
PriorityQueue remainingVertices = new KevinPriorityQueue();
foreach (GraphVertex v in weightedGraph.GetAllVertices())
{
remainingVertices.Enqueue(new MSTPriorityQueueNode(data: v, priority: int.MaxValue));
}
Dictionary <string, GraphEdge> lowestCostEdgeForVertex = new Dictionary <string, GraphEdge>();
while (remainingVertices.Count() > 0)
{
// Get the vertex with the lowest code to add to the MST
// The first vertex is chosen arbitrarily because all vertices start with max cost.
PriorityQueueNode currentNode = remainingVertices.Dequeue();
GraphVertex currentVertex = currentNode.Data as GraphVertex;
// Add the vertex and its lowest cost edge (if any) to the MST
mst.AddVertex(currentVertex.UniqueKey);
if (lowestCostEdgeForVertex.ContainsKey(currentVertex.UniqueKey))
{
GraphEdge lowestCostEdge = lowestCostEdgeForVertex[currentVertex.UniqueKey];
// TO-DO: why?
mst.AddEdge(lowestCostEdge.SourceVertexUniqueKey, lowestCostEdge.TargetVertexUniqueKey, lowestCostEdge.Weight);
mst.AddEdge(lowestCostEdge.TargetVertexUniqueKey, lowestCostEdge.SourceVertexUniqueKey, lowestCostEdge.Weight);
}
// update the minimum cost for each adjacent vertex, and the associated edge
foreach (GraphEdge edge in currentVertex.GetIncidentEdges())
{
GraphVertex edgeTarget = weightedGraph.GetVertexByUniqueKey(edge.TargetVertexUniqueKey);
if (!remainingVertices.Contains(edgeTarget.UniqueKey))
{
continue;
}
int newCost = edge.Weight;
PriorityQueueNode targetNode = remainingVertices.Peek(edgeTarget.UniqueKey);
if (newCost < targetNode.Priority)
{
remainingVertices.ChangePriority(targetNode.Data.UniqueKey, newCost);
lowestCostEdgeForVertex[edgeTarget.UniqueKey] = edge;
}
}
}
return(mst);
}
public async Task FindLibraryEntryAsync_LogsOnlyPackages(LibraryDependencyTarget libraryDependencyTarget)
{
// Arrange
const string packageX = "x", version = "1.0.0-beta.1", source = "source";
var range = new LibraryRange(packageX, VersionRange.Parse(version), libraryDependencyTarget);
var cacheContext = new SourceCacheContext();
var testLogger = new TestLogger();
var framework = NuGetFramework.Parse("net45");
var token = CancellationToken.None;
var edge = new GraphEdge <RemoteResolveResult>(null, null, null);
var actualIdentity = new LibraryIdentity(packageX, NuGetVersion.Parse(version), LibraryType.Package);
var dependencies = new[] { new LibraryDependency()
{
LibraryRange = new LibraryRange("y", VersionRange.All, LibraryDependencyTarget.Package)
} };
var dependencyInfo = LibraryDependencyInfo.Create(actualIdentity, framework, dependencies);
//package source mapping configuration
Dictionary <string, IReadOnlyList <string> > patterns = new();
patterns.Add(source, new List <string>()
{
packageX
});
PackageSourceMapping sourceMappingConfiguration = new(patterns);
var context = new RemoteWalkContext(cacheContext, sourceMappingConfiguration, testLogger);
var remoteProvider = new Mock <IRemoteDependencyProvider>();
remoteProvider.Setup(e => e.FindLibraryAsync(range, It.IsAny <NuGetFramework>(), It.IsAny <SourceCacheContext>(), testLogger, token))
.ReturnsAsync(actualIdentity);
remoteProvider.SetupGet(e => e.IsHttp).Returns(true);
remoteProvider.SetupGet(e => e.Source).Returns(new PackageSource(source));
remoteProvider.Setup(e => e.GetDependenciesAsync(It.IsAny <LibraryIdentity>(), It.IsAny <NuGetFramework>(), It.IsAny <SourceCacheContext>(), testLogger, token))
.ReturnsAsync(dependencyInfo);
context.RemoteLibraryProviders.Add(remoteProvider.Object);
// Act
var result = await ResolverUtility.FindLibraryEntryAsync(range, framework, null, context, token);
// Assert
Assert.Equal(0, testLogger.Errors);
testLogger.DebugMessages.TryPeek(out string message);
if (libraryDependencyTarget == LibraryDependencyTarget.Package)
{
Assert.Equal($"Package source mapping matches found for package ID '{packageX}' are: '{source}'.", message);
Assert.Equal(version, result.Key.Version.ToString());
Assert.Equal(source, result.Data.Match.Provider.Source.Name);
}
else
{
Assert.Equal(message, null);
}
}
// AddEdge adds the edge, creating endpoint nodes if necessary.
// Edge is added to adjacency list of from edges.
public void AddEdge(string name1, string name2, string relationship)
{
AddNode(name1); // create the node if it doesn't already exist
GraphNode n1 = nodeDict[name1]; // now fetch a reference to the node
AddNode(name2);
GraphNode n2 = nodeDict[name2];
GraphEdge e = new GraphEdge(n1, n2, relationship);
n1.AddIncidentEdge(e);
}
public override bool Equals(object obj)
{
if (obj is GraphEdge)
{
GraphEdge e = (GraphEdge)obj;
return(e.cost == this.cost && e.from == this.from && e.to == this.to);
}
else
{
return(false);
}
}
public async Task FindPackage_VerifyFloatingPackageIsRequiredOnlyFromASingleSource()
{
// Arrange
var range = new LibraryRange("x", VersionRange.Parse("1.0.0-*"), LibraryDependencyTarget.Package);
var cacheContext = new SourceCacheContext();
var testLogger = new TestLogger();
var framework = NuGetFramework.Parse("net45");
var context = new RemoteWalkContext(cacheContext, testLogger);
var token = CancellationToken.None;
var edge = new GraphEdge <RemoteResolveResult>(null, null, null);
var actualIdentity = new LibraryIdentity("x", NuGetVersion.Parse("1.0.0-beta.1"), LibraryType.Package);
var higherIdentity = new LibraryIdentity("x", NuGetVersion.Parse("1.0.0-beta.2"), LibraryType.Package);
var dependencies = new[] { new LibraryDependency()
{
LibraryRange = new LibraryRange("y", VersionRange.All, LibraryDependencyTarget.Package)
} };
var dependencyInfo = LibraryDependencyInfo.Create(actualIdentity, framework, dependencies);
var dependencyInfo2 = LibraryDependencyInfo.Create(higherIdentity, framework, dependencies);
var downloadCount = 0;
// Source1 returns 1.0.0-beta.1
var remoteProvider = new Mock <IRemoteDependencyProvider>();
remoteProvider.Setup(e => e.FindLibraryAsync(range, It.IsAny <NuGetFramework>(), It.IsAny <SourceCacheContext>(), testLogger, token))
.ReturnsAsync(actualIdentity);
remoteProvider.SetupGet(e => e.IsHttp).Returns(true);
remoteProvider.SetupGet(e => e.Source).Returns(new PackageSource("test"));
remoteProvider.Setup(e => e.GetDependenciesAsync(It.IsAny <LibraryIdentity>(), It.IsAny <NuGetFramework>(), It.IsAny <SourceCacheContext>(), testLogger, token))
.ReturnsAsync(dependencyInfo)
.Callback(() => ++ downloadCount);
context.RemoteLibraryProviders.Add(remoteProvider.Object);
// Source2 returns 1.0.0-beta.2
var remoteProvider2 = new Mock <IRemoteDependencyProvider>();
remoteProvider2.Setup(e => e.FindLibraryAsync(range, It.IsAny <NuGetFramework>(), It.IsAny <SourceCacheContext>(), testLogger, token))
.ReturnsAsync(higherIdentity);
remoteProvider2.SetupGet(e => e.IsHttp).Returns(true);
remoteProvider2.SetupGet(e => e.Source).Returns(new PackageSource("test"));
remoteProvider2.Setup(e => e.GetDependenciesAsync(It.IsAny <LibraryIdentity>(), It.IsAny <NuGetFramework>(), It.IsAny <SourceCacheContext>(), testLogger, token))
.ReturnsAsync(dependencyInfo2)
.Callback(() => ++ downloadCount);
context.RemoteLibraryProviders.Add(remoteProvider2.Object);
// Act
var result = await ResolverUtility.FindLibraryEntryAsync(range, framework, null, edge, context, token);
// Assert
// Verify only one download happened
Assert.Equal(1, downloadCount);
Assert.Equal("1.0.0-beta.2", result.Key.Version.ToString());
}
//this method performs the DFS search
private bool Search()
{
//create a std stack of edges
Stack <GraphEdge> stack = new Stack <GraphEdge>();
//create a dummy edge and put on the stack
GraphEdge Dummy = new GraphEdge(m_iSource, m_iSource, 0);
stack.Push(Dummy);
//while there are edges in the stack keep searching
while (0 != stack.Count)
{
//grab the next edge
GraphEdge Next = stack.Peek();
//Debug.Log(Next); //chamto test
//remove the edge from the stack
stack.Pop();
//make a note of the parent of the node this edge points to
m_Route[Next.To()] = Next.From();
//put it on the tree. (making sure the dummy edge is not placed on the tree)
if (Next != Dummy)
{
m_SpanningTree.Add(Next);
}
//and mark it visited
m_Visited[Next.To()] = (int)Aid.visited;
//if the target has been found the method can return success
if (Next.To() == m_iTarget)
{
return(true);
}
//push the edges leading from the node this edge points to onto
//the stack (provided the edge does not point to a previously
//visited node)
foreach (GraphEdge pE in m_Graph.GetEdges(Next.To()))
{
if (m_Visited[pE.To()] == (int)Aid.unvisited)
{
stack.Push(pE);
}
}
}
//no path to target
return(false);
}
public SpawnPosition(GraphEdge graphEdge, Vector2 normal, LevelObjectPrefab.SpawnPosType spawnPosType, Alignment alignment)
{
GraphEdge = graphEdge;
Normal = normal;
SpawnPosType = spawnPosType;
Alignment = alignment;
Length = Vector2.Distance(graphEdge.Point1, graphEdge.Point2);
noiseVal =
(float)(PerlinNoise.CalculatePerlin(GraphEdge.Point1.X / 10000.0f, GraphEdge.Point1.Y / 10000.0f, 0.5f) +
PerlinNoise.CalculatePerlin(GraphEdge.Point1.X / 20000.0f, GraphEdge.Point1.Y / 20000.0f, 0.5f));
}
public void Add(GraphEdge newObj)
{
if ( mSize >= mArray.Length )
{
GraphEdge[] temp = new GraphEdge[mCapacity << 1];
for ( int i = 0; i < (mCapacity << 1); ++i )
{
temp[i] = mArray[i];
}
mCapacity = mCapacity << 1;
mArray = new GraphEdge[mCapacity];
mArray = temp;
}
mArray[mSize] = newObj;
++mSize;
}
public bool Intersects(GraphEdge edge)
{
return LineSegmentGeometryD.Intersects(new LineSegmentGeometryD(this.A.Location, this.B.Location), new LineSegmentGeometryD(edge.A.Location, edge.B.Location));
}
/// <summary>
/// Creates a hallway on the given edge. Gets coordinates of the nodes in the edge,
/// translates into world coordinates, and places the properly stretched hallway
/// between those coordinates
/// </summary>
/// <param name="edge"></param>
private void CreateHallway(GraphEdge edge) {
MazeHallway newHallway = Instantiate(hallwayPrefab) as MazeHallway;
IntVector2 cellCoord1 = MazeGrid.GetNodeCoords(edge.node1);
IntVector2 cellCoord2 = MazeGrid.GetNodeCoords(edge.node2);
Vector3 hallwayPosition = GetHallwayPosition(edge);
newHallway.transform.parent = transform;
newHallway.transform.localPosition = hallwayPosition;
//decide which way the hallway should be rotated
if (cellCoord1.z != cellCoord2.z) {
newHallway.RotateHallway();
}
newHallway.StretchHallway(GetHallwayScale());
//add the hallway to the list
hallways[edge] = newHallway;
}
/// <summary>
/// Adds an outgoing edge.
/// </summary>
/// <param name="edge">The edge.</param>
protected internal void AddOutgoingEdge(GraphEdge edge)
{
Contract.Requires(edge != null);
this.outgoingEdges.Add(edge);
this.AddConnectedNode(edge.To);
this.AddConnectedEdge(edge);
}
private void CreateAllNeighboursToGridNode(int row, int col, int totalrow, int totalcolumn)
{
int noderow = 0;
int nodecol = 0;
for (int i=-1; i<2; ++i)
{
for (int j=-1; j<2; ++j)
{
noderow = row + i;
nodecol = col + j;
//Skip if equal to this node
if((i == 0) && (j == 0))
{
continue;
}
//Check to see if this is a valid neighbour
if(ValidNeighbour(noderow, nodecol, totalrow, totalcolumn))
{
Vector3 posnode = mNavGraph.Nodes[row * totalcolumn + col].Position;
Vector3 posneighbour = mNavGraph.Nodes[noderow * totalcolumn + nodecol].Position;
float dist = Vector3.Distance(posnode, posneighbour);
float fromnodeweight = mNavGraph.Nodes[row * totalcolumn + col].Weight;
float tonodeweight = mNavGraph.Nodes[noderow * totalcolumn + nodecol].Weight;
dist = dist + fromnodeweight + tonodeweight;
GraphEdge newedge = new GraphEdge(row * totalcolumn + col, noderow * totalcolumn + nodecol, dist);
mNavGraph.AddEdge(newedge);
}
}
}
}
private void pushGraphEdge( Site leftSite, Site rightSite, double x1, double y1, double x2, double y2 )
{
GraphEdge newEdge = new GraphEdge ();
allEdges.Add ( newEdge );
newEdge.x1 = x1;
newEdge.y1 = y1;
newEdge.x2 = x2;
newEdge.y2 = y2;
newEdge.site1 = leftSite.sitenbr;
newEdge.site2 = rightSite.sitenbr;
}
GraphEdge EdgeFromDomain(GraphComponent component, Domain d, bool fMustExist=false)
// Return the edge for the indicated domain along its strand. We create this
// edge if it doesn't already exist. The returned edge has edge.A on the 5'
// side of d and edge.B on the 3' side.
{
GraphEdge edge;
if (!this.mpDomainEdge.TryGetValue(d, out edge))
{
Debug.Assert(!fMustExist);
//
// If there's another domain 5' of this one, and he already has
// an edge, then we use the B vertex from that guy; otherwise,
// we make one fresh anew.
//
GraphVertex to5 = null;
if (d.CircularNextTo5 != null)
{
GraphEdge edgeTo5;
if (this.mpDomainEdge.TryGetValue(d.CircularNextTo5, out edgeTo5))
{
to5 = edgeTo5.B;
}
}
if (null == to5)
{
to5 = new GraphVertex(component, "[" + d.DisplayName + ">", d);
}
//
// Ditto, but in the 3' direction
//
GraphVertex to3 = null;
if (d.CircularNextTo3 != null)
{
GraphEdge edgeTo3;
if (this.mpDomainEdge.TryGetValue(d.CircularNextTo3, out edgeTo3))
{
to3 = edgeTo3.A;
}
}
if (null == to3)
{
to3 = new GraphVertex(component, "<" + d.DisplayName + "]", d);
}
//
// Make the new edge
//
double length = this.DomainRenderingLength(d);
edge = new GraphEdge(component, to5, to3, length, Constants.StyleLineDomain);
//
// Apply appropriate forces to the edge
//
SpringForce.CreateSymmetricalSpringForces(component, edge.A, edge.B, Constants.SpringConstantDomain, length);
IntersectionForce.Create(component, edge, Constants.IntersectionForceStrength);
//
// Remember this edge
//
edge.Domain = d;
this.mpDomainEdge[d] = edge;
}
return edge;
}
/// <summary>
/// Saves the action graph (and include dependency network) to a graph gile
/// </summary>
/// <param name="Filename">File name to emit</param>
/// <param name="Description">Description to be stored in graph metadata</param>
/// <param name="VisualizationType">Type of graph to create</param>
/// <param name="Actions">All actions</param>
/// <param name="IncludeCompileActions">True if we should include compile actions. If disabled, only the static link actions will be shown, which is useful to see module relationships</param>
public static void SaveActionGraphVisualization(STBuildTarget Target, string Filename, string Description, ActionGraphVisualizationType VisualizationType, List<Action> Actions, bool IncludeCompileActions = true)
{
// True if we should include individual files in the graph network, or false to include only the build actions
var IncludeFiles = VisualizationType != ActionGraphVisualizationType.OnlyActions;
var OnlyIncludeCPlusPlusFiles = VisualizationType == ActionGraphVisualizationType.OnlyCPlusPlusFilesAndHeaders;
// True if want to show actions in the graph, otherwise we're only showing files
var IncludeActions = VisualizationType != ActionGraphVisualizationType.OnlyFilesAndHeaders && VisualizationType != ActionGraphVisualizationType.OnlyCPlusPlusFilesAndHeaders;
// True if C++ header dependencies should be expanded into the graph, or false to only have .cpp files
var ExpandCPPHeaderDependencies = IncludeFiles && (VisualizationType == ActionGraphVisualizationType.ActionsWithFilesAndHeaders || VisualizationType == ActionGraphVisualizationType.OnlyFilesAndHeaders || VisualizationType == ActionGraphVisualizationType.OnlyCPlusPlusFilesAndHeaders);
var TimerStartTime = DateTime.UtcNow;
var GraphNodes = new List<GraphNode>();
var FileToGraphNodeMap = new Dictionary<FileItem, GraphNode>();
// Filter our list of actions
var FilteredActions = new List<Action>();
{
for (var ActionIndex = 0; ActionIndex < Actions.Count; ++ActionIndex)
{
var Action = Actions[ActionIndex];
if (!IncludeActions || IncludeCompileActions || (Action.ActionType != ActionType.Compile))
{
FilteredActions.Add(Action);
}
}
}
var FilesToCreateNodesFor = new HashSet<FileItem>();
for (var ActionIndex = 0; ActionIndex < FilteredActions.Count; ++ActionIndex)
{
var Action = FilteredActions[ActionIndex];
if (IncludeActions)
{
var GraphNode = new GraphNode()
{
Id = GraphNodes.Count,
// Don't bother including "Link" text if we're excluding compile actions
Label = IncludeCompileActions ? (Action.ActionType.ToString() + " " + Action.StatusDescription) : Action.StatusDescription
};
switch (Action.ActionType)
{
case ActionType.BuildProject:
GraphNode.Color = new GraphColor() { R = 0.3f, G = 1.0f, B = 1.0f, A = 1.0f };
GraphNode.Size = 1.1f;
break;
case ActionType.Compile:
GraphNode.Color = new GraphColor() { R = 0.3f, G = 1.0f, B = 0.3f, A = 1.0f };
break;
case ActionType.Link:
GraphNode.Color = new GraphColor() { R = 0.3f, G = 0.3f, B = 1.0f, A = 1.0f };
GraphNode.Size = 1.2f;
break;
}
GraphNodes.Add(GraphNode);
}
if (IncludeFiles)
{
foreach (var ProducedFileItem in Action.ProducedItems)
{
if (!OnlyIncludeCPlusPlusFiles || IsCPPFile(ProducedFileItem))
{
FilesToCreateNodesFor.Add(ProducedFileItem);
}
}
foreach (var PrerequisiteFileItem in Action.PrerequisiteItems)
{
if (!OnlyIncludeCPlusPlusFiles || IsCPPFile(PrerequisiteFileItem))
{
FilesToCreateNodesFor.Add(PrerequisiteFileItem);
}
}
}
}
var OverriddenPrerequisites = new Dictionary<FileItem, List<FileItem>>();
// Determine the average size of all of the C++ source files
Int64 AverageCPPFileSize;
{
Int64 TotalFileSize = 0;
int CPPFileCount = 0;
foreach (var FileItem in FilesToCreateNodesFor)
{
if (IsCPPFile(FileItem))
{
++CPPFileCount;
TotalFileSize += new FileInfo(FileItem.AbsolutePath).Length;
}
}
if (CPPFileCount > 0)
{
AverageCPPFileSize = TotalFileSize / CPPFileCount;
}
else
{
AverageCPPFileSize = 1;
}
}
var BuildPlatform = STBuildPlatform.GetBuildPlatform(STTargetPlatform.Win64);
foreach (var FileItem in FilesToCreateNodesFor)
{
var FileGraphNode = new GraphNode()
{
Id = GraphNodes.Count,
Label = Path.GetFileName(FileItem.AbsolutePath)
};
if (FileItem.AbsolutePath.EndsWith(".h", StringComparison.InvariantCultureIgnoreCase) ||
FileItem.AbsolutePath.EndsWith(".inl", StringComparison.InvariantCultureIgnoreCase))
{
// Header file
FileGraphNode.Color = new GraphColor() { R = 0.9f, G = 0.2f, B = 0.9f, A = 1.0f };
}
else if (FileItem.AbsolutePath.EndsWith(".cpp", StringComparison.InvariantCultureIgnoreCase) ||
FileItem.AbsolutePath.EndsWith(".c", StringComparison.InvariantCultureIgnoreCase) ||
FileItem.AbsolutePath.EndsWith(".mm", StringComparison.InvariantCultureIgnoreCase))
{
// C++ file
FileGraphNode.Color = new GraphColor() { R = 1.0f, G = 1.0f, B = 0.3f, A = 1.0f };
}
else
{
// Other file
FileGraphNode.Color = new GraphColor() { R = 0.4f, G = 0.4f, B = 0.1f, A = 1.0f };
}
// Set the size of the file node based on the size of the file on disk
var bIsCPPFile = IsCPPFile(FileItem);
if (bIsCPPFile)
{
var MinNodeSize = 0.25f;
var MaxNodeSize = 2.0f;
var FileSize = new FileInfo(FileItem.AbsolutePath).Length;
float FileSizeScale = (float)((double)FileSize / (double)AverageCPPFileSize);
var SourceFileSizeScaleFactor = 0.1f; // How much to make nodes for files bigger or larger based on their difference from the average file's size
FileGraphNode.Size = Math.Min(Math.Max(1.0f + SourceFileSizeScaleFactor * FileSizeScale, MinNodeSize), MaxNodeSize);
}
//@todo: Testing out attribute support. Replace with an attribute that is actually useful!
//if( FileItem.PrecompiledHeaderIncludeFilename != null )
//{
//FileGraphNode.Attributes[ "PCHFile" ] = Path.GetFileNameWithoutExtension( FileItem.PrecompiledHeaderIncludeFilename );
//}
FileToGraphNodeMap[FileItem] = FileGraphNode;
GraphNodes.Add(FileGraphNode);
if (ExpandCPPHeaderDependencies && bIsCPPFile)
{
bool HasUObjects;
List<DependencyInclude> DirectlyIncludedFilenames = CPPEnvironment.GetDirectIncludeDependencies(Target, FileItem, BuildPlatform, bOnlyCachedDependencies: false, HasUObjects: out HasUObjects);
// Resolve the included file name to an actual file.
var DirectlyIncludedFiles =
DirectlyIncludedFilenames
.Where(DirectlyIncludedFilename => !string.IsNullOrEmpty(DirectlyIncludedFilename.IncludeResolvedName))
.Select(DirectlyIncludedFilename => DirectlyIncludedFilename.IncludeResolvedName)
// Skip same include over and over (.inl files)
.Distinct()
.Select(FileItem.GetItemByFullPath)
.ToList();
OverriddenPrerequisites[FileItem] = DirectlyIncludedFiles;
}
}
// Connect everything together
var GraphEdges = new List<GraphEdge>();
if (IncludeActions)
{
for (var ActionIndex = 0; ActionIndex < FilteredActions.Count; ++ActionIndex)
{
var Action = FilteredActions[ActionIndex];
var ActionGraphNode = GraphNodes[ActionIndex];
List<FileItem> ActualPrerequisiteItems = Action.PrerequisiteItems;
if (IncludeFiles && ExpandCPPHeaderDependencies && Action.ActionType == ActionType.Compile)
{
// The first prerequisite is always the .cpp file to compile
var CPPFile = Action.PrerequisiteItems[0];
if (!IsCPPFile(CPPFile))
{
throw new BuildException("Was expecting a C++ file as the first prerequisite for a Compile action");
}
ActualPrerequisiteItems = new List<FileItem>();
ActualPrerequisiteItems.Add(CPPFile);
}
foreach (var PrerequisiteFileItem in ActualPrerequisiteItems)
{
if (IncludeFiles)
{
GraphNode PrerequisiteFileGraphNode;
if (FileToGraphNodeMap.TryGetValue(PrerequisiteFileItem, out PrerequisiteFileGraphNode))
{
// Connect a file our action is dependent on, to our action itself
var GraphEdge = new GraphEdge()
{
Id = GraphEdges.Count,
Source = PrerequisiteFileGraphNode,
Target = ActionGraphNode,
};
GraphEdges.Add(GraphEdge);
}
else
{
// Not a file we were tracking
// Console.WriteLine( "Unknown file: " + PrerequisiteFileItem.AbsolutePath );
}
}
else if (PrerequisiteFileItem.ProducingAction != null)
{
// Not showing files, so connect the actions together
var ProducingActionIndex = FilteredActions.IndexOf(PrerequisiteFileItem.ProducingAction);
if (ProducingActionIndex != -1)
{
var SourceGraphNode = GraphNodes[ProducingActionIndex];
var GraphEdge = new GraphEdge()
{
Id = GraphEdges.Count,
Source = SourceGraphNode,
Target = ActionGraphNode,
};
GraphEdges.Add(GraphEdge);
}
else
{
// Our producer action was filtered out
}
}
}
foreach (var ProducedFileItem in Action.ProducedItems)
{
if (IncludeFiles)
{
if (!OnlyIncludeCPlusPlusFiles || IsCPPFile(ProducedFileItem))
{
var ProducedFileGraphNode = FileToGraphNodeMap[ProducedFileItem];
var GraphEdge = new GraphEdge()
{
Id = GraphEdges.Count,
Source = ActionGraphNode,
Target = ProducedFileGraphNode,
};
GraphEdges.Add(GraphEdge);
}
}
}
}
}
if (IncludeFiles && ExpandCPPHeaderDependencies)
{
// Fill in overridden prerequisites
foreach (var FileAndPrerequisites in OverriddenPrerequisites)
{
var FileItem = FileAndPrerequisites.Key;
var FilePrerequisites = FileAndPrerequisites.Value;
var FileGraphNode = FileToGraphNodeMap[FileItem];
foreach (var PrerequisiteFileItem in FilePrerequisites)
{
GraphNode PrerequisiteFileGraphNode;
if (FileToGraphNodeMap.TryGetValue(PrerequisiteFileItem, out PrerequisiteFileGraphNode))
{
var GraphEdge = new GraphEdge()
{
Id = GraphEdges.Count,
Source = PrerequisiteFileGraphNode,
Target = FileGraphNode,
};
GraphEdges.Add(GraphEdge);
}
else
{
// Some other header that we don't track directly
//Console.WriteLine( "File not known: " + PrerequisiteFileItem.AbsolutePath );
}
}
}
}
GraphVisualization.WriteGraphFile(Filename, Description, GraphNodes, GraphEdges);
if (BuildConfiguration.bPrintPerformanceInfo)
{
var TimerDuration = DateTime.UtcNow - TimerStartTime;
Log.TraceInformation("Generating and saving ActionGraph took " + TimerDuration.TotalSeconds + "s");
}
}
/// <summary>
/// Add an edge to the graph.
/// </summary>
/// <param name="edge">Edge to add.</param>
public void Add(GraphEdge edge)
{
this.edges.Add(edge);
}
public static void Create(GraphComponent component, GraphEdge eNew, double strength)
{
if (strength != 0)
{
foreach (GraphEdge eExist in component.Edges)
{
if (eExist != eNew && !eExist.IncidentTo(eNew))
{
new IntersectionForce(component, eExist.A, strength, eExist, eNew, eNew.A);
new IntersectionForce(component, eNew.A, strength, eExist, eNew, eExist.A);
//
new IntersectionForce(component, eExist.B, strength, eExist, eNew, eNew.B);
new IntersectionForce(component, eNew.B, strength, eExist, eNew, eExist.B);
}
}
}
}
private Vector3 GetHallwayPosition(GraphEdge edge) {
IntVector2 cellCoord1 = MazeGrid.GetNodeCoords(edge.node1);
IntVector2 cellCoord2 = MazeGrid.GetNodeCoords(edge.node2);
Vector3 cellPosition1 = GetCellLocalPosition(cellCoord1.x, cellCoord1.z);
Vector3 cellPosition2 = GetCellLocalPosition(cellCoord2.x, cellCoord2.z);
Vector3 hallwayPosition = (cellPosition1 + cellPosition2) / 2.0f;
hallwayPosition.y += 0.3f;
return hallwayPosition;
}
void WireHydrogenBond(GraphComponent component, Domain d, GraphVertex from, GraphVertex to, GraphVertex fromAux, GraphVertex toAux)
{
if (!WiredHydrogenBondsOf(from).Contains(to))
{
Debug.Assert(!WiredHydrogenBondsOf(to).Contains(from));
WiredHydrogenBondsOf(from).Add(to);
WiredHydrogenBondsOf(to).Add(from);
double length = this.HydrogenBondLength(d, d.Connection);
GraphEdge edge = new GraphEdge(component, from, to, length, Constants.StyleLineHydrogenBond);
// edge.Visualization.Shaft = VisualGraphEdge.SHAFT.Full; // we don't show the end line of domains as we now shade the double stranded region entirely
SpringForce.CreateSymmetricalSpringForces(component, edge.A, edge.B, Constants.SpringConstantHydrogenBond, length);
IntersectionForce.Create(component, edge, Constants.IntersectionForceStrength);
new RightAngleForce(component, fromAux, from, to, Constants.RightAngleStrength);
new RightAngleForce(component, toAux, to, from, Constants.RightAngleStrength);
}
}
public List<GraphEdge> AStar(Vector3 start, Vector3 end)
{
List<float> gCosts = new List<float>();
List<float> fCosts = new List<float>();
List<GraphEdge> spt = new List<GraphEdge>(); // shortest path tree
List<GraphEdge> searchFrontier = new List<GraphEdge>();
for (int i = 0; i < Nodes.Count; ++i)
{
gCosts.Add(9999);
fCosts.Add(9999);
searchFrontier.Add(new GraphEdge(-1, -1));
}
BinaryHeap pq = new BinaryHeap();
int index = 0;
while (pq.Count() == 0 && index < Nodes.Count)
{
// check if we've found the node we want to start at
#if USE_XZ
if (Nodes[index].GetPosition().x == start.x && Nodes[index].GetPosition().z == start.z)
#else // USE_ZY
if (Nodes[index].GetPosition().x == start.x && Nodes[index].GetPosition().y == start.y)
#endif //USE_XZ
{
pq.Add(0, index); // add it to our pq
gCosts[index] = 0; // set its g cost
fCosts[index] = 0; // set its f cost
searchFrontier[index] = new GraphEdge(index, index); // add it to frontier
}
++index;
}
Vector2 endPosV2;
#if USE_XZ
endPosV2 = new Vector2(end.x, end.z);
#else //USE_XY
endPosV2 = new Vector2(end.x, end.y);
#endif
while (pq.Count() > 0)
{
int closestNode = pq.Values(0);
pq.RemoveAt(0);
if (!spt.Contains(searchFrontier[closestNode]))
spt.Add(searchFrontier[closestNode]); // if I use insert here, then later I can index it instead of searching for it
Vector2 curPositionV2 = new Vector2(Nodes[closestNode].GetPosition().x,
#if USE_XZ
Nodes[closestNode].GetPosition().z);
#else
Nodes[closestNode].GetPosition().y);
#endif
if (curPositionV2 == endPosV2)
{
return spt;
}
GraphNode curNode = Nodes[closestNode];
for (int i = 0; i < curNode.mEdges.GetSize(); ++i)
{
// index of the node that this edge is pointing to
int edgeToIndex = curNode.mEdges.Loc(i).GetToIndex();
float g = gCosts[curNode.GetIndex()] + (curNode.GetPosition() - Nodes[edgeToIndex].GetPosition()).sqrMagnitude;
float h = (end - Nodes[edgeToIndex].GetPosition()).sqrMagnitude;
float f = g + h;
// this is where I would index for the edge
//if (searchFrontier[edgeToIndex].GetToIndex() == -1 &&
// searchFrontier[edgeToIndex].GetFromIndex() == -1)
bool onFrontier = false;
for (int j = 0; j < searchFrontier.Count; +++j)
{
if (searchFrontier[j].GetToIndex() == edgeToIndex)
{
onFrontier = true;
break;
}
}
if (!onFrontier)
{
searchFrontier[edgeToIndex] = curNode.mEdges.Loc(i);
gCosts[edgeToIndex] = g;
fCosts[edgeToIndex] = f;
if (pq.ContainsValue(edgeToIndex))
{
int pqIndex = pq.IndexOfValue(edgeToIndex);
float oldFCost = pq.Keys(pqIndex);
if (f < oldFCost) // if path is shorter
{
pq.RemoveAt(pqIndex);
pq.Add(f, edgeToIndex);
}
}
else
{
pq.Add(f, edgeToIndex);
}
}
else
{
int indexOfEdgeToIndex = pq.IndexOfValue(edgeToIndex);
if (indexOfEdgeToIndex >= 0 && f < pq.Keys(indexOfEdgeToIndex))
{
pq.RemoveAt(indexOfEdgeToIndex);
pq.Add(f, edgeToIndex);
}
}
}
}
//Debug.LogWarning("Path to destination not found");
spt = new List<GraphEdge>(); // clear the list to represent no path found
return spt;
}
public void SaveGraphVisualization(List<string> Nodes)
{
var TimerStartTime = DateTime.UtcNow;
var GraphNodes = new List<GraphNode>();
var NodeToGraphNodeMap = new Dictionary<string, GraphNode>();
for (var NodeIndex = 0; NodeIndex < Nodes.Count; ++NodeIndex)
{
var Node = Nodes[NodeIndex];
var GraphNode = new GraphNode()
{
Id = GraphNodes.Count,
Label = Node
};
GraphNodes.Add(GraphNode);
NodeToGraphNodeMap.Add(Node, GraphNode);
}
// Connect everything together
var GraphEdges = new List<GraphEdge>();
for (var NodeIndex = 0; NodeIndex < Nodes.Count; ++NodeIndex)
{
var Node = Nodes[NodeIndex];
GraphNode NodeGraphNode = NodeToGraphNodeMap[Node];
foreach (var Dep in GUBPNodes[Node].FullNamesOfDependencies)
{
GraphNode PrerequisiteFileGraphNode;
if (NodeToGraphNodeMap.TryGetValue(Dep, out PrerequisiteFileGraphNode))
{
// Connect a file our action is dependent on, to our action itself
var NewGraphEdge = new GraphEdge()
{
Id = GraphEdges.Count,
Source = PrerequisiteFileGraphNode,
Target = NodeGraphNode,
Color = new GraphColor() { R = 0.0f, G = 0.0f, B = 0.0f, A = 0.75f }
};
GraphEdges.Add(NewGraphEdge);
}
}
foreach (var Dep in GUBPNodes[Node].FullNamesOfPseudosependencies)
{
GraphNode PrerequisiteFileGraphNode;
if (NodeToGraphNodeMap.TryGetValue(Dep, out PrerequisiteFileGraphNode))
{
// Connect a file our action is dependent on, to our action itself
var NewGraphEdge = new GraphEdge()
{
Id = GraphEdges.Count,
Source = PrerequisiteFileGraphNode,
Target = NodeGraphNode,
Color = new GraphColor() { R = 0.0f, G = 0.0f, B = 0.0f, A = 0.25f }
};
GraphEdges.Add(NewGraphEdge);
}
}
}
string Filename = CommandUtils.CombinePaths(CommandUtils.CmdEnv.LogFolder, "GubpGraph.gexf");
Log("Writing graph to {0}", Filename);
GraphVisualization.WriteGraphFile(Filename, "GUBP Nodes", GraphNodes, GraphEdges);
Log("Wrote graph to {0}", Filename);
}
public IntersectionForce(GraphComponent component, IPhysicalObject target, double strength, GraphEdge a, GraphEdge b, IPhysicalObject reference) : base(component,target,strength)
{
this.a = a;
this.b = b;
this.reference = reference;
}
public void UpdateNodeEdgesInfo(int index,float value)
{
Assert.IsTrue (index >= 0 && index < mNavGraph.NextFreeNodeIndex);
//Update Nodes weight first
mNavGraph.Nodes [index].Weight += value;
//Update edge info that starts from Node[index]
GraphEdge e;
for (int i = 0; i < mNavGraph.mEdgesList[index].Count; i++) {
e = mNavGraph.mEdgesList[index][i];
e.Cost += value;
}
//Update edge info that ends with Node[index]
int fromindex = 0;
GraphEdge edge = new GraphEdge ();
for (int i = -1; i <= 1; i++) {
for(int j = -1; j <= 1; j++)
{
fromindex = index + j + i * mColumn;
if(IsValidIndex(fromindex) && fromindex != index)
{
edge = mNavGraph.mEdgesList[fromindex].Find( x => x.To == index);
if(edge != null)
{
edge.Cost += value;
}
}
}
}
}
public void ToString_success()
{
var edge = new GraphEdge<int>(new GraphNode<int>(1), new GraphNode<int>(2));
var toString = edge.ToString();
Assert.AreEqual("{1} -> {2}", toString);
}
/// <summary>
/// Adds an incoming edge.
/// </summary>
/// <param name="edge">The edge.</param>
protected internal void AddIncomingEdge(GraphEdge edge)
{
Contract.Requires(edge != null);
this.incomingEdges.Add(edge);
this.AddConnectedNode(edge.From);
this.AddConnectedEdge(edge);
}
public void AddEdge(GraphEdge edge)
{
mEdges.Add(edge);
//fastEdges.Add(edge);
}
public DynArray(GraphEdge type)
{
mArray = new GraphEdge[8];
mCapacity = 8;
mSize = 0;
}
public GraphEdge(GraphEdge e)
{
mFrom = e.From;
mTo = e.To;
mCost = e.Cost;
}
/// <summary>
/// Exports the build graph as a GEXF file, for visualization in an external tool (eg. Gephi).
/// </summary>
/// <param name="Nodes">The nodes in the graph</param>
static void SaveGraphVisualization(IEnumerable<BuildNode> Nodes)
{
// Create a graph node for each GUBP node in the graph
List<GraphNode> GraphNodes = new List<GraphNode>();
Dictionary<BuildNode, GraphNode> NodeToGraphNodeMap = new Dictionary<BuildNode, GraphNode>();
foreach(BuildNode Node in Nodes)
{
GraphNode GraphNode = new GraphNode();
GraphNode.Id = NodeToGraphNodeMap.Count;
GraphNode.Label = Node.Name;
NodeToGraphNodeMap.Add(Node, GraphNode);
GraphNodes.Add(GraphNode);
}
// Connect everything together
List<GraphEdge> GraphEdges = new List<GraphEdge>();
foreach(KeyValuePair<BuildNode, GraphNode> NodeToGraphNodePair in NodeToGraphNodeMap)
{
foreach (BuildNode Dependency in NodeToGraphNodePair.Key.Dependencies)
{
GraphNode PrerequisiteFileGraphNode;
if (NodeToGraphNodeMap.TryGetValue(Dependency, out PrerequisiteFileGraphNode))
{
// Connect a file our action is dependent on, to our action itself
GraphEdge NewGraphEdge = new GraphEdge();
NewGraphEdge.Id = GraphEdges.Count;
NewGraphEdge.Source = PrerequisiteFileGraphNode;
NewGraphEdge.Target = NodeToGraphNodePair.Value;
NewGraphEdge.Color = new GraphColor() { R = 0.0f, G = 0.0f, B = 0.0f, A = 0.75f };
GraphEdges.Add(NewGraphEdge);
}
}
foreach (BuildNode Dependency in NodeToGraphNodePair.Key.PseudoDependencies)
{
GraphNode PrerequisiteFileGraphNode;
if (NodeToGraphNodeMap.TryGetValue(Dependency, out PrerequisiteFileGraphNode))
{
// Connect a file our action is dependent on, to our action itself
GraphEdge NewGraphEdge = new GraphEdge();
NewGraphEdge.Id = GraphEdges.Count;
NewGraphEdge.Source = PrerequisiteFileGraphNode;
NewGraphEdge.Target = NodeToGraphNodePair.Value;
NewGraphEdge.Color = new GraphColor() { R = 0.0f, G = 0.0f, B = 0.0f, A = 0.25f };
GraphEdges.Add(NewGraphEdge);
}
}
}
// Export the graph definition
string Filename = CommandUtils.CombinePaths(CommandUtils.CmdEnv.LogFolder, "GubpGraph.gexf");
Log("Writing graph to {0}", Filename);
GraphVisualization.WriteGraphFile(Filename, "GUBP Nodes", NodeToGraphNodeMap.Values.ToList(), GraphEdges);
Log("Wrote graph to {0}", Filename);
}
protected override int ExecuteTest()
{
var edges = new GraphEdge[SearchSpaceSize];
var removedNodes = 0;
for (var i = 0; i < SearchSpaceSize; i++)
{
// This test only checks non-terminals.
if (NodeStates.IsTarget(i)) continue;
// Nodes with less than 3 neighbors are covered by DegreeTest
// Nodes are limited to 7 neighbors because this test is exponential in the neighbor count.
var neighbors = EdgeSet.NeighborsOf(i);
if (neighbors.Count < 3 || neighbors.Count > 7) continue;
// Cache the edges. They might be removed from EdgeSet when we need them.
foreach (var neighbor in neighbors)
{
edges[neighbor] = EdgeSet[i, neighbor];
}
// Check whether each subset satisfies the condition.
var canBeRemoved = true;
foreach (var subset in GetAllSubsets(neighbors))
{
// Only subsets of at least size 3 are relevant.
if (subset.Count < 3) continue;
// Sum up the weights of all edges between the nodes of the subsets and i.
var edgeSum = subset.Sum(j => edges[j].Weight);
// Build the MST of the fully connected graph of the nodes in the subset with the bottleneck
// Steiner distances as edge weights.
var mst = new MinimalSpanningTree(subset, SMatrix);
mst.Span(subset[0]);
// Sum up the edge weights of the MST.
var mstSum = mst.SpanningEdges.Sum(e => e.Priority);
// The condition is only satisfied if edgeSum >= mstSum.
if (edgeSum < mstSum)
{
canBeRemoved = false;
break;
}
}
if (!canBeRemoved) continue;
// Remove i and replace its edges.
foreach (var neighbor in neighbors)
{
// Remove the old edges between i and its neighbors.
var edge = edges[neighbor];
EdgeSet.Remove(edge);
// For each pair of neighbors create a new edge.
foreach (var neighbor2 in neighbors)
{
if (neighbor >= neighbor2) continue;
// The weight of the new edge between the two neighbors is the sum of their edge weights to i.
var edge2 = edges[neighbor2];
var newEdgeWeight = edge.Weight + edge2.Weight;
// Only add this edge if it wouldn't be removed by the Paths with many terminals test.
if (newEdgeWeight <= SMatrix[neighbor, neighbor2])
{
EdgeSet.Add(neighbor, neighbor2, newEdgeWeight);
}
}
}
NodeStates.MarkNodeAsRemoved(i);
removedNodes++;
}
return removedNodes;
}
public void ValueCopy(GraphEdge edge)
{
mFrom = edge.From;
mTo = edge.To;
mCost = edge.Cost;
}
//The A* search algorithm with strickdistance with wall consideration
private void Search(float strickdistance, bool isignorewall)
{
float currentnodetotargetdistance = Mathf.Infinity;
mPQ.Clear();
mPQ.Push(mFCosts[mISource]);
//mSearchFrontier [mISource] = new GraphEdge (mISource, mISource, 0.0f);
mSearchFrontier[mISource].From = mISource;
mSearchFrontier[mISource].To = mISource;
mSearchFrontier[mISource].Cost = 0.0f;
GraphEdge edge = new GraphEdge();
int nextclosestnode = -1;
while (!mPQ.Empty())
{
//Get lowest cost node from the queue
nextclosestnode = mPQ.Pop().Key;
mAStarPathInfo.NodesSearched++;
//move this node from the frontier to the spanning tree
if (mSearchFrontier[nextclosestnode] != null && mSearchFrontier[nextclosestnode].IsValidEdge())
{
mShortestPathTree[nextclosestnode] = mSearchFrontier[nextclosestnode];
}
currentnodetotargetdistance = Heuristic_Euclid.Calculate(mGraph, mITarget, nextclosestnode);
if (nextclosestnode == mITarget || (currentnodetotargetdistance <= strickdistance && !mGraph.Nodes[nextclosestnode].IsWall))
{
mITarget = nextclosestnode;
return;
}
//Now to test all the edges attached to this node
List<GraphEdge> edgelist = mGraph.EdgesList[nextclosestnode];
for (int i = 0; i < edgelist.Count; i++)
{
//Avoid pass refrence
edge.Reset();
edge.From = edgelist[i].From;
edge.To = edgelist[i].To;
edge.Cost = edgelist[i].Cost;
//calculate the heuristic cost from this node to the target (H)
float hcost = Heuristic_Euclid.Calculate(mGraph, mITarget, edge.To) * mHCostPercentage;
//calculate the 'real' cost to this node from the source (G)
float gcost = 0.0f;
if (isignorewall)
{
gcost = mGCosts[nextclosestnode] + edge.Cost;
if (mGraph.Nodes[edge.From].IsWall)
{
gcost -= mGraph.Nodes[edge.From].Weight;
}
if (mGraph.Nodes[edge.To].IsWall)
{
gcost -= mGraph.Nodes[edge.To].Weight;
}
}
else
{
gcost = mGCosts[nextclosestnode] + edge.Cost;
if (mGraph.Nodes[edge.From].IsJumpable)
{
gcost -= mGraph.Nodes[edge.From].Weight;
}
if (mGraph.Nodes[edge.To].IsJumpable)
{
gcost -= mGraph.Nodes[edge.To].Weight;
}
}
//if the node has not been added to the frontier, add it and update the G and F costs
if (mSearchFrontier[edge.To] != null && !mSearchFrontier[edge.To].IsValidEdge())
{
mFCosts[edge.To].Value = gcost + hcost;
mGCosts[edge.To] = gcost;
mPQ.Push(mFCosts[edge.To]);
mSearchFrontier[edge.To].ValueCopy(edge);
mAStarPathInfo.EdgesSearched++;
if (mBDrawExplorePath)
{
Debug.DrawLine(mGraph.Nodes[edge.From].Position, mGraph.Nodes[edge.To].Position, Color.yellow, mExplorePathRemainTime);
}
}
//if this node is already on the frontier but the cost to get here
//is cheaper than has been found previously, update the node
//cost and frontier accordingly
else if (gcost < mGCosts[edge.To])
{
mFCosts[edge.To].Value = gcost + hcost;
mGCosts[edge.To] = gcost;
//Due to some node's f cost has been changed
//we should reoder the priority queue to make sure we pop up the lowest fcost node first
//compare the fcost will make sure we search the path in the right direction
//h cost is the key to search in the right direction
mPQ.ChangePriority(edge.To);
mSearchFrontier[edge.To].ValueCopy(edge);
mAStarPathInfo.EdgesSearched++;
}
}
}
}
//----------------------------------------------------------------------------------------
// Operations
//----------------------------------------------------------------------------------------
public bool IncidentTo(GraphEdge him)
{
return this.IncidentTo(him.A) || this.IncidentTo(him.B);
}
private void DestroyHallway(GraphEdge edge) {
Destroy(hallways[edge].gameObject);
}