GameCult/Aetheria
Watch
9
0
Fork
You've already forked Aetheria
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
Aetheria/Assets/Plugins/MSAGL/Layout/LargeGraphLayout/LgInteractor.cs
Reinier Vens dbc522a224 Weapos Rejiggered 
Modified weapon scripts to eliminate specialized projectile behavior - allows charged weapons to have projectiles and modify weapon stats when charged
Added machine gun weapon & VFX
Moved third party code to Plugins folder to improve compile times
2021-01-31 03:52:32 +00:00

4344 lines
173 KiB
C#
Raw Blame History

using System;
using System.CodeDom;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.Msagl.Core;
using Microsoft.Msagl.Core.DataStructures;
using Microsoft.Msagl.Core.Geometry;
using Microsoft.Msagl.Core.Geometry.Curves;
using Microsoft.Msagl.Core.GraphAlgorithms;
using Microsoft.Msagl.Core.Layout;
using Microsoft.Msagl.Core.Layout.ProximityOverlapRemoval.MinimumSpanningTree;
using Microsoft.Msagl.Core.Routing;
using Microsoft.Msagl.DebugHelpers;
using Microsoft.Msagl.GraphmapsWithMesh;
using Microsoft.Msagl.Layout.Incremental;
using Microsoft.Msagl.Layout.Initial;
using Microsoft.Msagl.Layout.LargeGraphLayout.NodeRailLevelCalculator;
using Microsoft.Msagl.Layout.Layered;
using Microsoft.Msagl.Layout.MDS;
using Microsoft.Msagl.Layout.OverlapRemovalFixedSegments;
using Microsoft.Msagl.Miscellaneous;
using Microsoft.Msagl.Miscellaneous.ConstrainedSkeleton;
using Microsoft.Msagl.Miscellaneous.RegularGrid;
using Microsoft.Msagl.Miscellaneous.Routing;
using Microsoft.Msagl.Routing.Visibility;
using Edge = Microsoft.Msagl.Core.Layout.Edge;
using LineSegment = Microsoft.Msagl.Core.Geometry.Curves.LineSegment;
using Point = Microsoft.Msagl.Core.Geometry.Point;
using Rectangle = Microsoft.Msagl.Core.Geometry.Rectangle;
using Size = Microsoft.Msagl.Core.DataStructures.Size;
using SymmetricSegment = Microsoft.Msagl.Core.DataStructures.SymmetricTuple<Microsoft.Msagl.Core.Geometry.Point>;
#if REPORTING
using Timer = Microsoft.Msagl.DebugHelpers.Timer;
#endif
namespace Microsoft.Msagl.Layout.LargeGraphLayout
{
/// <summary>
/// enables to interactively explore a large graph
/// </summary>
public class LgInteractor
{
const bool ShrinkEdgeLengths = true;
readonly bool _initFromPrecomputedLgData;
readonly LgData _lgData;
readonly LgLayoutSettings _lgLayoutSettings;
readonly CancelToken _cancelToken;
readonly GeometryGraph _mainGeometryGraph;
public Tiling g;
Dictionary<Point, int> PointToId = new Dictionary<Point, int>();
public Dictionary<Point, int> locationtoNode = new Dictionary<Point, int>();
public Dictionary<int, Node> idToNode;
/// <summary>
/// </summary>
bool _runInParallel = true;
RailGraph _railGraph;
Rectangle _visibleRectangle;
public Dictionary<LgNodeInfo, LgNodeInfo.LabelPlacement> SelectedNodeLabels = new Dictionary<LgNodeInfo, LgNodeInfo.LabelPlacement>();
/// <summary>
/// constructor
/// </summary>
/// <param name="geometryGraph"></param>
/// <param name="lgLayoutSettings"></param>
/// <param name="cancelToken"></param>
public LgInteractor(GeometryGraph geometryGraph, LgLayoutSettings lgLayoutSettings, CancelToken cancelToken)
{
_mainGeometryGraph = geometryGraph;
_lgLayoutSettings = lgLayoutSettings;
_cancelToken = cancelToken;
if (geometryGraph.LgData == null)
{
_lgData = new LgData(geometryGraph)
{
GeometryNodesToLgNodeInfos = lgLayoutSettings.GeometryNodesToLgNodeInfos
};
geometryGraph.LgData = _lgData;
}
else
{
_initFromPrecomputedLgData = true;
_lgData = geometryGraph.LgData;
_lgLayoutSettings.GeometryNodesToLgNodeInfos = _lgData.GeometryNodesToLgNodeInfos;
}
// add skeleton levels
AddSkeletonLevels();
}
double CurrentZoomLevel { get; set; }
/// <summary>
/// this graph is currently visible set of nodes and pieces of edges
/// </summary>
public RailGraph RailGraph
{
get { return _railGraph; }
}
/// <summary>
/// </summary>
public IDictionary<Edge, LgEdgeInfo> GeometryEdgesToLgEdgeInfos
{
get { return _lgData.GeometryEdgesToLgEdgeInfos; }
}
public Set<LgNodeInfo> SelectedNodeInfos
{
get { return _lgData.SelectedNodeInfos; }
}
void AddSkeletonLevels()
{
for (int i = _lgData.SkeletonLevels.Count; i < _lgData.Levels.Count(); i++)
{
_lgData.SkeletonLevels.Add(new LgSkeletonLevel { ZoomLevel = _lgData.Levels[i].ZoomLevel });
}
}
public Tiling[] calculateGraphsForEachZoomLevel(Tiling g, Dictionary<Node, int> nodeToId, bool hugeGraph)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
Console.WriteLine("Calculating Graphs For Each ZoomLevel");
List<Tiling> graphs = new List<Tiling>();
Tiling OldGraphHolder = null;
DijkstraAlgo dijkstra = new DijkstraAlgo();
g.pathList = new Dictionary<Edge, List<int>>();
Dictionary<Edge,List<VertexNeighbor>> ssp = new Dictionary<Edge, List<VertexNeighbor>>();
//for (int i = g.maxTheoreticalZoomLevel; i >= 1; i /= 2)
for (int i = 1; i <= g.maxTheoreticalZoomLevel; i *= 2)
{
//create a new graph and copy the vertex properties of the basic graph
Tiling newG = new Tiling(g.NumOfnodes, true);
newG.N = g.N;
for (int j = 0; j < g.NumOfnodes; j++)
{
newG.VList[j] = new Vertex(g.VList[j].XLoc, g.VList[j].YLoc) { Id = g.VList[j].Id, ZoomLevel = g.VList[j].ZoomLevel };
newG.VList[j].TargetX = newG.VList[j].PreciseX = newG.VList[j].XLoc;
newG.VList[j].TargetY = newG.VList[j].PreciseY = newG.VList[j].YLoc;
}
//copy bottom level graph O(V+E)
if (OldGraphHolder != null)
{
for (int j = 0; j < OldGraphHolder.NumOfnodes; j++)
{
for (int k = 0; k < OldGraphHolder.DegList[j]; k++)
{
newG.AddEdge(j, OldGraphHolder.EList[j, k].NodeId, OldGraphHolder.EList[j, k].Selected, OldGraphHolder.EList[j, k].Used);
}
}
}
//create the edges of the new graph
//for each edge (s,t), if both s and t are below ith zoomlevel, then find a s-t path
//try lev's code for shortest path here
foreach (Edge edge in _mainGeometryGraph.Edges)
{
int sourceZoomLevel = g.VList[nodeToId[edge.Source]].ZoomLevel;
int targetZoomLevel = g.VList[nodeToId[edge.Target]].ZoomLevel;
if (sourceZoomLevel <= i && targetZoomLevel <= i)
{
//if the edge is already in top level then copy it
if (sourceZoomLevel < i && targetZoomLevel < i)
{
/*
//jyoti: this seems unnecesary since we copied the edges earlier
//I will remove this later if all the tests pass
int[] p = OldGraphHolder.pathList[edge].ToArray();
for (int pindex = 0; pindex < p.Length - 1; pindex++)
{
int dindex;
for (dindex = 0; dindex < g.DegList[p[pindex]]; dindex++)
if (g.EList[p[pindex], dindex].NodeId == p[pindex + 1]) break;
newG.AddEdge(p[pindex], p[pindex + 1], g.EList[p[pindex], dindex].Selected, g.EList[p[pindex], dindex].Used);
}*/
newG.pathList[edge] = OldGraphHolder.pathList[edge];
continue;
}
newG.pathList[edge] = new List<int>();
List<int> pathvertices;
if (!ssp.ContainsKey(edge))
{
pathvertices = dijkstra.MSAGLAstarShortestPath(g.VList, g.EList, g.DegList,
nodeToId[edge.Source], nodeToId[edge.Target], g.NumOfnodes);
if(pathvertices.Count ==0 ) Console.WriteLine("missing path!");
g.pathList.Add(edge, pathvertices);
ssp.Add(edge, dijkstra.Edgelist);
}
foreach (int vertexId in g.pathList[edge])
newG.pathList[edge].Add(vertexId);
foreach (VertexNeighbor vn in ssp[edge])
newG.AddEdge(vn.A, g.EList[vn.A, vn.Neighbor].NodeId, g.EList[vn.A, vn.Neighbor].Selected, g.EList[vn.A, vn.Neighbor].Used);
//this is necessary, new edges are being created here
//foreach (VertexNeighbor vn in dijkstra.Edgelist)
// newG.AddEdge(vn.A, g.EList[vn.A, vn.Neighbor].NodeId, g.EList[vn.A, vn.Neighbor].Selected, g.EList[vn.A, vn.Neighbor].Used);
}
}
OldGraphHolder = newG;
graphs.Add(newG);
}
stopwatch.Stop();
Console.WriteLine("Graphs for all levels calculated = " + stopwatch.ElapsedMilliseconds);
ComputePathSimplification(g, stopwatch, graphs);
Tiling[] allGraphs = graphs.ToArray();
for (int index = 0; index < allGraphs.Length; index++)
{
for (int nodeindex = allGraphs[index].N; nodeindex < allGraphs[index].NumOfnodes; nodeindex++)
{
if (index < allGraphs.Length - 1)
{
allGraphs[index].VList[nodeindex].TargetX = allGraphs[index + 1].VList[nodeindex].PreciseX;
allGraphs[index].VList[nodeindex].TargetY = allGraphs[index + 1].VList[nodeindex].PreciseY;
}
else
{
allGraphs[index].VList[nodeindex].TargetX = allGraphs[index].VList[nodeindex].PreciseX;
allGraphs[index].VList[nodeindex].TargetY = allGraphs[index].VList[nodeindex].PreciseY;
}
}
}
stopwatch.Stop();
Console.WriteLine("Done Simplification = " + stopwatch.ElapsedMilliseconds);
return allGraphs;
}
private static void ComputePathSimplification(Tiling g, Stopwatch stopwatch, List<Tiling> graphs)
{
Dictionary<int,int> cycle = new Dictionary<int, int>();
Console.WriteLine("Starting Path Simplicfication");
stopwatch.Start();
foreach (Tiling graph in graphs)
{
//find all degree two vertices.
List<int> Deg2Vertices = new List<int>();
for (int j = graph.N; j < graph.NumOfnodes; j++)
{
if (graph.DegList[j] == 2) Deg2Vertices.Add(j);
graph.VList[j].Visited = false;
}
foreach (int w in Deg2Vertices)
{
if (graph.VList[w].Visited) continue;
//find the one end of the path
int currentVertexId = w;
int oldVertexId = -1;
cycle[w] = 1;
while (graph.DegList[currentVertexId] == 2 && currentVertexId >= g.N)
{
int neighbor1 = graph.EList[currentVertexId, 0].NodeId;
;
int neighbor2 = graph.EList[currentVertexId, 1].NodeId;
;
if (oldVertexId != neighbor1)
{
oldVertexId = currentVertexId;
currentVertexId = neighbor1;
}
else if (oldVertexId != neighbor2)
{
oldVertexId = currentVertexId;
currentVertexId = neighbor2;
}
if (cycle.ContainsKey(currentVertexId))
{
cycle.Clear();
break;
}
cycle.Add(currentVertexId, 1);
}
if (cycle.Count == 0) continue;
//find the path from this end
var tempId = oldVertexId;
oldVertexId = currentVertexId;
currentVertexId = tempId;
List<int> path = new List<int>();
path.Add(oldVertexId);
path.Add(currentVertexId);
graph.VList[oldVertexId].Visited = true;
graph.VList[currentVertexId].Visited = true;
//find the path and add it into a list
while (graph.DegList[currentVertexId] == 2 && currentVertexId >= g.N)
{
int neighbor1 = graph.EList[currentVertexId, 0].NodeId;
;
int neighbor2 = graph.EList[currentVertexId, 1].NodeId;
;
if (oldVertexId != neighbor1)
{
oldVertexId = currentVertexId;
currentVertexId = neighbor1;
}
else if (oldVertexId != neighbor2)
{
oldVertexId = currentVertexId;
currentVertexId = neighbor2;
}
path.Add(currentVertexId);
graph.VList[currentVertexId].Visited = true;
}
int[] pathVertices = path.ToArray();
Point[] PointList = new Point[path.Count];
int q = 0;
foreach (int vertex in path)
{
PointList[q++] = new Point(graph.VList[vertex].XLoc, graph.VList[vertex].YLoc);
//if (MsaglUtilities.EucledianDistance(99, 60, graph.VList[vertex].XLoc, graph.VList[vertex].YLoc) < 2)
//Console.WriteLine();
}
LocalModifications.PolygonalChainSimplification(PointList, 0, PointList.Length - 1, 1000);
//Modify graph according to the simplified path
for (int currentPoint = 0; currentPoint < PointList.Length - 1;)
{
int nextPoint = currentPoint + 1;
for (; nextPoint < PointList.Length; nextPoint++)
{
if (PointList[nextPoint].X == -1)
{
//jyoti: RemoveEdge was added to make things fast
graph.RemoveEdge(pathVertices[nextPoint], pathVertices[nextPoint - 1]);
continue;
}
//jyoti: RemoveEdge was added to make things fast
graph.RemoveEdge(pathVertices[nextPoint], pathVertices[nextPoint - 1]);
break;
}
if (nextPoint < PointList.Length)
{
//////graph.AddEdge(pathVertices[nextPoint], pathVertices[currentPoint]);
int left = currentPoint;
int right = nextPoint;
while (graph.noCrossings(pathVertices, pathVertices[left], pathVertices[right]) == false &&
left < right)
{
left++;
right--;
}
if (left < right)
{
//connect each path vertrex in between to this path
for (int index = left + 1; index < right; index++)
{
Vertex intermediateVertex = graph.VList[pathVertices[index]];
Vertex leftVertex = graph.VList[pathVertices[left]];
Vertex rightVertex = graph.VList[pathVertices[right]];
Point p = PointToSegmentDistance.getClosestPoint
(leftVertex, rightVertex, intermediateVertex);
intermediateVertex.PreciseX = p.X;
intermediateVertex.PreciseY = p.Y;
intermediateVertex.LeftX = leftVertex.XLoc;
intermediateVertex.LeftY = leftVertex.YLoc;
intermediateVertex.RightX = rightVertex.XLoc;
intermediateVertex.RightY = rightVertex.YLoc;
}
}
currentPoint = nextPoint;
}
}
}
}
}
public bool PromptUserforGraphSize()
{
Console.WriteLine();
Console.WriteLine("Loading a huge graph? (Y/N)");
string input = Console.ReadLine();
return (input.StartsWith("Y") || input.StartsWith("y"));
}
public bool PromptUserforFlow()
{
Console.WriteLine();
Console.WriteLine("Use Flow to assign nodes on layers? (Y/N)");
string input = Console.ReadLine();
return (input.StartsWith("Y") || input.StartsWith("y"));
}
void SetControlVariables()
{
//control the density at each label
if (_mainGeometryGraph.Edges.Count >= 15000)
_lgLayoutSettings.MaxNumberOfNodesPerTile = 20;
else if (_mainGeometryGraph.Edges.Count >= 10000)
_lgLayoutSettings.MaxNumberOfNodesPerTile = 30;
else
_lgLayoutSettings.MaxNumberOfNodesPerTile = 40;
if (_mainGeometryGraph.Nodes.Count >= 1000 && _mainGeometryGraph.Edges.Count <= 15000)
_lgLayoutSettings.MaxNumberOfNodesPerTile = 40;
//delta = 1 (higher than 1) will give exact (fast approximate) flow
//control speed and approximation
_lgLayoutSettings.delta = (_lgLayoutSettings.MaxNumberOfNodesPerTile / 8) + 1;
}
public void RunForMsaglFiles(string tileDirectory)
{
//ask user
Console.WriteLine("Running in Default Settings - Enable UserPrompt in LgInteractor if needed.");
_lgLayoutSettings.hugeGraph = true; //PromptUserforGraphSize();
_lgLayoutSettings.flow = false;//true;// PromptUserforFlow();
//set control variables
SetControlVariables();
/*
//generate dot from msagl
string mydocpath =
Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
using (StreamWriter outputFile = new StreamWriter("D:/MSIntern/New Folder/mytest/composers.dot"))
{
outputFile.WriteLine("digraph composers {");
String a, b;
foreach (Edge e in _mainGeometryGraph.Edges)
{
a = e.Source.ToString().Split('\"')[1];
b = e.Target.ToString().Split('\"')[1];
outputFile.WriteLine("\"" + a + "\"" + " -> " +
"\"" + b + "\"");
}
outputFile.WriteLine("}");
outputFile.Close();
}
//*/
Dictionary<Node, int> nodeToId;
var g = TryCompetitionMeshApproach(out nodeToId, tileDirectory);
var stopwatch = new Stopwatch();
Tiling[] graphs = calculateGraphsForEachZoomLevel(g, nodeToId, _lgLayoutSettings.hugeGraph);
stopwatch.Start();
DrawAtEachLevelQuotaBounded(graphs, nodeToId);
//DrawAtEachLevelQuotaSatisfied(graphs, nodeToId);
stopwatch.Stop();
Console.WriteLine("Time for DrawAtEachLevelQuotaBounded = " + stopwatch.ElapsedMilliseconds);
Console.WriteLine("Total Number of Rails = " + _lgData.Levels[_lgData.Levels.Count-1].RailDictionary.Values.Count);
//g = graphs[0];
//RenderGraph( g, nodeToId);
}
public void DrawAtEachLevelQuotaBounded(Tiling[] g, Dictionary<Node, int> nodeToId)
{
//until all edges are added create a layer and add vertices one after another
int layer = 0;
//int plottedNodeCount = 0;
List<Node> nodes = new List<Node>();
_lgData.Levels.Clear();
foreach (var node in _mainGeometryGraph.Nodes)
_lgData.GeometryNodesToLgNodeInfos[node].ZoomLevel = maxdepth;
//foreach (var node in _mainGeometryGraph.Nodes)
// _lgData.GeometryNodesToLgNodeInfos[node].ZoomLevel = Math.Log(_lgData.GeometryNodesToLgNodeInfos[node].ZoomLevel, 2);
for (int i = 0; i < g.Length; i++)
{
var level = CreateLevel(layer);
var count = 0;
//set the zoomlevel of the nodes
for (int j = 0; j < g[i].N; j++)
{
if (g[i].DegList[j] > 0)
//if (_lgData.GeometryNodesToLgNodeInfos[idToNode[j]].ZoomLevel<= layer)
{
//count++
Node nd = idToNode[g[i].VList[j].Id];
if (_lgData.GeometryNodesToLgNodeInfos[nd].ZoomLevel == maxdepth)
{
count++;
_lgData.GeometryNodesToLgNodeInfos[nd].ZoomLevel = layer;
_lgLayoutSettings.GeometryNodesToLgNodeInfos[nd].ZoomLevel = layer;
}
else count++;
}
//else //jyoti - added this in case all top level nodes are of degree 0 - bipartite graph
// if (g[i].VList[j].ZoomLevel <= i+1) count++;
}
_lgData.LevelNodeCounts[layer] = count;
//add the edges to the current level for this graph
Dictionary<Node, int> nodeId = new Dictionary<Node, int>();//-remove later - not needed
Set<Rail> railsOfEdge = new Set<Rail>();
foreach (Edge edge in _mainGeometryGraph.Edges)
{
//if (!level._railsOfEdges.ContainsKey(edge))
{
railsOfEdge = MsaglAddRailsOfEdgeQuotaBounded(level, g[i], edge, nodeId);
if (railsOfEdge.Count > 0)
{
level._railsOfEdges[edge] = railsOfEdge;
}
}
}
layer++;
}
_lgLayoutSettings.maximumNumOfLayers = layer;
Console.WriteLine("MAX Num of Level " + layer);
}
public void DrawAtEachLevelQuotaSatisfied(Tiling[] g, Dictionary<Node, int> nodeToId)
{
//until all edges are added create a layer and add vertices one after another
int layer = 0;
int plottedNodeCount = 0;
List<Node> nodes = new List<Node>();
_lgData.Levels.Clear();
var level = CreateLevel(layer);
foreach (var node in _mainGeometryGraph.Nodes)
_lgData.GeometryNodesToLgNodeInfos[node].ZoomLevel = 100;
foreach (LgNodeInfo node in _lgData.SortedLgNodeInfos)
{
_lgData.SortedLgNodeInfos[plottedNodeCount].ZoomLevel = layer;
_lgData.GeometryNodesToLgNodeInfos[node.GeometryNode].ZoomLevel = layer;
nodes.Add(node.GeometryNode);
int graphLayer = layer;
if (layer >= g.Length) graphLayer = g.Length - 1;
double nodeOnlyZoomLevel = Math.Log(g[graphLayer].VList[nodeToId[node.GeometryNode]].ZoomLevel,2);
//Console.WriteLine("vertex level " + node.GeometryNode + " : " + layer + " " + nodeOnlyZoomLevel+" " +g[graphLayer].VList[nodeToId[node.GeometryNode]].ZoomLevel);
while (true)
{
if (nodeOnlyZoomLevel <= layer)
{
//try to insert the node
if (MsaglNodePlottedandQuotaSatisfied(g[graphLayer], level, graphLayer,
plottedNodeCount,nodes, nodeToId))
{
//if the node is successfully inserted, break the loop to proceed with a new node
break;
}
}
layer++;
level = CreateLevel(layer);
_lgData.SortedLgNodeInfos[plottedNodeCount].ZoomLevel = layer;
_lgData.GeometryNodesToLgNodeInfos[node.GeometryNode].ZoomLevel = layer;
_lgLayoutSettings.GeometryNodesToLgNodeInfos[node.GeometryNode].ZoomLevel = layer;
node.ZoomLevel = layer;
if (layer >= g.Length) graphLayer = g.Length - 1;
else graphLayer = layer;
_lgData.LevelNodeCounts[layer] = plottedNodeCount;
}
plottedNodeCount++;
_lgData.LevelNodeCounts[layer] = plottedNodeCount;
}
_lgLayoutSettings.maximumNumOfLayers = layer;
Console.WriteLine("MAX Num of Level " + layer);
}
Dictionary<int, List<int>> tileNodes = new Dictionary<int, List<int>>();
//(7,5460,21845) (5,341,1365)
private int maxdepth = 7;
private int maxtiles = 21845;
private int immediatemaxtiles = 5461;
private int[] tileNodeCount = new int[21845];
private int[] tileEdgeFlow = new int[21845];
int[] tileDepth = new int[21845];
private int id;
Rectangle[] tiles = new Rectangle[21845];
private void buildTiles( double l, double t, double r, double b, int depth, int pid, int kid)
{
if (depth > maxdepth) return;
int index = 4*pid;
tiles[pid] = new Rectangle(l,t,r,b);
tileDepth[pid] = depth;
double centerx = l + (r - l) / 2;
double centery = t + (b - t) / 2;
buildTiles(l, t, centerx, centery , depth + 1, index+1 , 1);
buildTiles(centerx, t, r, centery, depth + 1, index+2, 2);
buildTiles(l, centery, centerx, b, depth + 1,index+3 , 3);
buildTiles(centerx, centery, r, b, depth + 1,index+4, 4);
}
bool computeEdgeFlow(int root, int alreadyVisible, int[,] costTree, Dictionary<IntPair, List<int>> resultTree)
{
if (immediatemaxtiles <= root && root <= maxtiles) return true;
IntPair p = new IntPair(root,alreadyVisible);
int[] result = resultTree[p].ToArray();
if (result.Length == 0) //no feasible solution
return false;
tileEdgeFlow[4 * root + 1] = result[1];
tileEdgeFlow[4 * root + 2] = result[2];
tileEdgeFlow[4 * root + 3] = result[3];
tileEdgeFlow[4 * root + 4] = result[4];
bool a = computeEdgeFlow(4 * root + 1, result[1], costTree, resultTree);
bool b = computeEdgeFlow(4 * root + 2, result[2], costTree, resultTree);
bool c = computeEdgeFlow(4 * root + 3, result[3], costTree, resultTree);
bool d = computeEdgeFlow(4 * root + 4, result[4], costTree, resultTree);
return a & b & c & d;
}
int dynamicProgram(int root, int alreadyVisible, int[,] costTree, Dictionary<IntPair, List<int>> resultTree)
{
//processing for leafnode
if (immediatemaxtiles <= root && root <= maxtiles)
{
if (tileNodeCount[root] < alreadyVisible) return 0;//int.MaxValue;
return (tileNodeCount[root] - alreadyVisible) * (tileNodeCount[root] - alreadyVisible);
}
//process non-leaf nodes
int cost;
int mink1=0, mink2=0, mink3=0, mink4=0;
int mincost = int.MaxValue;
int minrootsum = int.MaxValue;
//I can choose the rootsome anything between current visible and nodequota
for (int rootsum = alreadyVisible; rootsum <= _lgLayoutSettings.MaxNumberOfNodesPerTile; rootsum += _lgLayoutSettings.delta)
{
//distribute the rootsum among the kids approximately
for (int k1 = 0; k1 <= rootsum; k1 += _lgLayoutSettings.delta)
{
for (int k2 = 0; k2 <= rootsum; k2 += _lgLayoutSettings.delta)
{
if (rootsum < (k1 + k2)) break;
for (int k3 = 0; k3 <= rootsum; k3 += _lgLayoutSettings.delta)
{
int k4 = rootsum - (k1 + k2 + k3);
if (k4 < 0) break;
//computation of a distribution ends here
int sum = (k1 + k2 + k3 + k4);
//total visible in this layer
if (sum != rootsum) continue; //distribution is not correct
int newvis = rootsum - alreadyVisible; //newly visible nodes
bool solutionexists = true;
int []c = new int[5];
int[] k = new int[5];
k[1] = k1;
k[2] = k2;
k[3] = k3;
k[4] = k4;
for (int i = 1; i <= 4; i++)
{
c[i] = costTree[4*root + i, k[i]];
if (c[i] == -1)
{
c[i] = dynamicProgram(4*root + i, k[i], costTree, resultTree);
costTree[4*root + i, k[i]] = c[i];
}
if (c[i] == int.MaxValue) solutionexists = false; //no solution
}
if (solutionexists == false) continue;
cost = (int) (1+Math.Log(root+1,4)) * newvis*newvis; //cost for newly visible nodes
if (root == 0) cost = 0;
cost += (c[1] + c[2] + c[3] + c[4]);
if (mincost > cost)
{
mincost = cost;
minrootsum = rootsum;
mink1 = k1; mink2 = k2; mink3 = k3; mink4 = k4;
}
}
}
}
}
costTree[root, alreadyVisible] = mincost;
var p = new IntPair(root, alreadyVisible);
if (!resultTree.ContainsKey(p)) resultTree[p] = new List<int>();
resultTree[p] = new List<int>() { minrootsum, mink1, mink2, mink3, mink4 };
return mincost;
}
void distributeNodes(int root, int[,] costTree, Dictionary<IntPair, List<int>> resultTree, Dictionary<int, Node> idToNode)
{
//processing for a leafnode
if (immediatemaxtiles <= root && root <= maxtiles) return;
distributeNodes(4 * root + 1, costTree, resultTree, idToNode);
distributeNodes(4 * root + 2, costTree, resultTree, idToNode);
distributeNodes(4 * root + 3, costTree, resultTree, idToNode);
distributeNodes(4 * root + 4, costTree, resultTree, idToNode);
List<int> L = new List<int>();
List<double> R = new List<double>();
foreach (var x in tileNodes[4 * root + 1])
{
L.Add(x);
R.Add(_lgData.GeometryNodesToLgNodeInfos[idToNode[x]].ZoomLevel);
}
foreach (var x in tileNodes[4 * root + 2])
{
L.Add(x);
R.Add(_lgData.GeometryNodesToLgNodeInfos[idToNode[x]].ZoomLevel);
}
foreach (var x in tileNodes[4 * root + 3])
{
L.Add(x);
R.Add(_lgData.GeometryNodesToLgNodeInfos[idToNode[x]].ZoomLevel);
}
foreach (var x in tileNodes[4 * root + 4])
{
L.Add(x);
R.Add(_lgData.GeometryNodesToLgNodeInfos[idToNode[x]].ZoomLevel);
}
if (root == 0)
Console.Write("");
int[] LA = L.ToArray();
double[] RA = R.ToArray();
Array.Sort(RA, LA);
tileNodes[root] = new List<int>();
//assign values of ks
int k1 = tileEdgeFlow[4 * root + 1];
int k2 = tileEdgeFlow[4 * root + 2];
int k3 = tileEdgeFlow[4 * root + 3];
int k4 = tileEdgeFlow[4 * root + 4];
//if (k1 + k2 + k3 + k4 == 0) return;
//shift nodes into layers
for (int i = 0; i < LA.Length; i++)
{
if (RA[i] <= Math.Pow(2, tileDepth[root]))
{
tileNodes[root].Add(LA[i]);
if (tileNodes[4*root + 1].Remove(LA[i])) k1--;
if (tileNodes[4*root + 2].Remove(LA[i])) k2--;
if (tileNodes[4*root + 3].Remove(LA[i])) k3--;
if (tileNodes[4*root + 4].Remove(LA[i])) k4--;
continue;
}
}
k1 *= 1+(int)Math.Log(root, 4);
k2 *= 1 + (int)Math.Log(root, 4);
k3 *= 1 + (int)Math.Log(root, 4);
k4 *= 1 + (int)Math.Log(root, 4);
for (int i = 0; i < LA.Length; i++)
{
if (tileNodes[4 * root + 1].Contains(LA[i]) && k1 > 0)
{
tileNodes[root].Add(LA[i]);
tileNodes[4 * root + 1].Remove(LA[i]);
k1--;
Console.Write(".");
}
else if (tileNodes[4 * root + 2].Contains(LA[i]) && k2 > 0)
{
tileNodes[root].Add(LA[i]);
tileNodes[4 * root + 2].Remove(LA[i]);
k2--;
Console.Write(".");
}
else if (tileNodes[4 * root + 3].Contains(LA[i]) && k3 > 0)
{
tileNodes[root].Add(LA[i]);
tileNodes[4 * root + 3].Remove(LA[i]);
k3--;
Console.Write(".");
}
else if (tileNodes[4 * root + 4].Contains(LA[i]) && k4 > 0)
{
tileNodes[root].Add(LA[i]);
tileNodes[4 * root + 4].Remove(LA[i]);
k4--;
Console.Write(".");
}
}
}
void distributeNodesOld(int root, int[,] costTree, Dictionary<IntPair, List<int>> resultTree, Dictionary<int, Node> idToNode)
{
//processing for a leafnode
if (immediatemaxtiles <= root && root <= maxtiles) return;
distributeNodesOld(4 * root + 1, costTree, resultTree, idToNode);
distributeNodesOld(4 * root + 2, costTree, resultTree, idToNode);
distributeNodesOld(4 * root + 3, costTree, resultTree, idToNode);
distributeNodesOld(4 * root + 4, costTree, resultTree, idToNode);
List<int> L = new List<int>();
List<double> R = new List<double>();
foreach (var x in tileNodes[4*root + 1])
{
L.Add(x);
R.Add(_lgData.GeometryNodesToLgNodeInfos[idToNode[x]].ZoomLevel);
}
foreach (var x in tileNodes[4 * root + 2])
{
L.Add(x);
R.Add(_lgData.GeometryNodesToLgNodeInfos[idToNode[x]].ZoomLevel);
}
foreach (var x in tileNodes[4 * root + 3])
{
L.Add(x);
R.Add(_lgData.GeometryNodesToLgNodeInfos[idToNode[x]].ZoomLevel);
}
foreach (var x in tileNodes[4 * root + 4])
{
L.Add(x);
R.Add(_lgData.GeometryNodesToLgNodeInfos[idToNode[x]].ZoomLevel);
}
if (root == 0)
Console.Write("");
int []LA = L.ToArray();
double [] RA = R.ToArray();
Array.Sort(RA,LA);
tileNodes[root] = new List<int>();
//assign values of ks
int k1= tileEdgeFlow[4 * root + 1];
int k2 = tileEdgeFlow[4 * root + 2];
int k3 = tileEdgeFlow[4 * root + 3];
int k4 = tileEdgeFlow[4 * root + 4];
if(k1+k2+k3+k4 == 0) return;
//shift nodes into layers
for (int i = 0; i < LA.Length; i++)
{
if (tileNodes[4*root + 1].Contains(LA[i]) && k1 > 0)
{
tileNodes[root].Add(LA[i]);
tileNodes[4*root + 1].Remove(LA[i]);
k1--;
Console.Write(".");
}
else if (tileNodes[4 * root + 2].Contains(LA[i]) && k2 > 0)
{
tileNodes[root].Add(LA[i]);
tileNodes[4 * root + 2].Remove(LA[i]);
k2--;
Console.Write(".");
}
else if (tileNodes[4 * root + 3].Contains(LA[i]) && k3 > 0)
{
tileNodes[root].Add(LA[i]);
tileNodes[4 * root + 3].Remove(LA[i]);
k3--;
Console.Write(".");
}
else if (tileNodes[4 * root + 4].Contains(LA[i]) && k4 > 0)
{
tileNodes[root].Add(LA[i]);
tileNodes[4 * root + 4].Remove(LA[i]);
k4--;
Console.Write(".");
}
}
}
private Tiling TryCompetitionMeshApproach(out Dictionary<Node, int> nodeToId, string tileDirectory)
{
Boolean loaded = LoadNodeLocationsFromFile(tileDirectory);
_mainGeometryGraph.UpdateBoundingBox();
_lgLayoutSettings.lgGeometryGraph = _mainGeometryGraph;
Console.WriteLine("Nodes = " + _mainGeometryGraph.Nodes.Count + "Edges = " + _mainGeometryGraph.Edges.Count);
//create a set of nodes and empty edges
g = new Tiling(_mainGeometryGraph.Nodes.Count, true);
idToNode = new Dictionary<int, Node>();
nodeToId = new Dictionary<Node, int>();
var stopwatch = new Stopwatch();
stopwatch.Start();
CreateConnectedGraphs();
FillGeometryNodeToLgInfosTables();
LevelCalculator.RankGraph(_lgData, _mainGeometryGraph);
if (!loaded)
LayoutTheWholeGraph();
int maxY;
var maxX = CreateNodePositions(g, nodeToId, idToNode, out maxY, tileDirectory);
if (_lgLayoutSettings.flow)
ComputeZoomLevelviaFlow(nodeToId, maxX, maxY);
stopwatch.Stop();
Console.WriteLine("Conected Graph and MDS Time = " + stopwatch.ElapsedMilliseconds);
//create competitionMesh of G //less than a minute for 1500 vertices and 5000 edges
/*
* CCM:CCMWLP
*
seed Spanning R Avg Spanning R
1 1.67:1.45 1.238:1.225
2 1.61:1.41 1.232:1.212
3 1.80:1.71 1.240:1.228
4 1.78:1.49 1.241:1.225
*/
//MeshCreator.CreateMeshByLayers(g, idToNode, maxX, maxY);
//MeshCreator.CreateCompetitionMesh(g, idToNode, maxX, maxY);
//MeshCreator.FastCompetitionMesh(g, idToNode, maxX, maxY, locationtoNode);
//MeshCreator.CreateCompetitionMeshWithLeftPriority(g, idToNode, maxX, maxY);
stopwatch.Start();
MeshCreator.FastCompetitionMesh(g, idToNode, maxX, maxY, locationtoNode);
stopwatch.Stop();
Console.WriteLine("MeshCreation Time = " + stopwatch.ElapsedMilliseconds);
//Compute Spanning ratio
//ComputeSpanningRatio(g);
stopwatch.Start();
//Create Detour //less than a minute for 1500 vertices and 5000 edges
g.MsaglDetour(idToNode, true); //true : don't create detour
g.CreateNodeTreeEdgeTree();
stopwatch.Stop();
Console.WriteLine("Detour Creation Time = " + stopwatch.ElapsedMilliseconds);
//Compute the EdgeList for each vertex
//var AdjacencyList = BuildAdjacencyListFromEdgeList();
//Dictionary<Node, List<Edge>> AdjacencyList = null; // BuildAdjacencyListFromEdgeList();
//for (int iteration = 1; iteration < 2; iteration++)
//{
stopwatch.Start();
g = ComputeEdgeRoutes(g, nodeToId);
//RouteByLayers();
stopwatch.Stop();
Console.WriteLine("Lev's = " + stopwatch.ElapsedMilliseconds);
/*
//UPDATE ACCORDING TO DIJKSTRA
Console.WriteLine("Computing Edge Routes");
stopwatch.Start();
var g1 = ComputeEdgeRoutes(g, nodeToId, AdjacencyList);
stopwatch.Stop();
Console.WriteLine("Edge Routing Time = " + stopwatch.ElapsedMilliseconds);
g = g1;
*/
Console.WriteLine("Removing Deg 2 junctions");
//Remove Deg 2 Nodes when possible //less than a minute for 1500 vertices and 5000 edges
stopwatch.Start();
g.MsaglRemoveDeg2(idToNode);
stopwatch.Stop();
Console.WriteLine("Deg 2 removal Time = " + stopwatch.ElapsedMilliseconds);
stopwatch.Start();
PlanarGraphUtilities.TransformToGeometricPlanarGraph(g);
stopwatch.Stop();
Console.WriteLine("Planar Graph Building Time = " + stopwatch.ElapsedMilliseconds);
stopwatch.Start();
PlanarGraphUtilities.RemoveLongEdgesFromThinFaces(g);
stopwatch.Stop();
Console.WriteLine("Thin Face Removal Time = " + stopwatch.ElapsedMilliseconds);
//Move the points towards median
//Console.WriteLine("Moving junctions to minimize ink");
stopwatch.Start();
//LocalModifications.MsaglStretchAccordingToZoomLevel(g, idToNode);
LocalModifications.MsaglMoveToMedian(g, idToNode, _lgLayoutSettings);
stopwatch.Stop();
Console.WriteLine("Ink Minimization Time = " + stopwatch.ElapsedMilliseconds);
LocalModifications.MsaglShortcutShortEdges(g, idToNode, _lgLayoutSettings);
g.MsaglRemoveDeg2(idToNode);
LocalModifications.MsaglMoveToMedian(g, idToNode, _lgLayoutSettings);
//}
return g;
}
private void ComputeZoomLevelviaFlow(Dictionary<Node, int> nodeToId, int maxX, int maxY)
{
Console.WriteLine("Assign Nodes to zoomlevels via Flow. Increase delta for faster computation.");
id = 0;
buildTiles(0, 0, maxX, maxY, 0, 0, 0);
Console.WriteLine("Number of tiles =" + id);
id = 0;
int count = 0;
RTree<int> TreeOfNodes = new RTree<int>();
for (int index = 0; index < g.N; index++)
{
TreeOfNodes.Add(new Rectangle(new Point(g.VList[index].XLoc, g.VList[index].YLoc)), index);
}
//nodecount on tiles
for (int i = immediatemaxtiles; i < maxtiles; i++)
{
if (tileDepth[i] < maxdepth) continue;
tileNodes.Add(i, new List<int>());
int[] candidateList = TreeOfNodes.GetAllIntersecting(tiles[i]);
for (int index = 0; index < candidateList.Length; index++)
{
//if (!tileNodes.ContainsKey(i)) tileNodes.Add(i, new List<int>());
tileNodes[i].Add(candidateList[index]);
}
count += candidateList.Length;
tileNodeCount[i] = candidateList.Length;
}
Console.WriteLine("Total Nodes =" + g.N + " Nodes Found " + count);
int quota = _lgLayoutSettings.MaxNumberOfNodesPerTile;
#if SHARPKIT //https://code.google.com/p/sharpkit/issues/detail?id=340
throw new NotImplementedException();
#else
int[,] costTree = new int[maxtiles, quota + 1];
Dictionary<IntPair, List<int>> resultTree = new Dictionary<IntPair, List<int>>();
for (int i = 0; i < maxtiles; i++)
for (int j = 0; j <= quota; j++) costTree[i, j] = -1;
dynamicProgram(0, Math.Min(g.N, quota), costTree, resultTree);
bool flowfound = computeEdgeFlow(0, Math.Min(g.N, quota), costTree, resultTree);
if (flowfound)
Console.WriteLine("A feasible flow found with " + maxdepth + " layers");
distributeNodes(0, costTree, resultTree, idToNode);
g.maxTheoreticalZoomLevel = 0;
for (int i = 0; i < maxtiles; i++)
{
foreach (var x in tileNodes[i])
{
//Console.WriteLine("prev,new" + g.VList[x].ZoomLevel + " " + (int)Math.Pow(2, tileDepth[i]));
g.VList[x].ZoomLevel = (int) Math.Pow(2, tileDepth[i]);
_lgData.GeometryNodesToLgNodeInfos[idToNode[x]].ZoomLevel = g.VList[x].ZoomLevel;
if (g.maxTheoreticalZoomLevel < g.VList[x].ZoomLevel)
g.maxTheoreticalZoomLevel = g.VList[x].ZoomLevel;
}
}
/*
id = 0;
foreach (var e in _mainGeometryGraph.Edges)
{
if (g.VList[nodeToId[e.Source]].ZoomLevel == 1 &&
g.VList[nodeToId[e.Target]].ZoomLevel == 1) id++;
}
Console.WriteLine("Number of edges in level 1 =" + id);
* */
/*
foreach (var node in _lgData.SortedLgNodeInfos)
{
var x = nodeToId[node.GeometryNode];
node.ZoomLevel = g.VList[x].ZoomLevel;
}
*/
LevelCalculator.SetEdgesOnLevels(_lgData, _mainGeometryGraph, _lgLayoutSettings);
_lgData.Levels.Clear();
/*
_mainGeometryGraph.UpdateBoundingBox();
*/
#endif
}
public bool loadBipartiteData(string line)
{
if (line == null) return false;
line = line.Replace(".tiles", "");
try
{
System.IO.StreamReader file = new System.IO.StreamReader(line + ".set");
Dictionary<string, int> nametoset = new Dictionary<string, int>();
//int count = 0;
while ((line = file.ReadLine()) != null)
{
string[] words = line.Split(',');
nametoset[words[0].Trim()] = int.Parse(words[1]);
}
foreach (var n in _mainGeometryGraph.Nodes)
{
var nodename = n.ToString().Trim();
if ( nametoset.ContainsKey(nodename))
_lgData.GeometryNodesToLgNodeInfos[n].PartiteSet = nametoset[nodename];
}
file.Close();
return true;
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine("May not be a Bipartite Graph");
return false;
}
}
public bool LoadNodeLocationsFromFile(string tileDirectory)
{
//OpenFileDialog openFileDialog1 = new OpenFileDialog();
if (tileDirectory == null) return false;
string line = tileDirectory.Replace(".tiles", "");
try
{
System.IO.StreamReader file = new System.IO.StreamReader(line + ".loc");
Dictionary<string, Point> nametopoint = new Dictionary<string, Point>();
while ((line = file.ReadLine()) != null)
{
string[] words = line.Split(',');
//if (count++ > 200) break;
Point p = new Point(Double.Parse(words[1]) * 5, Double.Parse(words[2]) * 5);
nametopoint[words[0]] = p;
}
List<Node> remove = new List<Node>();
foreach (Node w in _mainGeometryGraph.Nodes)
{
String s = w.ToString();//.Split('\"')[1];
if (!nametopoint.ContainsKey(s))
{
remove.Add(w);
}
else
w.Center = nametopoint[s];
}
return true;
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine("exiting LoadNodeLocationsFromFile");
return false;
}
}
public void RouteByLayers()//int maxNodesPerTile, int maxSegmentsPerTile, double increaseNodeQuota)
{
FillLevelsWithNodesOnly(int.MaxValue);
InitRailsOfEdgesEmpty();
//InitNodeLabelWidthToHeightRatios();
AddSkeletonLevels();
for (int i = 0; i < _lgData.Levels.Count; i++)
RemoveOverlapsAndRouteForLayer(int.MaxValue, int.MaxValue, int.MaxValue, i);
_lgData.CreateLevelNodeTrees(NodeDotWidth(1));
//LabelingOfOneRun();
#if DEBUG
TestAllEdgesConsistency();
#endif
}
private int CreateNodePositions(Tiling g, Dictionary<Node, int> nodeToId, Dictionary<int, Node> idToNode, out int maxY, string tileDirectory)
{
//PointSet ps = new PointSet(_mainGeometryGraph.Nodes.Count);
//find maxX and maxY
int maxX = 0;
maxY = 0;
/*
int nodeIndex = 0;
foreach (Node node in _mainGeometryGraph.Nodes)
{
node.Center = new Point((int) ps.Pt[nodeIndex].X, (int) ps.Pt[nodeIndex].Y);
g.VList[nodeIndex] = new Vertex((int) ps.Pt[nodeIndex].X, (int) ps.Pt[nodeIndex].Y) {Id = nodeIndex};
nodeToId.Add(node, nodeIndex);
idToNode.Add(nodeIndex, node);
if (node.Center.X > maxX) maxX = ps.Pt[nodeIndex].X + 5; //(int)node.Center.X+10;
if (node.Center.Y > maxY) maxY = ps.Pt[nodeIndex].Y + 5; //(int)node.Center.Y+10;
nodeIndex++;
}
*/
//check if negative coordinate
double minX = 0;
double minY = 0;
foreach (Node node in _mainGeometryGraph.Nodes)
{
if (node.Center.X < minX) minX = node.Center.X;
if (node.Center.Y < minY) minY = node.Center.Y;
}
//shift to positive coordinate
int nodeIndex = 0;
foreach (Node node in _mainGeometryGraph.Nodes)
{
nodeToId.Add(node, nodeIndex);
idToNode.Add(nodeIndex, node);
node.Center = new Point((int)(node.Center.X - minX + 5), (int)(node.Center.Y - minY + 5));
if (node.Center.X > maxX) maxX = (int)node.Center.X;
if (node.Center.Y > maxY) maxY = (int)node.Center.Y;
nodeIndex++;
}
//bound the graph inside a 1000 by 1000 box
foreach (Node node in _mainGeometryGraph.Nodes)
{
var x = node.Center.X;//(node.Center.X / maxX) * 1000;
var y = node.Center.Y;//(node.Center.Y / maxY) * 1000;
Point p = new Point((int)x, (int)y);
x = (int)x;
y = (int)y;
while (locationtoNode.ContainsKey(p))
{
x++;
y++;
p = new Point((int)x, (int)y);
}
node.Center = p;
if (!locationtoNode.ContainsKey(p)) locationtoNode.Add(p, nodeToId[node]);
g.VList[nodeToId[node]] = new Vertex((int)p.X, (int)p.Y) { Id = nodeToId[node] };
}
/*
//make sure that no two nodes are on the same position
for (int i = 0; i < g.NumOfnodes;i++ )
{
while (g.GetNodeOtherthanThis(i, g.VList[i].XLoc, g.VList[i].YLoc) >= 0)
{
g.VList[i].XLoc++;
g.VList[i].YLoc++;
}
}
*/
maxX = 0;
maxY = 0;
//scale the node positions to create intermediate gaps
for (int i = 0; i < g.NumOfnodes; i++)
{
g.VList[i].XLoc *= 5;
g.VList[i].YLoc *= 5;
idToNode[i].Center = new Point(g.VList[i].XLoc, g.VList[i].YLoc);
if (g.VList[i].XLoc > maxX) maxX = g.VList[i].XLoc;
if (g.VList[i].YLoc > maxY) maxY = g.VList[i].YLoc;
}
locationtoNode = new Dictionary<Point, int>();
for (int i = 0; i < g.NumOfnodes; i++)
{
Point p = new Point(g.VList[i].XLoc, g.VList[i].YLoc);
locationtoNode.Add(p, i);
}
int index = 0;
foreach (Node node in _mainGeometryGraph.Nodes)
{
Point p = new Point(g.VList[index].XLoc, g.VList[index].YLoc);
g.nodeToLoc.Add(node, p);
index++;
}
_lgData.SortedLgNodeInfos = new List<LgNodeInfo>();
//FillGeometryNodeToLgInfosTables();
//CreateConnectedGraphs();
//LevelCalculator.RankGraph(_lgData, _mainGeometryGraph);
LevelCalculator.SetNodeZoomLevelsAndRouteEdgesOnLevels(_lgData, _mainGeometryGraph, _lgLayoutSettings);
bool bipartite = loadBipartiteData(tileDirectory);
if (bipartite)
{
List<LgNodeInfo> listOfinfo = new List<LgNodeInfo>();
foreach (var node in _lgData.SortedLgNodeInfos)
{
if (node.PartiteSet == 1)
{
listOfinfo.Add(node);
}
}
foreach (var node in _lgData.SortedLgNodeInfos)
{
if (node.PartiteSet == 0)
{
listOfinfo.Add(node);
}
}
_lgData.SortedLgNodeInfos.Clear();
foreach (var node in listOfinfo)
_lgData.SortedLgNodeInfos.Add(node);
}
foreach (var node in _lgData.SortedLgNodeInfos)
{
int l = (int)node.ZoomLevel;
g.VList[nodeToId[node.GeometryNode]].ZoomLevel = l;
if (g.maxTheoreticalZoomLevel < l) g.maxTheoreticalZoomLevel = l;
}
_lgData.Levels.Clear();
_mainGeometryGraph.UpdateBoundingBox();
return maxX;
}
private Tiling ComputeEdgeRoutes(Tiling g, Dictionary<Node, int> nodeId)
{
Tiling g1 = new Tiling(g.NumOfnodes, true);
g1.N = g.N;
g1.isPlanar = g.isPlanar;
g1.NumOfnodesBeforeDetour = g.NumOfnodesBeforeDetour;
g1.nodeTree = g.nodeTree;
g1.maxTheoreticalZoomLevel = g.maxTheoreticalZoomLevel;
for (int i = 0; i < g.NumOfnodes; i++)
g1.VList[i] = new Vertex(g.VList[i].XLoc, g.VList[i].YLoc) { Id = g.VList[i].Id, ZoomLevel = g.VList[i].ZoomLevel };
/*
Parallel.ForEach(_mainGeometryGraph.Edges, (edge) =>
{
//List<Edge> processedEdges = new List<Edge>();
DijkstraAlgo dijkstra = new DijkstraAlgo();
dijkstra.MSAGLGreedy(g.VList, g.EList, g.DegList, nodeId[edge.Source],
nodeId[edge.Target],
g.NumOfnodes);
// dijkstra.MSAGLAstarShortestPath(g.VList, g.EList, g.DegList, nodeId[edge.Source],nodeId[edge.Target],g.NumOfnodes);
foreach (VertexNeighbor vn in dijkstra.Edgelist)
g1.AddEdge(vn.A, g.EList[vn.A, vn.Neighbor].NodeId, g.EList[vn.A, vn.Neighbor].Selected,
g.EList[vn.A, vn.Neighbor].Used);
});*/
//List<Edge> processedEdges = new List<Edge>();
DijkstraAlgo dijkstra = new DijkstraAlgo();
//Dictionary<Edge, bool> processedEdges = new Dictionary<Edge, bool>();
int counter = 0;
foreach (var edge in _mainGeometryGraph.Edges)
{
counter++;
//if (processedEdges.ContainsKey(edge)) continue;
//else processedEdges.Add(edge, true);
if (counter % 10000 == 0) Console.WriteLine(".");
dijkstra.MSAGLGreedy(g.VList, g.EList, g.DegList, nodeId[edge.Source],
nodeId[edge.Target],
g.NumOfnodes);
// dijkstra.MSAGLAstarShortestPath(g.VList, g.EList, g.DegList, nodeId[edge.Source],nodeId[edge.Target],g.NumOfnodes);
foreach (VertexNeighbor vn in dijkstra.Edgelist)
g1.AddEdge(vn.A, g.EList[vn.A, vn.Neighbor].NodeId, g.EList[vn.A, vn.Neighbor].Selected, g.EList[vn.A, vn.Neighbor].Used);
}
/*
Dictionary<Edge, bool> processedEdges = new Dictionary<Edge, bool>();
foreach (var node in _mainGeometryGraph.Nodes)
{
dijkstra.MSAGLAstarSSSP(g.VList, g.EList, g.DegList, nodeId[node], nodeId,
_mainGeometryGraph, g.NumOfnodesBeforeDetour,
g.NumOfnodes, g, g1);
}
*/
for (int i = 0; i < g1.NumOfnodes; i++)
if (g1.DegList[i] == 0) g1.VList[i].Invalid = true;
return g1;
}
public Dictionary<SymmetricSegment, Rail> Segs = new Dictionary<SymmetricSegment, Rail>();
//GreedyNodeRailLevelCalculator calc;
public int[] graphLayer = new int[100];
public bool MsaglNodePlottedandQuotaSatisfied(Tiling g, LgLevel level, int currentGraphLayer, int nodeToBePlotted, IEnumerable<Node> nodes, Dictionary<Node, int> nodeId)
{
graphLayer[level.ZoomLevel] = currentGraphLayer;
Set<Rail> railsOfEdge = new Set<Rail>();
foreach (Edge edge in _mainGeometryGraph.Edges)
{
if (!level._railsOfEdges.ContainsKey(edge))
{
railsOfEdge = MsaglAddRailsOfEdge(level, g, edge, nodeId);
if (railsOfEdge.Count > 0)
{
level._railsOfEdges[edge] = railsOfEdge;
}
}
}
SymmetricSegment s;
List<SymmetricSegment> newSegments = new List<SymmetricSegment>();
foreach (var rail in level.RailDictionary.Values)
{
s = new SymmetricSegment(rail.Left, rail.Right);
if (!Segs.ContainsKey(s))
{
Segs.Add(s, rail);
newSegments.Add(s);
}
}
//Console.WriteLine("Total Rails = " + level.RailDictionary.Values.Count);
var allInserted = true;
if (!level.QuotaSatisfied(nodes,
_lgLayoutSettings.MaxNumberOfNodesPerTile,
_lgLayoutSettings.MaxNumberOfRailsPerTile))
allInserted = false;
if (!allInserted && level.ZoomLevel - 1 >= 0)
{
//foreach (Edge edge in level._railsOfEdges.Keys)
level._railsOfEdges.Clear();
level._railDictionary.Clear();
level.RailTree.Clear();
foreach (SymmetricSegment sg in newSegments)
Segs.Remove(sg);
foreach (Edge edge in _lgData.Levels[level.ZoomLevel - 1]._railsOfEdges.Keys)
{
railsOfEdge = _lgData.Levels[level.ZoomLevel - 1]._railsOfEdges[edge];
Set<Rail> rails = new Set<Rail>();
Set<Rail> oldRails = new Set<Rail>();
foreach (var r in railsOfEdge)
{
LineSegment ls = new LineSegment(r.A, r.B);
var tuple = new SymmetricSegment(r.A, r.B);
Rail rail;
if (!level._railDictionary.TryGetValue(tuple, out rail))
{
rail = new Rail(ls, _lgData.GeometryEdgesToLgEdgeInfos[edge],
level.ZoomLevel);
_lgData.GeometryEdgesToLgEdgeInfos[edge].ZoomLevel = level.ZoomLevel;
rail.A = r.targetA;
rail.B = r.targetB;
rail.initialA = r.initialA;
rail.initialB = r.initialB;
rail.targetA = r.targetA;
rail.targetB = r.targetB;
if (!RailToEdges.ContainsKey(rail)) RailToEdges[rail] = new List<Edge>();
if (!RailToEdges[rail].Contains(edge)) RailToEdges[rail].Add(edge);
level._railDictionary[tuple] = rail;
level._railTree.Add(ls.BoundingBox, rail);
rails.Insert(rail);
}
else
{
if (!RailToEdges[rail].Contains(edge)) RailToEdges[rail].Add(edge);
}
}
level._railsOfEdges[edge] = rails;
}
return false;
}
return true;
}
public bool MsaglNodeSuccessfullyPlotted(Tiling g, LgLevel level, int currentGraphLayer, int nodeToBePlotted, IEnumerable<Node> nodes, Dictionary<Node, int> nodeId)
{
graphLayer[level.ZoomLevel] = currentGraphLayer;
Set<Rail> railsOfEdge = new Set<Rail>();
foreach (Edge edge in _mainGeometryGraph.Edges)
{
if (!level._railsOfEdges.ContainsKey(edge))
{
railsOfEdge = MsaglAddRailsOfEdge(level, g, edge, nodeId);
if (railsOfEdge.Count > 0)
{
level._railsOfEdges[edge] = railsOfEdge;
}
}
}
var bbox = GetLargestTile();
GridTraversal grid = new GridTraversal(bbox, level.ZoomLevel);
GreedyNodeRailLevelCalculator calc = new GreedyNodeRailLevelCalculator(_lgData.SortedLgNodeInfos);
calc.MaxAmountRailsPerTile = _lgLayoutSettings.MaxNumberOfRailsPerTile;
SymmetricSegment s;
List<SymmetricSegment> newSegments = new List<SymmetricSegment>();
foreach (var rail in level.RailDictionary.Values)
{
s = new SymmetricSegment(rail.Left, rail.Right);
if (!Segs.ContainsKey(s))
{
Segs.Add(s, rail);
newSegments.Add(s);
}
}
//Console.WriteLine("Total Rails = " + level.RailDictionary.Values.Count);
Boolean allInserted = true;
foreach (var seg in newSegments)
if (calc.IfCanInsertLooseSegmentUpdateTiles(seg, grid) == false)
{
allInserted = false;
//break;
}
if (!allInserted && level.ZoomLevel - 1 >= 0)
{
foreach (Edge edge in level._railsOfEdges.Keys)
level._railsOfEdges[edge].Clear();
foreach (SymmetricSegment sg in newSegments)
Segs.Remove(sg);
foreach (Edge edge in _lgData.Levels[level.ZoomLevel - 1]._railsOfEdges.Keys)
{
railsOfEdge = _lgData.Levels[level.ZoomLevel - 1]._railsOfEdges[edge];
level._railsOfEdges[edge] = railsOfEdge;
}
return false;
}
return true;//level.QuotaSatisfied(nodes, this._lgLayoutSettings.MaxNumberOfNodesPerTile, this._lgLayoutSettings.MaxNumberOfRailsPerTile);
}
public Dictionary<Rail, List<Edge>> RailToEdges = new Dictionary<Rail, List<Edge>>();
private Set<Rail> MsaglAddRailsOfEdge(LgLevel level, Tiling g, Edge edge, Dictionary<Node, int> nodeId)
{
if (_lgData.GeometryNodesToLgNodeInfos[edge.Source].ZoomLevel > level.ZoomLevel ||
_lgData.GeometryNodesToLgNodeInfos[edge.Target].ZoomLevel > level.ZoomLevel)
return new Set<Rail>();
if (!g.pathList.ContainsKey(edge)) return new Set<Rail>();
_lgData.GeometryEdgesToLgEdgeInfos[edge] = new LgEdgeInfo(edge)
{
Rank = Math.Min(_lgData.GeometryNodesToLgNodeInfos[edge.Source].ZoomLevel,
_lgData.GeometryNodesToLgNodeInfos[edge.Target].ZoomLevel),
ZoomLevel =
Math.Max(_lgData.GeometryNodesToLgNodeInfos[edge.Source].ZoomLevel,
_lgData.GeometryNodesToLgNodeInfos[edge.Target].ZoomLevel)
};
var railsOfEdge = new Set<Rail>();
int[] pathVertices = g.pathList[edge].ToArray();
for (int index = 0; index < pathVertices.Length - 1; index++)
{
var a = new Point(g.VList[pathVertices[index]].PreciseX, g.VList[pathVertices[index]].PreciseY);
var b = new Point(g.VList[pathVertices[index + 1]].PreciseX, g.VList[pathVertices[index + 1]].PreciseY);
var initial_a = new Point(g.VList[pathVertices[index]].XLoc, g.VList[pathVertices[index]].YLoc);
var initial_b = new Point(g.VList[pathVertices[index + 1]].XLoc, g.VList[pathVertices[index + 1]].YLoc);
var target_a = new Point(g.VList[pathVertices[index]].TargetX, g.VList[pathVertices[index]].TargetY);
var target_b = new Point(g.VList[pathVertices[index + 1]].TargetX, g.VList[pathVertices[index + 1]].TargetY);
var left = new Point(0, 0);
var right = new Point(0, 0);
if (g.VList[pathVertices[index]].LeftX != 0 && g.VList[pathVertices[index]].RightX != 0)
{
left = new Point(g.VList[pathVertices[index]].LeftX, g.VList[pathVertices[index]].LeftY);
right = new Point(g.VList[pathVertices[index]].RightX, g.VList[pathVertices[index]].RightY);
}
else if (g.VList[pathVertices[index + 1]].LeftX != 0 && g.VList[pathVertices[index + 1]].RightX != 0)
{
left = new Point(g.VList[pathVertices[index + 1]].LeftX, g.VList[pathVertices[index + 1]].LeftY);
right = new Point(g.VList[pathVertices[index + 1]].RightX, g.VList[pathVertices[index + 1]].RightY);
}
var tuple = new SymmetricSegment(a, b);
Rail rail;
if (!level._railDictionary.TryGetValue(tuple, out rail))
{
var ls = new LineSegment(a, b);
//CubicBezierSegment cb = new CubicBezierSegment(a, a, a, a);
rail = new Rail(ls, _lgData.GeometryEdgesToLgEdgeInfos[edge], level.ZoomLevel);
//(int)_lgData.GeometryEdgesToLgEdgeInfos[edge].ZoomLevel);
if (!RailToEdges.ContainsKey(rail)) RailToEdges[rail] = new List<Edge>();
if (!RailToEdges[rail].Contains(edge)) RailToEdges[rail].Add(edge);
rail.A = a;
rail.B = b;
rail.initialA = initial_a;
rail.initialB = initial_b;
rail.targetA = target_a;
rail.targetB = target_b;
if (left.X != 0 && left.Y != 0)
{ rail.Left = left; rail.Right = right; }
else { rail.Left = a; rail.Right = b; }
level._railDictionary[tuple] = rail;
level._railTree.Add(ls.BoundingBox, rail);
}
else
{
rail.ZoomLevel = Math.Max(rail.ZoomLevel, level.ZoomLevel);
//rail.ZoomLevel = level.ZoomLevel;
if (!RailToEdges[rail].Contains(edge)) RailToEdges[rail].Add(edge);
}
railsOfEdge.Insert(rail);
}
return railsOfEdge;
}
private Set<Rail> MsaglAddRailsOfEdgeQuotaBounded(LgLevel level, Tiling g, Edge edge, Dictionary<Node, int> nodeId)
{
if (_lgData.GeometryNodesToLgNodeInfos[edge.Source].ZoomLevel > level.ZoomLevel ||
_lgData.GeometryNodesToLgNodeInfos[edge.Target].ZoomLevel > level.ZoomLevel)
return new Set<Rail>();
if (!g.pathList.ContainsKey(edge)) return new Set<Rail>();
_lgData.GeometryEdgesToLgEdgeInfos[edge] = new LgEdgeInfo(edge)
{
Rank = Math.Max(_lgData.GeometryNodesToLgNodeInfos[edge.Source].ZoomLevel,
_lgData.GeometryNodesToLgNodeInfos[edge.Target].ZoomLevel),
ZoomLevel =
Math.Max(_lgData.GeometryNodesToLgNodeInfos[edge.Source].ZoomLevel,
_lgData.GeometryNodesToLgNodeInfos[edge.Target].ZoomLevel)
};
var railsOfEdge = new Set<Rail>();
int[] pathVertices = g.pathList[edge].ToArray();
for (int index = 0; index < pathVertices.Length - 1; index++)
{
var a = new Point(g.VList[pathVertices[index]].PreciseX, g.VList[pathVertices[index]].PreciseY);
var b = new Point(g.VList[pathVertices[index + 1]].PreciseX, g.VList[pathVertices[index + 1]].PreciseY);
var initial_a = new Point(g.VList[pathVertices[index]].XLoc, g.VList[pathVertices[index]].YLoc);
var initial_b = new Point(g.VList[pathVertices[index + 1]].XLoc, g.VList[pathVertices[index + 1]].YLoc);
var target_a = new Point(g.VList[pathVertices[index]].TargetX, g.VList[pathVertices[index]].TargetY);
var target_b = new Point(g.VList[pathVertices[index + 1]].TargetX, g.VList[pathVertices[index + 1]].TargetY);
var left = new Point(0, 0);
var right = new Point(0, 0);
if (g.VList[pathVertices[index]].LeftX != 0 && g.VList[pathVertices[index]].RightX != 0)
{
left = new Point(g.VList[pathVertices[index]].LeftX, g.VList[pathVertices[index]].LeftY);
right = new Point(g.VList[pathVertices[index]].RightX, g.VList[pathVertices[index]].RightY);
}
else if (g.VList[pathVertices[index + 1]].LeftX != 0 && g.VList[pathVertices[index + 1]].RightX != 0)
{
left = new Point(g.VList[pathVertices[index + 1]].LeftX, g.VList[pathVertices[index + 1]].LeftY);
right = new Point(g.VList[pathVertices[index + 1]].RightX, g.VList[pathVertices[index + 1]].RightY);
}
var tuple = new SymmetricSegment(a, b);
Rail rail;
if (!level._railDictionary.TryGetValue(tuple, out rail))
{
var ls = new LineSegment(a, b);
//CubicBezierSegment cb = new CubicBezierSegment(a, a, a, a);
rail = new Rail(ls, _lgData.GeometryEdgesToLgEdgeInfos[edge], level.ZoomLevel);
//(int)_lgData.GeometryEdgesToLgEdgeInfos[edge].ZoomLevel);
if (!RailToEdges.ContainsKey(rail)) RailToEdges[rail] = new List<Edge>();
if (!RailToEdges[rail].Contains(edge)) RailToEdges[rail].Add(edge);
rail.A = a;
rail.B = b;
rail.initialA = initial_a;
rail.initialB = initial_b;
rail.targetA = target_a;
rail.targetB = target_b;
if (left.X != 0 && left.Y != 0)
{ rail.Left = left; rail.Right = right; }
else { rail.Left = a; rail.Right = b; }
level._railDictionary[tuple] = rail;
level._railTree.Add(ls.BoundingBox, rail);
//rail.TopRankedEdgeInfoOfTheRail = _lgData.GeometryEdgesToLgEdgeInfos[edge];
rail.UpdateTopEdgeInfo(_lgData.GeometryEdgesToLgEdgeInfos[edge]);
}
else
{
rail.ZoomLevel = Math.Max(rail.ZoomLevel, level.ZoomLevel);
//rail.ZoomLevel = level.ZoomLevel;
if (!RailToEdges[rail].Contains(edge)) RailToEdges[rail].Add(edge);
}
railsOfEdge.Insert(rail);
}
return railsOfEdge;
}
private void FillGeometryNodesToLgNodeInfos()
{
int rankIndex = int.MaxValue;
_lgData.SortedLgNodeInfos = new List<LgNodeInfo>();
foreach (Node node in _mainGeometryGraph.Nodes)
{
var nodeInfo = new LgNodeInfo(node)
{
Rank = rankIndex--,
ZoomLevel = 1000,
LabelVisibleFromScale = 1, //GetDoubleAttributeOrDefault(GeometryToken.LabelVisibleFromScale, 1.0),
LabelWidthToHeightRatio = 1, // = GetDoubleAttributeOrDefault(GeometryToken.LabelWidthToHeightRatio, 1.0),
LabelOffset = new Point(1, 1) // = TryGetPointAttribute(GeometryToken.LabelOffset)
};
_lgData.SortedLgNodeInfos.Add(nodeInfo);
_lgData.GeometryNodesToLgNodeInfos[node] = nodeInfo;
Console.WriteLine("" + node);
}
}
/// <summary>
/// does the initialization
/// </summary>
public void Run(string tileDirectory)
{
//Dictionary<Node, int> nodeToIndex;
Console.WriteLine("dot graph");
RunForMsaglFiles(tileDirectory);
//RunForDotFiles();
//ProcessEdges(points, nodeToIndex, level, _grid);
_lgData.CreateLevelNodeTrees(NodeDotWidth(1));
_railGraph = new RailGraph();
#if TEST_GRAPHMAPS
#if DEBUG && TEST_MSAGL
_mainGeometryGraph.SetDebugIds();
#endif
CreateConnectedGraphs();
FillGeometryNodeToLgInfosTables();
LevelCalculator.RankGraph(_lgData, _mainGeometryGraph);
LayoutTheWholeGraph();
#if !SHARPKIT
var timer = new Timer();
timer.Start();
#endif
LevelCalculator.SetNodeZoomLevelsAndRouteEdgesOnLevels(_lgData, _mainGeometryGraph, _lgLayoutSettings);
Debug.Assert(ClusterRanksAreNotLessThanChildrens());
_railGraph = new RailGraph();
LayoutAndRouteByLayers(_lgLayoutSettings.MaxNumberOfNodesPerTile, _lgLayoutSettings.MaxNumberOfRailsPerTile,
_lgLayoutSettings.IncreaseNodeQuota);
#if !SHARPKIT
timer.Stop();
Console.WriteLine("levels calculated for {0}", timer.Duration);
if (_lgLayoutSettings.ExitAfterInit)
Environment.Exit(0);
#endif
#endif
}
private bool NodeSuccessfullyPlotted(PointSet points, Dictionary<Node, int> nodeToIndex, LgLevel level, Tiling grid, int nodeToBePlotted, IEnumerable<Node> nodes)
{
DijkstraAlgo dijkstra = new DijkstraAlgo();
foreach (Edge edge in _mainGeometryGraph.Edges)
{
var railsOfEdge = AddRailsOfEdge(points, nodeToIndex, level, grid, edge, dijkstra);
level._railsOfEdges[edge] = railsOfEdge;
}
return level.QuotaSatisfied(nodes, _lgLayoutSettings.MaxNumberOfNodesPerTile, _lgLayoutSettings.MaxNumberOfRailsPerTile);
}
private Set<Rail> AddRailsOfEdge(PointSet points, Dictionary<Node, int> nodeToIndex, LgLevel level, Tiling grid, Edge edge,
DijkstraAlgo dijkstra)
{
if (_lgData.GeometryNodesToLgNodeInfos[edge.Source].ZoomLevel > level.ZoomLevel ||
_lgData.GeometryNodesToLgNodeInfos[edge.Target].ZoomLevel > level.ZoomLevel)
return new Set<Rail>();
_lgData.GeometryEdgesToLgEdgeInfos[edge] = new LgEdgeInfo(edge)
{
Rank = Math.Min(_lgData.GeometryNodesToLgNodeInfos[edge.Source].ZoomLevel,
_lgData.GeometryNodesToLgNodeInfos[edge.Target].ZoomLevel),
ZoomLevel =
Math.Max(_lgData.GeometryNodesToLgNodeInfos[edge.Source].ZoomLevel,
_lgData.GeometryNodesToLgNodeInfos[edge.Target].ZoomLevel)
};
dijkstra.SelectShortestPath(grid.VList, grid.EList, grid.DegList, points.Pt[nodeToIndex[edge.Source]].GridPoint,
points.Pt[nodeToIndex[edge.Target]].GridPoint, grid.NumOfnodes);
var railsOfEdge = new Set<Rail>();
foreach (VertexNeighbor e in dijkstra.Edgelist)
{
var a = new Point(grid.VList[e.A].XLoc, grid.VList[e.A].YLoc);
var b = new Point(grid.VList[grid.EList[e.A, e.Neighbor].NodeId].XLoc,
grid.VList[grid.EList[e.A, e.Neighbor].NodeId].YLoc);
//_grid.EList[e.A, e.Neighbor].Used++;
var tuple = new SymmetricSegment(a, b);
Rail rail;
if (!level._railDictionary.TryGetValue(tuple, out rail))
{
var ls = new LineSegment(a, b);
rail = new Rail(ls, _lgData.GeometryEdgesToLgEdgeInfos[edge],
(int)_lgData.GeometryEdgesToLgEdgeInfos[edge].ZoomLevel);
level._railDictionary[tuple] = rail;
level._railTree.Add(ls.BoundingBox, rail);
}
else rail.ZoomLevel = Math.Max(rail.ZoomLevel, level.ZoomLevel);
railsOfEdge.Insert(rail);
}
return railsOfEdge;
}
private LgLevel CreateLevel(int layer)
{
//FillGeometryNodeToLgInfosTables();
LgLevel level = new LgLevel(layer, _mainGeometryGraph);
int levelNodeCount = _mainGeometryGraph.Nodes.Count;
if (_lgData.LevelNodeCounts == null)
{
_lgData.LevelNodeCounts = new List<int>();
}
_lgData.LevelNodeCounts.Add(levelNodeCount);
_lgData.Levels.Add(level);
return level;
}
bool ClusterRanksAreNotLessThanChildrens()
{
return
_mainGeometryGraph.RootCluster.AllClustersDepthFirstExcludingSelf().
All(cluster => cluster.Clusters.Concat(cluster.Nodes).Any(n =>
_lgData.GeometryNodesToLgNodeInfos[cluster].Rank >= _lgData.GeometryNodesToLgNodeInfos[n].Rank));
}
// void TestVisibleTogether() {
// for (int i = 0; i < geometryGraph.Nodes.Count - 1; i++) {
// var a = GeometryNodesToLgNodes[geometryGraph.Nodes[i]];
// for (int j = i + 1; j < geometryGraph.Nodes.Count; j++) {
// var b = GeometryNodesToLgNodes[geometryGraph.Nodes[j]];
// string color = VisibleTogether(a, b) ? "green" : "red";
// var l = new List<DebugCurve>();
// foreach (var n in geometryGraph.Nodes) {
// if(n!=a.GeometryNode && n!=b.GeometryNode)
// l.Add(new DebugCurve(100, 1, "black", n.BoundaryCurve));
// else
// l.Add(new DebugCurve(3, color, n.BoundaryCurve));
//
// }
//
// l.Add(new DebugCurve(5,color, a.DominatedRect.Perimeter()));
// l.Add(new DebugCurve(5, color, b.DominatedRect.Perimeter()));
// LayoutAlgorithmSettings.ShowDebugCurves(l.ToArray());
// }
// }
// }
void FillGeometryNodeToLgInfosTables()
{
foreach (
Node node in
_mainGeometryGraph.Nodes.Concat(_mainGeometryGraph.RootCluster.AllClustersWideFirstExcludingSelf()))
{
_lgData.GeometryNodesToLgNodeInfos[node] = new LgNodeInfo(node);
}
foreach (Edge edge in _mainGeometryGraph.Edges)
{
_lgData.GeometryEdgesToLgEdgeInfos[edge] = new LgEdgeInfo(edge);
}
}
void LayoutTheWholeGraph()
{
if (_lgLayoutSettings.NeedToLayout)
{
if (_runInParallel)
Parallel.ForEach(_lgData.ConnectedGeometryGraphs, new ParallelOptions(), LayoutAndPadOneComponent);
else
foreach (GeometryGraph connectedGraph in _lgData.ConnectedGeometryGraphs)
LayoutAndPadOneComponent(connectedGraph);
Rectangle rect = MdsGraphLayout.PackGraphs(_lgData.ConnectedGeometryGraphs, _lgLayoutSettings);
_mainGeometryGraph.BoundingBox = rect;
}
else
foreach (GeometryGraph graph in _lgData.ConnectedGeometryGraphs)
graph.UpdateBoundingBox();
}
void LayoutAndPadOneComponent(GeometryGraph connectedGraph)
{
LayoutOneComponent(connectedGraph);
connectedGraph.BoundingBox.Pad(_lgLayoutSettings.NodeSeparation / 2);
}
void CreateConnectedGraphs()
{
Dictionary<Node, int> nodeToIndex;
List<Node> listOfNodes = CreateNodeListForBasicGraph(out nodeToIndex);
var basicGraph = new BasicGraph<SimpleIntEdge>(GetSimpleIntEdges(nodeToIndex), listOfNodes.Count);
IEnumerable<IEnumerable<int>> comps = ConnectedComponentCalculator<SimpleIntEdge>.GetComponents(basicGraph);
foreach (var comp in comps)
_lgData.AddConnectedGeomGraph(GetConnectedSubgraph(comp, listOfNodes));
}
GeometryGraph GetConnectedSubgraph(IEnumerable<int> comp, List<Node> nodeList)
{
var edges = new List<Edge>();
var nodes = new List<Node>();
var geomGraph = new GeometryGraph();
foreach (int i in comp)
{
Node node = nodeList[i];
var cluster = node as Cluster;
if (cluster != null)
{
if (cluster.ClusterParents.First() == _mainGeometryGraph.RootCluster)
{
//MainGeometryGraph.RootCluster.RemoveCluster(cluster);
geomGraph.RootCluster.AddCluster(cluster);
}
}
else
{
nodes.Add(node);
}
foreach (Edge edge in node.OutEdges.Concat(node.SelfEdges))
{
Debug.Assert(!edges.Contains(edge));
edges.Add(edge);
}
}
geomGraph.Edges = new SimpleEdgeCollection(edges);
geomGraph.Nodes = new SimpleNodeCollection(nodes);
return geomGraph;
}
List<Node> CreateNodeListForBasicGraph(out Dictionary<Node, int> nodeToIndex)
{
var list = new List<Node>();
nodeToIndex = new Dictionary<Node, int>();
foreach (Node node in _mainGeometryGraph.Nodes)
{
nodeToIndex[node] = list.Count;
list.Add(node);
}
foreach (Cluster node in _mainGeometryGraph.RootCluster.AllClustersDepthFirstExcludingSelf())
{
nodeToIndex[node] = list.Count;
list.Add(node);
}
return list;
}
List<SimpleIntEdge> GetSimpleIntEdges(Dictionary<Node, int> nodeToIndex)
{
var list =
_mainGeometryGraph.Edges.Select(
edge => new SimpleIntEdge { Source = nodeToIndex[edge.Source], Target = nodeToIndex[edge.Target] })
.ToList();
foreach (Cluster cluster in _mainGeometryGraph.RootCluster.AllClustersDepthFirstExcludingSelf())
{
list.AddRange(
cluster.Clusters.Select(
child => new SimpleIntEdge { Source = nodeToIndex[cluster], Target = nodeToIndex[child] }));
list.AddRange(
cluster.Nodes.Select(
child => new SimpleIntEdge { Source = nodeToIndex[cluster], Target = nodeToIndex[child] }));
}
return list;
}
void LayoutOneComponent(GeometryGraph component)
{
PrepareGraphForLayout(component);
if (component.RootCluster.Clusters.Any())
{
// todo: do we really use layered layout here?
var layoutSettings = new SugiyamaLayoutSettings
{
FallbackLayoutSettings =
new FastIncrementalLayoutSettings
{
AvoidOverlaps = true
},
NodeSeparation = _lgLayoutSettings.NodeSeparation,
LayerSeparation = _lgLayoutSettings.NodeSeparation,
EdgeRoutingSettings = _lgLayoutSettings.EdgeRoutingSettings,
LayeringOnly = true
};
var initialBc = new InitialLayoutByCluster(component, a => layoutSettings);
initialBc.Run();
}
else
{
// todo: currently implemented as if there is only one component
LayoutHelpers.CalculateLayout(component, GetMdsLayoutSettings(), _cancelToken);
RemoveOverlapsForLgLayout(component);
}
#if SHARPKIT //https://code.google.com/p/sharpkit/issues/detail?id=369 there are no structs in js
Rectangle box = component.BoundingBox.Clone();
#else
Rectangle box = component.BoundingBox;
#endif
box.Pad(_lgLayoutSettings.NodeSeparation / 2);
component.BoundingBox = box;
}
void RemoveOverlapsForLgLayout(GeometryGraph component)
{
Node[] componentNodes = component.Nodes.ToArray();
Debug.Assert(RankingIsDefined(componentNodes));
SortComponentNodesByRanking(componentNodes);
List<int> approxLayerCounts = GetApproximateLayerCounts(componentNodes);
Size[] sizes = GetApproxSizesForOverlapRemoval(approxLayerCounts, _lgLayoutSettings.NodeSeparation * 3,
componentNodes);
GTreeOverlapRemoval.RemoveOverlapsForLayers(componentNodes, sizes);
}
Size[] GetApproxSizesForOverlapRemoval(List<int> approxLayerCounts, double w, Node[] componentNodes)
{
var ret = new Size[componentNodes.Length];
int layer = 0;
for (int i = 0; i < componentNodes.Length; i++)
{
ret[i] = new Size(w, w);
if (i == approxLayerCounts[layer])
{
w /= 2;
layer++;
}
}
return ret;
}
/// <summary>
/// trying to approximately evaluate what the number of nodes will be in each layer
/// </summary>
/// <param name="componentNodes"></param>
/// <returns></returns>
List<int> GetApproximateLayerCounts(Node[] componentNodes)
{
int total = componentNodes.Length;
int nodesPerTile = _lgLayoutSettings.MaxNumberOfNodesPerTile;
int numberOfTiles = 1;
var ret = new List<int>();
while (true)
{
int nodesOnLayer = Math.Min(nodesPerTile * numberOfTiles, total);
ret.Add(nodesOnLayer);
if (nodesOnLayer == total)
break;
numberOfTiles *= 3; // thinking about those empty tiles!
}
return ret;
}
void SortComponentNodesByRanking(Node[] componentNodes)
{
var comparer = new RankComparer(_lgData.GeometryNodesToLgNodeInfos);
Array.Sort(componentNodes, comparer);
}
bool RankingIsDefined(Node[] componentNodes)
{
if (componentNodes.Length == 0) return true;
return _lgData.GeometryNodesToLgNodeInfos[componentNodes[0]].Rank > 0;
}
static void PrepareGraphForLayout(GeometryGraph connectedGraph)
{
foreach (Cluster cluster in connectedGraph.RootCluster.AllClustersDepthFirst())
{
if (cluster.RectangularBoundary == null)
cluster.RectangularBoundary = new RectangularClusterBoundary();
}
foreach (Edge edge in connectedGraph.Edges)
{
if (edge.SourcePort == null)
{
Edge e = edge;
edge.SourcePort = new RelativeFloatingPort(() => e.Source.BoundaryCurve,
() => e.Source.Center);
}
if (edge.TargetPort == null)
{
Edge e = edge;
edge.TargetPort = new RelativeFloatingPort(() => e.Target.BoundaryCurve,
() => e.Target.Center);
}
}
}
MdsLayoutSettings GetMdsLayoutSettings()
{
var settings = new MdsLayoutSettings
{
EdgeRoutingSettings = { KeepOriginalSpline = true, EdgeRoutingMode = EdgeRoutingMode.None },
RemoveOverlaps = false
};
return settings;
}
bool IsEdgeVisibleAtCurrentLevel(Edge e)
{
LgEdgeInfo ei;
if (!GeometryEdgesToLgEdgeInfos.TryGetValue(e, out ei)) return false;
double curLevel = _lgData.Levels[_lgData.GetLevelIndexByScale(CurrentZoomLevel)].ZoomLevel;
return ei.ZoomLevel <= curLevel;
}
void AddHighlightedEdgesAndNodesToRailGraph()
{
_railGraph.Edges.InsertRange(_lgData.SelectedEdges);
_railGraph.Nodes.InsertRange(_lgData.SelectedNodeInfos.Select(n => n.GeometryNode));
}
public void AddLabelsOfHighlightedNodes(double scale)
{
SelectedNodeLabels.Clear();
var selNodesSet = new Set<LgNodeInfo>();
foreach (var edge in _lgData.SelectedEdges)
{
var ni = _lgData.GeometryNodesToLgNodeInfos[edge.Source];
if (_visibleRectangle.Intersects(GetNodeDotRect(ni, scale)))
{
selNodesSet.Insert(ni);
}
ni = _lgData.GeometryNodesToLgNodeInfos[edge.Target];
if (_visibleRectangle.Intersects(GetNodeDotRect(ni, scale)))
{
selNodesSet.Insert(ni);
}
}
selNodesSet.InsertRange(_lgData.SelectedNodeInfos.Where(ni => _visibleRectangle.Intersects(GetNodeDotRect(ni, scale))));
if (!selNodesSet.Any())
{
return;
}
foreach (var n in selNodesSet)
{
}
var selNodes = selNodesSet.ToList();
selNodes = selNodes.OrderByDescending(ni => ni.Rank).ToList();
InsertCandidateLabelsGreedily(selNodes, scale);
}
public bool forthefirsttime = true;
void AddVisibleRailsAndNodes()
{
_railGraph.Rails.Clear();
var level = _lgData.GetCurrentLevelByScale(CurrentZoomLevel);
Console.WriteLine("current zoomlevel = " + level.ZoomLevel);
_railGraph.Rails.InsertRange(level.GetRailsIntersectingRect(_visibleRectangle));
//jyoti: only show the top level nodes for the first time
if (forthefirsttime)
_railGraph.Nodes.InsertRange(level.GetNodesIntersectingRectLabelzero(_visibleRectangle, 1));
else
_railGraph.Nodes.InsertRange(level.GetNodesIntersectingRectLabelzero(_visibleRectangle, Math.Pow(2, level.ZoomLevel)));
_railGraph.Edges.Clear();
_railGraph.Edges.InsertRange(
_railGraph.Rails.Select(r => r.TopRankedEdgeInfoOfTheRail.Edge).Where(IsEdgeVisibleAtCurrentLevel));
AddHighlightedEdgesAndNodesToRailGraph();
}
internal static GeometryGraph CreateClusteredSubgraphFromFlatGraph(GeometryGraph subgraph,
GeometryGraph mainGeometryGraph)
{
if (mainGeometryGraph.RootCluster.Clusters.Any() == false) return subgraph;
var ret = new GeometryGraph();
Dictionary<Node, Node> originalNodesToNewNodes = MapSubgraphNodesToNewNodesForRouting(subgraph);
ReplicateClusterStructure(subgraph, originalNodesToNewNodes);
AddNewNodeAndClustersToTheNewGraph(originalNodesToNewNodes, ret);
foreach (Edge edge in subgraph.Edges)
{
Node ns = originalNodesToNewNodes[edge.Source];
Node nt = originalNodesToNewNodes[edge.Target];
ret.Edges.Add(new Edge(ns, nt)
{
EdgeGeometry = edge.EdgeGeometry,
SourcePort = null,
TargetPort = null
});
}
foreach (var kv in originalNodesToNewNodes)
{
Node newNode = kv.Value;
var cluster = newNode as Cluster;
if (cluster != null)
{
Node oldNode = kv.Key;
if (oldNode.BoundaryCurve != newNode.BoundaryCurve)
{
oldNode.BoundaryCurve = newNode.BoundaryCurve;
oldNode.RaiseLayoutChangeEvent(null);
}
}
}
return ret;
//LayoutAlgorithmSettings.ShowGraph(ret);
}
static void AddNewNodeAndClustersToTheNewGraph(Dictionary<Node, Node> onodesToNewNodes, GeometryGraph ret)
{
foreach (Node newNode in onodesToNewNodes.Values)
{
var cl = newNode as Cluster;
if (cl == null)
ret.Nodes.Add(newNode);
else
{
if (!cl.ClusterParents.Any())
ret.RootCluster.AddCluster(cl);
}
}
}
static void ReplicateClusterStructure(GeometryGraph geometryGraph, Dictionary<Node, Node> onodesToNewNodes)
{
foreach (Node onode in geometryGraph.Nodes)
foreach (Cluster oclparent in onode.ClusterParents)
{
Node newParent;
if (onodesToNewNodes.TryGetValue(oclparent, out newParent))
((Cluster)newParent).AddNode(onodesToNewNodes[onode]);
}
}
/*
bool IsRootCluster(Cluster oclparent) {
return !oclparent.ClusterParents.Any();
}
*/
static Dictionary<Node, Node> MapSubgraphNodesToNewNodesForRouting(GeometryGraph geometryGraph)
{
var onodesToNewNodes = new Dictionary<Node, Node>();
foreach (Node oNode in geometryGraph.Nodes)
{
var cluster = oNode as Cluster;
onodesToNewNodes[oNode] = cluster != null
? new Cluster
{
CollapsedBoundary = cluster.CollapsedBoundary,
BoundaryCurve = oNode.BoundaryCurve,
#if DEBUG && TEST_MSAGL
DebugId = oNode.DebugId
#endif
}
: new Node(oNode.BoundaryCurve);
}
return onodesToNewNodes;
}
/// <summary>
/// </summary>
public void RunOnViewChange()
{
_visibleRectangle = _lgLayoutSettings.ClientViewportMappedToGraph();
//Rectangle.Intersect(lgLayoutSettings.ClientViewportMappedToGraph, mainGeometryGraph.BoundingBox);
// if (MainGeometryGraph.Edges.Count == 33) {
// LayoutAlgorithmSettings.ShowDebugCurves(
// new DebugCurve("red", MainGeometryGraph.BoundingBox.Perimeter()),
// new DebugCurve("blue", visibleRectangle.Perimeter()));
// LayoutAlgorithmSettings.ShowGraph(clusterOGraph);
// }
if (_visibleRectangle.IsEmpty) return; //probably we should avoid this situation
CurrentZoomLevel = GetZoomFactorToTheGraph();//jyoti added -1
//CurrentZoomLevel = Math.Floor(GetZoomFactorToTheGraph());
FillRailGraph();
_lgLayoutSettings.OnViewerChangeTransformAndInvalidateGraph();
}
public double GetZoomFactorToTheGraph()
{
return _lgLayoutSettings.TransformFromGraphToScreen()[0, 0] / FitFactor();
}
public double FitFactor()
{
Rectangle vp = _lgLayoutSettings.ClientViewportFunc();
_lgLayoutSettings.mainGeometryGraphWidth = _mainGeometryGraph.Width;
_lgLayoutSettings.mainGeometryGraphHeight = _mainGeometryGraph.Height;
return Math.Min(vp.Width / _mainGeometryGraph.Width, vp.Height / _mainGeometryGraph.Height);
}
void FillRailGraph()
{
_railGraph.Nodes.Clear();
AddVisibleRailsAndNodes();
RegisterEdgeSourceTargets();
}
void RegisterEdgeSourceTargets()
{
foreach (Edge e in _railGraph.Edges)
AddEdgeSourceAndTarget(e);
}
void AddEdgeSourceAndTarget(Edge edge)
{
_railGraph.Nodes.Insert(edge.Source); //
_railGraph.Nodes.Insert(edge.Target);
}
/// <summary>
/// </summary>
/// <returns></returns>
public double GetMaximalZoomLevel()
{
if (_lgData == null)
return 1;
return _lgData.GetMaximalZoomLevel();
}
/// <summary>
/// gets all edges passing through rail from the rail's level.
/// </summary>
/// <param name="rail"></param>
/// <returns></returns>
public List<Edge> GetEdgesPassingThroughRail(Rail rail)
{
int i = (int)Math.Log(rail.ZoomLevel, 2);
LgLevel railLevel = _lgData.Levels[i];
List<Edge> passingEdges = railLevel.GetEdgesPassingThroughRail(rail);
return passingEdges;
}
int GetIndexByZoomLevel(double z)
{
return (int)Math.Log(z, 2);
}
//
// void GetCellInfosOfLevel(int iLevel, List<LgCellInfo> cellInfos) {
// Rectangle biggestTile = _lgData.BiggestTile.IsEmpty ? _mainGeometryGraph.BoundingBox : _lgData.BiggestTile;
//
// var levelCellInfos = new List<LgCellInfo>();
// Rectangle rect1 = _visibleRectangle.Intersection(biggestTile);
// Rectangle rect2 = biggestTile;
// var d = (int) Math.Pow(2, iLevel);
// double cW = rect2.Width/d;
// double cH = rect2.Height/d;
// var iL = (int) ((rect1.Left - rect2.Left)/rect2.Width*d);
// double iR = Math.Ceiling((rect1.Right - rect2.Left)/rect2.Width*d);
// var iB = (int) ((rect1.Bottom - rect2.Bottom)/rect2.Height*d);
// double iT = Math.Ceiling((rect1.Top - rect2.Bottom)/rect2.Height*d);
// iL = Math.Min(d, Math.Max(iL, 0));
// iR = Math.Min(d, Math.Max(iR, 0));
// iT = Math.Min(d, Math.Max(iT, 0));
// iB = Math.Min(d, Math.Max(iB, 0));
//
// for (int ix = iL; ix < iR; ix++) {
// for (int iy = iB; iy < iT; iy++) {
// Point pBottomLeft = biggestTile.LeftBottom + new Point(ix*cW, iy*cH);
// var r = new Rectangle(pBottomLeft, pBottomLeft + new Point(cW, cH));
// var ci = new LgCellInfo
// {
// CellRectangle = r,
// ZoomLevel = d,
// MaxNumberNodesPerTile = _lgLayoutSettings.MaxNumberOfNodesPerTile
// };
// levelCellInfos.Add(ci);
// }
// }
//
// CountContainingNodesOfLevelLeq(d, levelCellInfos);
// cellInfos.AddRange(levelCellInfos);
// }
// void CountContainingNodesOfLevelLeq(double zoomLevel, IEnumerable<LgCellInfo> cellInfos) {
// throw new NotImplementedException();
//// var ciRtree = new RTree<LgCellInfo>();
//// var visCellsRect = new Rectangle();
//// visCellsRect.SetToEmpty();
//// foreach (LgCellInfo ci in cellInfos) {
//// ciRtree.Add(ci.CellRectangle, ci);
//// visCellsRect.Add(ci.CellRectangle.LeftBottom);
//// visCellsRect.Add(ci.CellRectangle.RightTop);
//// }
//// IEnumerable<LgNodeInfo> nodeInfosInCells = _lgNodeHierarchy.GetNodeItemsIntersectingRectangle(visCellsRect);
//// foreach (LgNodeInfo nodeInfo in nodeInfosInCells) {
//// if (nodeInfo.ZoomLevel <= zoomLevel) {
//// LgCellInfo[] toCount = ciRtree.GetAllIntersecting(nodeInfo.GeometryNode.BoundingBox);
//// foreach (LgCellInfo ci in toCount) {
//// if (ci.ZoomLevel <= zoomLevel)
//// ci.NumberNodesLeqItsLevelInside++;
//// }
//// }
//// }
// }
public List<LgNodeInfo> GetAllNodesOnVisibleLayers()
{
var nodesToSelect = new List<LgNodeInfo>();
for (int i = 0; i < _lgData.Levels.Count; i++)
{
var nodes = GetNodeInfosOnLevel(i);
nodesToSelect.AddRange(nodes);
}
return nodesToSelect;
}
IEnumerable<LgNodeInfo> GetNodeInfosOnLevel(int i)
{
int iStart = (i == 0 ? 0 : _lgData.LevelNodeCounts[i - 1]);
int iEnd = _lgData.LevelNodeCounts[i];
for (int j = iStart; j < iEnd; j++)
yield return _lgData.SortedLgNodeInfos[j];
}
IEnumerable<LgNodeInfo> GetNodeInfosOnLevelLeq(int i)
{
int iEnd = _lgData.LevelNodeCounts[i];
for (int j = 0; j < iEnd; j++)
yield return _lgData.SortedLgNodeInfos[j];
}
public void InitEdgesOfLevels()
{
foreach (Edge edge in GeometryEdgesToLgEdgeInfos.Keys)
{
LgNodeInfo s = _lgData.GeometryNodesToLgNodeInfos[edge.Source];
LgNodeInfo t = _lgData.GeometryNodesToLgNodeInfos[edge.Target];
int iLevel = GetIndexByZoomLevel(Math.Max(s.ZoomLevel, t.ZoomLevel));
for (int j = iLevel; j < _lgData.Levels.Count; j++)
{
_lgData.Levels[j]._railsOfEdges[edge] = new Set<Rail>();
}
}
}
List<LgNodeInfo> GetNeighborsOnLevel(LgNodeInfo ni, int i)
{
int zoomLevel = _lgData.Levels[i].ZoomLevel;
Debug.Assert(ni.ZoomLevel <= zoomLevel);
List<LgNodeInfo> neighb = (from e in ni.GeometryNode.OutEdges
let nit = _lgData.GeometryNodesToLgNodeInfos[e.Target]
where nit.ZoomLevel <= zoomLevel
select nit).ToList();
neighb.AddRange(from e in ni.GeometryNode.InEdges
let nis = _lgData.GeometryNodesToLgNodeInfos[e.Source]
where nis.ZoomLevel <= zoomLevel
select nis);
return neighb;
}
//adapting lev's shortest path - jyoti
public void RouteEdgesOnZeroLayer()
{
Tiling g1 = new Tiling(g.NumOfnodes, true);
g1.N = g.N;
g1.isPlanar = g.isPlanar;
g1.NumOfnodesBeforeDetour = g.NumOfnodesBeforeDetour;
g1.nodeTree = g.nodeTree;
g1.maxTheoreticalZoomLevel = g.maxTheoreticalZoomLevel;
g1.nodeToLoc = g.nodeToLoc;
for (int i = 0; i < g.NumOfnodes; i++)
g1.VList[i] = new Vertex(g.VList[i].XLoc, g.VList[i].YLoc) { Id = g.VList[i].Id, ZoomLevel = g.VList[i].ZoomLevel };
var skeletonLevel = _lgData.SkeletonLevels[0];
skeletonLevel.ClearSavedTrajectoriesAndUsedEdges();
Console.Write("\nRouting edges");
//int numRouted = 0;
foreach (LgNodeInfo ni in GetNodeInfosOnLevelLeq(0))
{
skeletonLevel.PathRouter.SetAllEdgeLengthMultipliersMin(0.8);
DecreaseWeightsAlongOldTrajectoriesFromSource(0, skeletonLevel, ni);
var neighb = GetNeighborsOnLevel(ni, 0);
foreach (LgNodeInfo t in neighb)
{
var path = _lgData.SkeletonLevels[0].HasSavedTrajectory(ni, t)
? skeletonLevel.GetTrajectory(ni, t)
: skeletonLevel.PathRouter.GetPath(ni, t, ShrinkEdgeLengths, g);
skeletonLevel.SetTrajectoryAndAddEdgesToUsed(ni, t, path);
//collect the path
int node1Id = PointToId[path.First()];
int lastnode = PointToId[path.Last()];
var zoomlevel = Math.Max(g.VList[node1Id].ZoomLevel, g.VList[lastnode].ZoomLevel);
int node2Id = -1;
foreach (Point p in path)
{
node2Id = PointToId[p];
if (node1Id == node2Id) continue;
int j = -1;
//find the neighbor where node2 is located
for (j = 0; j < g.DegList[node1Id]; j++)
if (g.EList[node1Id, j].NodeId == node2Id) break;
//g1.AddEdge(node1Id, node2Id, g.EList[node1Id, j].Selected, g.EList[node1Id, j].Used);
g1.AddEdge(node1Id, node2Id, 1, zoomlevel);
node1Id = node2Id;
}
// decrease weights
skeletonLevel.PathRouter.DecreaseWeightOfEdgesAlongPath(path, 0.5);
//if (numRouted++%100 == 0)
// Console.Write(".");
}
}
//clear unused junctions
for (int i = 0; i < g1.NumOfnodes; i++)
if (g1.DegList[i] == 0) g1.VList[i].Invalid = true;
g = g1;
}
bool EdgeIsNew(LgNodeInfo s, LgNodeInfo t, int i)
{
return Math.Max(s.ZoomLevel, t.ZoomLevel) >= _lgData.Levels[i].ZoomLevel;
}
public void RouteEdges(int i)
{
AddAllPortEdges(i);
if (i == 0)
RouteEdgesOnZeroLayer();
else
RouteOnHigherLevel(i);
}
void RouteOnHigherLevel(int iLevel)
{
IEnumerable<LgNodeInfo> nodes;
var skeletonLevel = DealWithPathsFromPreviousLevels(iLevel, out nodes);
ComputeNewTrajectories(iLevel, nodes, skeletonLevel);
}
LgSkeletonLevel DealWithPathsFromPreviousLevels(int i, out IEnumerable<LgNodeInfo> nodes)
{
var skeletonLevel = _lgData.SkeletonLevels[i];
var prevSkeletonLevel = _lgData.SkeletonLevels[i - 1];
nodes = GetNodeInfosOnLevelLeq(i);
skeletonLevel.ClearSavedTrajectoriesAndUsedEdges();
skeletonLevel.PathRouter.ResetAllEdgeLengthMultipliers();
Console.Write("\nRouting edges");
Console.Write("\nUpdating old trajectories");
// reset multipliers
skeletonLevel.PathRouter.ResetAllEdgeLengthMultipliers();
UpdatePrevLayerTrajectories(i, nodes, prevSkeletonLevel, skeletonLevel);
//DecreaseWeightsAlongOldTrajectories(i, skeletonLevel);
return skeletonLevel;
}
// bool susp(Point s, Point t) {
// Point ss = new Point(73.79755, 210.1525);
// Point tt = new Point(-119.5393, 50.605);
// return (s - ss).Length < 2 && (t - tt).Length < 2;
// }
/// <summary>
/// find a better name
/// </summary>
/// <param name="i"></param>
/// <param name="nodes"></param>
/// <param name="prevSkeletonLevel"></param>
/// <param name="skeletonLevel"></param>
void UpdatePrevLayerTrajectories(int i, IEnumerable<LgNodeInfo> nodes,
LgSkeletonLevel prevSkeletonLevel, LgSkeletonLevel skeletonLevel
)
{
int numRouted = 0;
foreach (LgNodeInfo s in nodes)
{
var neighb = GetNeighborsOnLevel(s, i).OrderBy(n => n.ZoomLevel);
foreach (LgNodeInfo t in neighb)
{
var oldTrajectory = prevSkeletonLevel.GetTrajectory(s, t);
if (oldTrajectory == null) continue;
var trajectory = skeletonLevel.PathRouter.GetPathOnSavedTrajectory(s, t,
oldTrajectory, ShrinkEdgeLengths);
skeletonLevel.SetTrajectoryAndAddEdgesToUsed(s, t, trajectory);
skeletonLevel.MarkEdgesAlongPathAsEdgesOnOldTrajectories(trajectory);
}
if (++numRouted % 100 == 1) Console.Write(".");
}
}
void DecreaseWeightsAlongOldTrajectories(int i, LgSkeletonLevel skeletonLevel)
{
foreach (var tuple in skeletonLevel.EdgeTrajectories)
{
// debug
if (!EdgeIsNew(tuple.Key.A, tuple.Key.B, i))
{
List<Point> oldPath = tuple.Value;
double iEdgeLevel = Math.Log(Math.Max(tuple.Key.A.ZoomLevel, tuple.Key.B.ZoomLevel), 2);
//double newWeight = //(iEdgeLevel < 1 ? 0.3 : (iEdgeLevel < 2 ? 0.6 : 1));
// 0.4 + iEdgeLevel/(Math.Max(i - 1.0, 1.0))*0.2;
//newWeight = Math.Max(0.4, newWeight);
//newWeight = Math.Min(0.6, newWeight);
double newWeight = (iEdgeLevel < 1 ? 0.1 : (iEdgeLevel < 2 ? 0.2 : 0.6));
newWeight = Math.Max(0.1, newWeight);
newWeight = Math.Min(0.6, newWeight);
skeletonLevel.PathRouter.DecreaseWeightOfEdgesAlongPath(oldPath, newWeight);
}
}
}
void DecreaseWeightsAlongOldTrajectoriesFromSource(int i, LgSkeletonLevel skeletonLevel, LgNodeInfo s)
{
IOrderedEnumerable<LgNodeInfo> neighb = GetNeighborsOnLevel(s, i).OrderBy(n => n.ZoomLevel);
foreach (var t in neighb)
{
var tuple = new SymmetricTuple<LgNodeInfo>(s, t);
List<Point> path;
skeletonLevel.EdgeTrajectories.TryGetValue(tuple, out path);
if (path != null)
{
double iEdgeLevel = Math.Log(Math.Max(s.ZoomLevel, t.ZoomLevel), 2);
double newWeight = (iEdgeLevel < 1 ? 0.4 : (iEdgeLevel < 2 ? 0.5 : 0.6));
newWeight = Math.Max(0.4, newWeight);
newWeight = Math.Min(0.6, newWeight);
skeletonLevel.PathRouter.DecreaseWeightOfEdgesAlongPath(path, newWeight);
//#if DEBUG
// skeletonLevel.PathRouter.AssertEdgesPresentAndPassable(path);
//#endif
}
}
}
List<LineSegment> GetSegmentsOnOldTrajectoriesFromSource(int i, LgSkeletonLevel skeletonLevel, LgNodeInfo s)
{
var pc = new List<LineSegment>();
IOrderedEnumerable<LgNodeInfo> neighb = GetNeighborsOnLevel(s, i).OrderBy(n => n.ZoomLevel);
foreach (var t in neighb)
{
var tuple = new SymmetricTuple<LgNodeInfo>(s, t);
List<Point> path;
skeletonLevel.EdgeTrajectories.TryGetValue(tuple, out path);
if (path != null)
{
for (int j = 0; j < path.Count - 1; j++)
{
pc.Add(new LineSegment(path[j], path[j + 1]));
}
}
}
return pc;
}
void SetWeightsAlongOldTrajectoriesFromSourceToMin(int i, LgSkeletonLevel skeletonLevel, LgNodeInfo s, double wmin)
{
IOrderedEnumerable<LgNodeInfo> neighb = GetNeighborsOnLevel(s, i).OrderBy(n => n.ZoomLevel);
foreach (var t in neighb)
{
var tuple = new SymmetricTuple<LgNodeInfo>(s, t);
List<Point> path;
skeletonLevel.EdgeTrajectories.TryGetValue(tuple, out path);
if (path != null)
{
skeletonLevel.PathRouter.SetWeightOfEdgesAlongPathToMin(path, wmin);
}
}
}
void ComputeNewTrajectories(int i, IEnumerable<LgNodeInfo> nodes, LgSkeletonLevel skeletonLevel)
{
int numRouted = 0;
Console.Write("\nComputing new trajectories");
// reset multipliers
skeletonLevel.PathRouter.SetAllEdgeLengthMultipliersMin(0.8);
foreach (LgNodeInfo s in nodes)
{
// decrease weights along old trajectories
DecreaseWeightsAlongOldTrajectoriesFromSource(i, skeletonLevel, s);
IOrderedEnumerable<LgNodeInfo> neighb = GetNeighborsOnLevel(s, i).OrderBy(n => n.ZoomLevel);
foreach (LgNodeInfo t in neighb)
{
List<Point> path = skeletonLevel.GetTrajectory(s, t);
if (path == null)
{
path = skeletonLevel.PathRouter.GetPath(s, t, ShrinkEdgeLengths);
skeletonLevel.SetTrajectoryAndAddEdgesToUsed(s, t, path);
}
numRouted++;
if (numRouted % 100 == 1)
Console.Write(".");
//#if DEBUG
// List<LineSegment> pc = new List<LineSegment>();
// List<LineSegment> pcold = GetSegmentsOnOldTrajectoriesFromSource(i, skeletonLevel, s);
// for (int j = 0; j < path.Count - 1; j++)
// {
// pc.Add(new LineSegment(path[j],path[j+1]));
// }
// if ((int)s.GeometryNode.DebugId == 301 && (int)t.GeometryNode.DebugId == 81) {
// SplineRouter.ShowVisGraph(skeletonLevel.PathRouter.VisGraph,
// nodes.Select(n => n.BoundaryOnLayer), pcold, pc);
// }
//#endif
}
// reset multipliers
SetWeightsAlongOldTrajectoriesFromSourceToMin(i, skeletonLevel, s, 0.8);
}
}
public bool CheckSanityAllRoutes(int i)
{
var nodes = GetNodeInfosOnLevelLeq(i);
bool sanity = true;
foreach (LgNodeInfo s in nodes)
{
sanity &= CheckSanityRoutes(s, i);
if (!sanity) break;
}
return sanity;
}
public bool CheckSanityRoutes(LgNodeInfo s, int i)
{
List<LgNodeInfo> neighb = GetNeighborsOnLevel(s, i);
Point rootPoint = _lgData.SkeletonLevels[i].PathRouter.AddVisGraphVertex(s.Center);
var graph = new LgPathRouter();
foreach (LgNodeInfo t in neighb)
{
List<Point> path = _lgData.SkeletonLevels[i].GetTrajectory(s, t);
for (int j = 0; j < path.Count - 1; j++)
{
graph.AddVisGraphEdge(path[j], path[j + 1]);
}
}
bool hasCycles = graph.HasCycles(rootPoint);
if (hasCycles) Console.WriteLine("BAD SP Tree at: " + s);
//foreach (var t in neighb)
//{
// List<Point> path, treePath;
// if (!lgData.SkeletonLevels[i].HasSavedTrajectory(s, t))
// continue;
// path = lgData.SkeletonLevels[i].GetTrajectory(s, t);
// tree.AddPathToTree(path);
// var tp = lgData.SkeletonLevels[i].VisGraph.AddVisGraphVertex(t.Center);
// treePath = tree.GetPathFromRoot(tp);
// if (!path.First().Equals(rootPoint))
// {
// path.Reverse();
// }
// bool pathsEqual = true;
// for (int j = 0; j < path.Count; j++)
// {
// pathsEqual &= path[j].Equals(treePath[j]);
// if (!pathsEqual)
// break;
// }
// if (!pathsEqual)
// {
// return false;
// }
//}
return !hasCycles;
}
void CopyGraphToNextLevel(int i)
{
foreach (var st in _lgData.SkeletonLevels[i].PathRouter.GetAllEdgesVisibilityEdges())
{
_lgData.SkeletonLevels[i + 1].PathRouter.AddVisGraphEdge(st.SourcePoint, st.TargetPoint);
}
}
public void ClearSkeleton(int iLevel)
{
_lgData.SkeletonLevels[iLevel].Clear();
}
public void RunOverlapRemovalBitmap(int iLevel)
{
//if (iLevel == 0) return;
// should run even for level 0!
var fixedNodes = iLevel > 0
? GetNodeInfosOnLevelLeq(iLevel - 1)
: new List<LgNodeInfo>();
var moveableNodes = GetNodeInfosOnLevel(iLevel);
Rectangle[] fixedBoxes = (from node in fixedNodes select node.BoundaryOnLayer.BoundingBox).ToArray();
Rectangle[] moveableBoxes = (from node in moveableNodes select node.BoundaryOnLayer.BoundingBox).ToArray();
// string[] fixedBoxesLabels = (from node in fixedNodes select node.ToString()).ToArray();
// string[] moveableBoxesLabels = (from node in moveableNodes select node.ToString()).ToArray();
var fixedSegments = iLevel > 0
? _lgData.Levels[iLevel - 1].GetAllRailsEndpoints().ToArray()
: new SymmetricSegment[0];
#if DEBUG
// ShowNodesAndSegmentsForOverlapRemoval(fixedNodes, moveableNodes, fixedSegments);
#endif
//Test
//Test1.RunTestOrb1(moveableBoxes, fixedBoxes, fixedSegments);
//return;
//Test end
var orb = new OverlapRemovalFixedSegmentsBitmap(moveableBoxes, fixedBoxes, fixedSegments)
{
NumPixelsPadding = 10
};
var fixedRectTree = new RTree<Rectangle>();
var fixedSegTree = new RTree<SymmetricSegment>();
foreach (Rectangle rect in fixedBoxes)
fixedRectTree.Add(rect, rect);
foreach (var seg in fixedSegments)
fixedSegTree.Add(new Rectangle(seg.A, seg.B), seg);
int numPlaced = 0;
while (true)
{
numPlaced = orb.PositionAllMoveableRectsSameSize(numPlaced, fixedRectTree, fixedSegTree);
if (numPlaced >= moveableBoxes.Count()) break;
orb.ScaleBbox(1.25);
}
Point[] translations = orb.GetTranslations();
int i = 0;
foreach (var mv in moveableNodes)
{
mv.Translate(translations[i++]);
}
#if DEBUG
// ShowNodesAndSegmentsForOverlapRemoval(fixedNodes, moveableNodes, fixedSegments);
#endif
}
static void ShowNodesAndSegmentsForOverlapRemoval(IEnumerable<LgNodeInfo> fixedNodes,
IEnumerable<LgNodeInfo> moveableNodes, SymmetricSegment[] fixedSegments)
{
// #if DEBUG && !SHARPKIT
// var l = new List<DebugCurve>();
// if (fixedNodes != null && fixedNodes.Any())
// {
// foreach (var node in fixedNodes)
// {
// l.Add(new DebugCurve(200, 0.1, "red", node.BoundaryCurve));
// }
// }
// if (fixedSegments != null && fixedSegments.Any())
// {
// foreach (var seg in fixedSegments)
// {
// var ls = new LineSegment(seg.A, seg.B);
// l.Add(new DebugCurve(100, 0.1, "magenta", ls));
// }
// }
// foreach (var node in moveableNodes)
// {
// l.Add(new DebugCurve(200, 0.1, "green", node.BoundaryCurve));
// }
// LayoutAlgorithmSettings.ShowDebugCurves(l.ToArray());
// #endif
}
void ClearLevels(int num)
{
_lgData.Levels.Clear();
_lgData.SkeletonLevels.Clear();
int zoomLevel = 1;
for (int i = 0; i < num; i++)
{
var level = new LgLevel(zoomLevel, _mainGeometryGraph);
level.ClearRailTree();
_lgData.Levels.Add(level);
_lgData.SkeletonLevels.Add(new LgSkeletonLevel { ZoomLevel = zoomLevel });
zoomLevel *= 2;
}
}
void UpdateNodeInfoZoomLayers()
{
int level = 1;
int j = 0;
for (int i = 0; i < _lgData.SortedLgNodeInfos.Count; i++)
{
while (j < _lgData.LevelNodeCounts.Count && i == _lgData.LevelNodeCounts[j])
{
j++;
level *= 2;
}
_lgData.SortedLgNodeInfos[i].ZoomLevel = level;
}
}
void InitRailsOfEdgesEmpty()
{
foreach (Edge edge in _mainGeometryGraph.Edges)
{
LgNodeInfo s = _lgData.GeometryNodesToLgNodeInfos[edge.Source];
LgNodeInfo t = _lgData.GeometryNodesToLgNodeInfos[edge.Target];
double zoomLevel = Math.Max(s.ZoomLevel, t.ZoomLevel);
GeometryEdgesToLgEdgeInfos[edge].ZoomLevel = zoomLevel;
int iLevel = GetIndexByZoomLevel(zoomLevel); //(int) Math.Log(zoomLevel, 2);
for (int j = iLevel; j < _lgData.Levels.Count; j++)
_lgData.Levels[j]._railsOfEdges[edge] = new Set<Rail>();
}
}
void InitRailsOfEdgesEmpty(int iMinLevel)
{
foreach (Edge edge in _mainGeometryGraph.Edges)
{
LgNodeInfo s = _lgData.GeometryNodesToLgNodeInfos[edge.Source];
LgNodeInfo t = _lgData.GeometryNodesToLgNodeInfos[edge.Target];
double zoomLevel = Math.Max(s.ZoomLevel, t.ZoomLevel);
GeometryEdgesToLgEdgeInfos[edge].ZoomLevel = zoomLevel;
int iLevel = Math.Max(GetIndexByZoomLevel(zoomLevel), iMinLevel);
for (int j = iLevel; j < _lgData.Levels.Count; j++)
_lgData.Levels[j]._railsOfEdges[edge] = new Set<Rail>();
}
}
public void AddAllPortEdges(int iLevel)
{
var nodes = GetNodeInfosOnLevelLeq(iLevel);
var skeletonLevel = _lgData.SkeletonLevels[iLevel];
skeletonLevel.AddGraphEdgesFromCentersToPointsOnBorders(nodes);
//SplineRouter.ShowVisGraph(skeletonLevel.PathRouter.VisGraph, null,null,null);
}
void CreateGraphFromSteinerCdt(int iLevel)
{
var nodes = GetNodeInfosOnLevelLeq(iLevel);
var cdt = new SteinerCdt(_lgData.SkeletonLevels[iLevel].PathRouter.VisGraph, nodes);
//cdt.ReadTriangleOutputAndPopulateTheLevelVisibilityGraphFromTriangulation();
for (int index = 0; index < g.NumOfnodes; index++)
{
var p = new Point(g.VList[index].XLoc, g.VList[index].YLoc);
var w = cdt._visGraph.AddVertex(p);
if (index < g.NumOfnodesBeforeDetour) w.isReal = true;
else w.isReal = false;
cdt._outPoints[index] = w;
cdt._visGraph.PointToVertexMap[p] = w;
cdt._visGraph.visVertexToId[w] = index;
PointToId[p] = index;
}
for (int index = 0; index < g.NumOfnodes; index++)
{
for (int neighbor = 0; neighbor < g.DegList[index]; neighbor++)
{
var a = cdt._outPoints[index];
var b = cdt._outPoints[g.EList[index, neighbor].NodeId];
cdt.AddVisEdge(a, b);
}
}
}
/*
void CreateGraphFromSteinerCdt(int iLevel)
{
var nodes = GetNodeInfosOnLevelLeq(iLevel);
var cdt = new SteinerCdt(_lgData.SkeletonLevels[iLevel].PathRouter.VisGraph, nodes);
cdt.ReadTriangleOutputAndPopulateTheLevelVisibilityGraphFromTriangulation();
}
*/
public bool SimplifyRoutes(int iLevel)
{
Console.WriteLine("\nsimplifying level {0}", iLevel);
var nodes = GetNodeInfosOnLevelLeq(iLevel);
var skeletonLevel = _lgData.SkeletonLevels[iLevel];
var fixedVertices = new Set<Point>(nodes.Select(n => n.Center));
if (iLevel > 0)
fixedVertices.InsertRange(_lgData.SkeletonLevels[iLevel - 1].GetPointsOnSavedTrajectories());
#if DEBUG
// SplineRouter.ShowVisGraph(skeletonLevel.PathRouter.VisGraph, nodes.Select(n=>n.BoundaryOnLayer), null, null);
#endif
var routeSimplifier = new RouteSimplifier(skeletonLevel.PathRouter, nodes, fixedVertices);
return routeSimplifier.Run();
}
// #if DEBUG && !SHARPKIT
// static void ShowOldNewIntersected(Set<Rail> oldIntersected, Set<Rail> newIntersected, Point a, Point shortcutted,
// Point b, LgSkeletonLevel skeletonLevel)
// {
// var ll = new List<DebugCurve>();
// ll.Add(new DebugCurve(new LineSegment(a, shortcutted)));
// ll.Add(new DebugCurve(new LineSegment(shortcutted, b)));
// ll.AddRange(oldIntersected.Select(r => new DebugCurve(100, 0.1, "blue", LineFromRail(r))));
// ll.AddRange(newIntersected.Select(r => new DebugCurve(100, 0.1, "red", LineFromRail(r))));
// ll.Add(new DebugCurve(CurveFactory.CreateCircle(3, shortcutted)));
// ll.Add(new DebugCurve("red", CurveFactory.CreateCircle(3, a)));
// ll.Add(new DebugCurve("green", CurveFactory.CreateCircle(3, b)));
//
// foreach (var rail in newIntersected)
// {
// var e = FindRailInVisGraph(rail, skeletonLevel);
// if (e == null)
// {
// Console.WriteLine("rail {0} is not found in the vis graph", rail);
// }
// }
//
//
// LayoutAlgorithmSettings.ShowDebugCurves(ll.ToArray());
// }
// #endif
//
// #if DEBUG && !SHARPKIT
// private static void ShowOldTrajectories(LgSkeletonLevel skeletonLevel)
// {
// if (skeletonLevel.ZoomLevel <= 1.0) return;
// var segs = skeletonLevel.PathRouter.EdgesOnOldTrajectories();
// var ll = new List<DebugCurve>();
// foreach (var seg in segs)
// {
// ll.Add(new DebugCurve(new LineSegment(seg.A, seg.B)));
// }
// LayoutAlgorithmSettings.ShowDebugCurves(ll.ToArray());
// }
// #endif
static VisibilityEdge FindRailInVisGraph(Rail rail, LgSkeletonLevel skeletonLevel)
{
Point s, t;
rail.GetStartEnd(out s, out t);
return skeletonLevel.PathRouter.FindEdge(s, t);
}
static ICurve LineFromRail(Rail rail)
{
Point s, t;
rail.GetStartEnd(out s, out t);
return new LineSegment(s, t);
}
/*
var rect = new Rectangle(a, b);
foreach (var railNode in skeletonLevel._railTree.GetAllLeavesIntersectingRectangle(rect)) {
var rail = railNode.UserData;
if (NontrivialIntersection(a, b, rail)) {
return false;
}
}
return true;
}
*/
public void FillLevelsWithNodesOnly(int maxNodesPerTile)
{
var calc = new GreedyNodeRailLevelCalculator(_lgData.SortedLgNodeInfos)
{
GeometryNodesToLgNodeInfos = _lgData.GeometryNodesToLgNodeInfos
};
calc.MaxAmountNodesPerTile = maxNodesPerTile;
calc.IncreaseNodeQuota = _lgLayoutSettings.IncreaseNodeQuota;
var bbox = GetLargestTile();
calc.PlaceNodesOnly(bbox);
_lgData.LevelNodeCounts = calc.GetLevelNodeCounts();
ClearLevels(_lgData.LevelNodeCounts.Count);
}
public void FillLevelWithNodesRoutesTryRerouting(int iLevel, int maxNodesPerTile, int maxSegmentsPerTile,
double increaseNodeQuota)
{
var calc = new GreedyNodeRailLevelCalculator(_lgData.SortedLgNodeInfos)
{
GeometryNodesToLgNodeInfos = _lgData.GeometryNodesToLgNodeInfos
};
calc.InitBoundingBox();
calc.MaxAmountNodesPerTile = maxNodesPerTile;
calc.MaxAmountRailsPerTile = maxSegmentsPerTile;
calc.IncreaseNodeQuota = increaseNodeQuota;
var trajectories =
_lgData.SkeletonLevels[iLevel].EdgeTrajectories;
int numToInsert = _lgData.LevelNodeCounts[iLevel];
int zoomLevel = _lgData.Levels[iLevel].ZoomLevel;
int nodesOnPrevLevel = iLevel > 0 ? _lgData.LevelNodeCounts[iLevel - 1] : 0;
var bbox = GetLargestTile();
var oldSegs = GetSegmentsOnOldTrajectories(iLevel);
//int numInserted = calc.TryInsertingNodesAndRoutesTryRerouting(numToInsert, trajectories, zoomLevel,
// nodesOnPrevLevel, new GridTraversal(bbox, iLevel), _lgData.SkeletonLevels[iLevel].PathRouter);
int numInserted = calc.TryInsertingNodesAndRoutes(numToInsert, trajectories, oldSegs, zoomLevel,
nodesOnPrevLevel, new GridTraversal(bbox, iLevel), _lgData.SkeletonLevels[iLevel].PathRouter);
if (iLevel > 0 && numInserted < _lgData.LevelNodeCounts[iLevel - 1])
// couldn't even get to current level
numInserted = _lgData.LevelNodeCounts[iLevel - 1];
if (numInserted < numToInsert)
PushNodesToNextLevel(iLevel, numInserted);
// update level node counts
_lgData.LevelNodeCounts[iLevel] = numInserted;
}
public List<SymmetricSegment> GetSegmentsOnOldTrajectories(int iLevel)
{
var segs = new List<SymmetricSegment>();
for (int i = 0; i < iLevel; i++)
{
segs.AddRange(_lgData.SkeletonLevels[i].PathRouter.SegmentsNotOnOldTrajectories());
}
return segs;
}
void AssignRailsByTrajectories(int iLevel)
{
var edges = new List<Edge>(_lgData.Levels[iLevel]._railsOfEdges.Keys);
_lgData.Levels[iLevel]._railTree = new RTree<Rail>();
foreach (Edge edge in edges)
{
LgEdgeInfo ei = _lgData.GeometryEdgesToLgEdgeInfos[edge];
LgNodeInfo s = _lgData.GeometryNodesToLgNodeInfos[edge.Source];
LgNodeInfo t = _lgData.GeometryNodesToLgNodeInfos[edge.Target];
if (_lgData.SkeletonLevels[iLevel].HasSavedTrajectory(s, t))
{
List<Point> trajectory = _lgData.SkeletonLevels[iLevel].GetTrajectory(s, t);
List<Rail> rails = _lgData.Levels[iLevel].FetchOrCreateRailSequence(trajectory);
_lgData.Levels[iLevel]._orderedRailsOfEdges[edge] = rails;
_lgData.AssembleEdgeAtLevel(ei, iLevel, new Set<Rail>(rails));
}
}
}
void PushNodesToNextLevel(int iLevel, int numInserted)
{
if (iLevel == _lgData.Levels.Count - 1)
{
var level = new LgLevel(_lgData.Levels[iLevel].ZoomLevel * 2, _mainGeometryGraph);
level.CreateEmptyRailTree();
_lgData.Levels.Add(level);
_lgData.SkeletonLevels.Add(new LgSkeletonLevel { ZoomLevel = level.ZoomLevel });
_lgData.LevelNodeCounts.Add(_lgData.LevelNodeCounts.Last());
}
int numToInsert = _lgData.LevelNodeCounts[iLevel];
if (numToInsert <= numInserted) return;
int newZoomLevel = _lgData.Levels[iLevel + 1].ZoomLevel;
for (int i = numInserted; i < numToInsert; i++)
{
_lgData.SortedLgNodeInfos[i].ZoomLevel = newZoomLevel;
}
_lgData.LevelNodeCounts[iLevel] = numInserted;
// need to update assigned edge routes
_lgData.Levels[iLevel]._railsOfEdges.Clear();
_lgData.Levels[iLevel + 1]._railsOfEdges.Clear();
InitRailsOfEdgesEmpty(iLevel);
}
/// <summary>
/// calculates all info for LG Browsing
/// </summary>
/// <param name="maxNodesPerTile"></param>
/// <param name="maxSegmentsPerTile"></param>
/// <param name="increaseNodeQuota"></param>
public void LayoutAndRouteByLayers(int maxNodesPerTile, int maxSegmentsPerTile, double increaseNodeQuota)
{
FillLevelsWithNodesOnly(maxNodesPerTile);
InitRailsOfEdgesEmpty();
//InitNodeLabelWidthToHeightRatios();
AddSkeletonLevels();
for (int i = 0; i < _lgData.Levels.Count; i++)
RemoveOverlapsAndRouteForLayer(maxNodesPerTile, maxSegmentsPerTile, increaseNodeQuota, i);
_lgData.CreateLevelNodeTrees(NodeDotWidth(1));
//LabelingOfOneRun();
#if DEBUG
TestAllEdgesConsistency();
#endif
}
public Rectangle GetLargestTile()
{
var bbox = _mainGeometryGraph.boundingBox.Clone();
var p = NodeDotWidth(1) * 0.5;
bbox.Pad(p, p, p, p);
return bbox;
}
public void LabelingOfOneRun()
{
foreach (LgNodeInfo node in _lgData.SortedLgNodeInfos)
{
//if (node.ZoomLevel > 1.0)
// node.LabelVisibleFromScale = node.ZoomLevel;
//else
node.LabelVisibleFromScale = 0.0;
}
double scale = 1.0 / 16.0;
double delta = Math.Pow(2, 1.0 / 8.0);
int numberOfLabeledNodes = 0;
double hugeScale = Math.Pow(2, _lgData.Levels.Last().ZoomLevel + 1);
while (numberOfLabeledNodes < _lgData.GeometryNodesToLgNodeInfos.Count && scale <= hugeScale)
{
numberOfLabeledNodes = InsertLabelsGreedily(scale);
scale *= delta;
}
if (numberOfLabeledNodes < _lgData.SortedLgNodeInfos.Count)
Console.WriteLine("Failed to label {0} nodes", _lgData.SortedLgNodeInfos.Count - numberOfLabeledNodes);
CleanUpRails();
// make labels appear slightly earlier
foreach (LgNodeInfo node in _lgData.SortedLgNodeInfos)
{
node.LabelVisibleFromScale -= 0.0001;
}
}
/*
private void TestRouteNodeOverlaps(int i)
{
var skeletonLevel = _lgData.SkeletonLevels[i];
var nodes = GetNodesOnLevelLeq(i);
var rtree = new RTree<LgNodeInfo>();
foreach (var node in nodes)
{
var bbox = node.BoundingBox.Clone();
bbox.ScaleAroundCenter(0.5);
rtree.Add(bbox, node);
}
foreach (var tuple in skeletonLevel.EdgeTrajectories)
{
var s = tuple.Key.Item1;
var t = tuple.Key.Item2;
var path = tuple.Value;
var ndsInt = new Set<LgNodeInfo>();
for (int j = 0; j < path.Count - 1; j++)
{
var p0 = path[j];
var p1 = path[j + 1];
var nds = rtree.GetAllIntersecting(new Rectangle(p0, p1)).ToList();
ndsInt.InsertRange( nds.Where(ni => RectSegIntersection.Intersect(ni.BoundingBox, p0, p1)) );
}
if (ndsInt.Count > 2)
{
Console.WriteLine("Path {0} -> {1} intersects nodes {2}", s.GeometryNode.ToString(), t.GeometryNode, ndsInt);
}
}
}
*/
void RemoveOverlapsAndRouteForLayer(int maxNodesPerTile, int maxSegmentsPerTile, double increaseNodeQuota,
int iLayer)
{
PrepareNodeBoundariesAndSkeletonOnLayer(iLayer);
//commented by jyoti - takes too long
//RunOverlapRemovalBitmap(iLayer);
var skeletonLevel = _lgData.SkeletonLevels[iLayer];
CreateGraphFromSteinerCdt(iLayer);
var bbox = GetLargestTile();
var gt = new GridTraversal(bbox, iLayer);
#if DEBUG
// var rects = gt.GetTileRectangles();
// var rCurves = new List<ICurve>();
// foreach (var r in rects)
// {
// rCurves.Add(CurveFactory.CreateRectangle(r));
// }
// SplineRouter.ShowVisGraph(skeletonLevel.PathRouter.VisGraph, null, rCurves, null);
#endif
RouteEdges(iLayer);
RemoveUnusedVisibilityGraphEdgesAndNodes(iLayer);
/*
var layer = _lgData.SkeletonLevels[iLayer];
Debug.Assert(layer.RoutesAreConsistent());
SimplifyRoutesOnLevelUntilDone(iLayer);
Debug.Assert(layer.RoutesAreConsistent());
FillLevelWithNodesRoutesTryRerouting(iLayer, maxNodesPerTile, maxSegmentsPerTile, increaseNodeQuota);
RemoveTrajectoriesForEdgesWithHighZoom(iLayer);
Debug.Assert(layer.RoutesAreConsistent());
Debug.Assert(HigherTrajectoriesPreserved(iLayer));
SimplifyRoutesOnLevelUntilDone(iLayer);
Debug.Assert(layer.RoutesAreConsistent());
AssignRailsByTrajectories(iLayer);
Debug.Assert(layer.RoutesAreConsistent());
if (iLayer < _lgData.Levels.Count - 1)
CopyGraphToNextLevel(iLayer);
* */
}
bool HigherTrajectoriesPreserved(int iLayer)
{
for (int j = 0; j <= iLayer; j++)
if (!TestTrajectoriesPreserved(iLayer)) return false;
return true;
}
void PrepareNodeBoundariesAndSkeletonOnLayer(int iLayer)
{
var scale = Math.Pow(2, iLayer);
var rad = NodeDotWidth(scale); // make the BoundaryOnLayer twice larger than the node
for (int i = 0; i < _lgData.LevelNodeCounts[iLayer]; i++)
{
LgNodeInfo ni = _lgData.SortedLgNodeInfos[i];
ni.BoundaryOnLayer = CurveFactory.CreateRegularPolygon(_lgLayoutSettings.NumberOfNodeShapeSegs,
ni.Center, rad);
}
if (iLayer > 0)
{
ModifySkeletonWithNewBoundariesOnLayer(iLayer);
}
}
void ModifySkeletonWithNewBoundariesOnLayer(int iLayer)
{
for (int i = 0; i < _lgData.LevelNodeCounts[iLayer]; i++)
_lgData.SkeletonLevels[iLayer].PathRouter.ModifySkeletonWithNewBoundaryOnLayer(
_lgData.SortedLgNodeInfos[i]);
}
void RemoveUnusedVisibilityGraphEdgesAndNodes(int i)
{
_lgData.SkeletonLevels[i].RemoveUnusedGraphEdgesAndNodes();
}
void SimplifyRoutesOnLevelUntilDone(int i)
{
#if DEBUG
// ShowOldTrajectories(_lgData.SkeletonLevels[i]);
#endif
do
{
if (!SimplifyRoutes(i))
break;
UpdateRoutesAfterSimplification(i);
} while (true);
#if DEBUG
// ShowOldTrajectories(_lgData.SkeletonLevels[i]);
#endif
}
public void InitNodeLabelWidthToHeightRatios(List<double> noldeLabelRatios)
{
for (int i = 0; i < _mainGeometryGraph.Nodes.Count; i++)
{
var n = _mainGeometryGraph.Nodes[i];
var ni = _lgData.GeometryNodesToLgNodeInfos[n];
if (ni != null)
{
ni.LabelWidthToHeightRatio = noldeLabelRatios[i];
}
}
}
void RemoveTrajectoriesForEdgesWithHighZoom(int iLevel)
{
// some edges are no longer used since their adjacent nodes moved to the next level.
// need to delete them from the level EdgeTrajectories
var edgeTrajectories = _lgData.SkeletonLevels[iLevel].EdgeTrajectories;
int zoomLevel = _lgData.Levels[iLevel].ZoomLevel;
var removeList =
new List<SymmetricTuple<LgNodeInfo>>(
edgeTrajectories.Keys.Where(p => p.A.ZoomLevel > zoomLevel || p.B.ZoomLevel > zoomLevel));
if (removeList.Count > 0)
{
_lgData.SkeletonLevels[iLevel].RemoveSomeEdgeTrajectories(removeList);
_lgData.Levels[iLevel].RemoveFromRailEdges(removeList);
}
}
void TestRailsForTrajectories(int iLevel)
{
foreach (var path in _lgData.SkeletonLevels[iLevel].EdgeTrajectories.Values)
{
for (int i = 0; i < path.Count - 1; i++)
{
Rail rail = _lgData.Levels[iLevel].FindRail(path[i], path[i + 1]);
//lgData.Levels[iLevel].AddRailToDictionary(rail);
//lgData.Levels[iLevel].AddRailToRtree(rail);
if (rail == null)
{
Console.WriteLine("Rail not found for trajectory!");
}
}
}
}
void UpdateRoutesAfterSimplification(int i)
{
var skeletonLevel = _lgData.SkeletonLevels[i];
foreach (Edge edge in _lgData.Levels[i]._railsOfEdges.Keys)
{
LgNodeInfo s = _lgData.GeometryNodesToLgNodeInfos[edge.Source];
LgNodeInfo t = _lgData.GeometryNodesToLgNodeInfos[edge.Target];
List<Point> path = skeletonLevel.GetTrajectory(s, t);
if (path == null) continue;
int startedToSkip = 0;
for (int j = 1; j < path.Count - 1; j++)
{
if (skeletonLevel.PathRouter.ContainsVertex(path[j]))
{
if (startedToSkip > 0)
{
skeletonLevel.PathRouter.MarkEdgeUsed(path[startedToSkip - 1], path[j]);
startedToSkip = 0;
}
continue;
}
path.RemoveAt(j);
if (startedToSkip == 0) startedToSkip = j;
j--;
}
if (startedToSkip > 0)
skeletonLevel.PathRouter.MarkEdgeUsed(path[startedToSkip - 1], path.Last());
if (!EdgeIsNew(s, t, i))
{
skeletonLevel.MarkEdgesAlongPathAsEdgesOnOldTrajectories(path);
}
}
}
bool TestTrajectoriesPreserved(int iLevel)
{
if (iLevel == 0) return true;
foreach (var st in _lgData.SkeletonLevels[iLevel - 1].EdgeTrajectories)
{
LgNodeInfo s = st.Key.A;
LgNodeInfo t = st.Key.B;
List<Point> oldPath = st.Value;
Point ps = oldPath.First();
List<Point> newPath = _lgData.SkeletonLevels[iLevel].GetTrajectory(s, t);
Debug.Assert(newPath.Count > 1);
if (!newPath.First().Equals(ps))
newPath.Reverse();
if (!newPath.First().Equals(ps))
{
Console.WriteLine("Endpoint of old path not found on new path!");
return false;
}
int i;
int j;
for (i = 1, j = 1; i < oldPath.Count; i++, j++)
{
var subdivEdge = new List<Point> { oldPath[i - 1] };
while (j < newPath.Count && !oldPath[i].Equals(newPath[j]))
{
subdivEdge.Add(newPath[j]);
j++;
}
if (j == newPath.Count || !oldPath[i].Equals(newPath[j]))
{
Console.WriteLine("Point of old path not found on new path!");
return false;
}
subdivEdge.Add(newPath[j]);
bool subdivEdgeIsLine = RectSegIntersection.ArePointsOnLine(subdivEdge);
if (subdivEdgeIsLine) continue;
Console.WriteLine("New path segment is not a line!");
return false;
}
}
return true;
}
/*
void TestTopRankedEdgeInfosOfTheRail(int iLevel) {
// sanity check
foreach (Edge edge in _lgData.Levels[iLevel]._railsOfEdges.Keys) {
Set<Rail> rails = _lgData.Levels[iLevel]._railsOfEdges[edge];
if (!rails.Any()) {
Console.WriteLine("Corrupt edge rail set");
}
foreach (Rail rail in rails) {
LgEdgeInfo ei = rail.TopRankedEdgeInfoOfTheRail;
if (ei == null) {
Console.WriteLine("Corrupt Rail");
}
if (!_lgData.Levels[iLevel].RailDictionary.ContainsValue(rail)) {
Console.WriteLine("used rail not in dictionary!");
}
}
}
}
*/
void CleanUpRails()
{
foreach (LgLevel level in _lgData.Levels)
{
var usedRails = new Set<Rail>();
foreach (var rails in level._railsOfEdges.Values)
{
usedRails.InsertRange(rails);
}
var unusedRails = new Set<Rail>(level._railDictionary.Values.Where(r => !usedRails.Contains(r)));
if (!unusedRails.Any()) continue;
foreach (Rail rail in unusedRails)
{
level.RemoveRailFromDictionary(rail);
level.RemoveRailFromRtree(rail);
}
}
}
void TestAllEdgesConsistency()
{
foreach (Edge edge in _mainGeometryGraph.Edges)
{
LgNodeInfo s = _lgData.GeometryNodesToLgNodeInfos[edge.Source];
LgNodeInfo t = _lgData.GeometryNodesToLgNodeInfos[edge.Target];
double zoomLevel = Math.Max(s.ZoomLevel, t.ZoomLevel);
int iLevel = GetIndexByZoomLevel(zoomLevel);
for (int i = iLevel; i < _lgData.Levels.Count; i++)
{
Set<Rail> rails = _lgData.Levels[i]._railsOfEdges[edge];
foreach (Rail rail in rails)
{
var rc = rail.Geometry as ICurve;
if (rc != null)
{
var ss = new SymmetricSegment(rc.Start, rc.End);
if (!_lgData.Levels[i]._railDictionary.ContainsKey(ss))
Debug.Assert(false, string.Format("rail {0} is not in the dictionary", rail));
}
}
}
}
}
/*
bool TestEdgeConsistency(Edge edge) {
LgNodeInfo s = _lgData.GeometryNodesToLgNodeInfos[edge.Source];
LgNodeInfo t = _lgData.GeometryNodesToLgNodeInfos[edge.Target];
LgEdgeInfo ei = GeometryEdgesToLgEdgeInfos[edge];
double zoomLevel = Math.Max(s.ZoomLevel, t.ZoomLevel);
if (ei.ZoomLevel != zoomLevel) {
Console.WriteLine("ZoomLevel not set!");
}
int iLevel = ViewModel.GetIndexByZoomLevel(zoomLevel);
for (int i = iLevel; i < _lgData.Levels.Count; i++) {
Set<Rail> rails = _lgData.Levels[i]._railsOfEdges[edge];
foreach (Rail rail in rails) {
if (!_lgData.SkeletonLevels[i].RailDictionary.ContainsValue(rail)) {
Console.WriteLine("used rail not in dictionary!");
}
}
}
return true;
}
*/
public void SelectAllColoredEdgesIncidentTo(LgNodeInfo nodeInfo, object color)
{
List<Edge> edges = nodeInfo.GeometryNode.Edges.ToList();
//START-jyoti to select only the neighbors within the current zoom level
List<Edge> filteredEdges = new List<Edge>();
Dictionary<Edge,object> reselectEdges = new Dictionary<Edge, object>();
foreach (Edge edge in edges)
{
//if (_lgData.GeometryNodesToLgNodeInfos[edge.Source].ZoomLevel > CurrentZoomLevel ||
// _lgData.GeometryNodesToLgNodeInfos[edge.Target].ZoomLevel > CurrentZoomLevel) continue;
//jyoti - user selects a and then the neighbor b of a is selected
// if the user deselect b, then we still need the edge (a,b) to be there.
// so reselect these edges.
if (_lgData.GeometryNodesToLgNodeInfos[edge.Source].Color != null &&
_lgData.GeometryNodesToLgNodeInfos[edge.Target].Color != null)
{
if (nodeInfo.GeometryNode.Center == edge.Source.Center)
reselectEdges[edge] = _lgData.GeometryNodesToLgNodeInfos[edge.Target].Color;
else reselectEdges[edge] =_lgData.GeometryNodesToLgNodeInfos[edge.Source].Color;
}
filteredEdges.Add(edge);
if (!nodeInfo.Selected)
{
edge.Color = nodeInfo.Color;
if(nodeInfo.GeometryNode.Center == edge.Source.Center)
_lgData.GeometryNodesToLgNodeInfos[edge.Target].SelectedNeighbor++; // = !nodeInfo.Selected;
else
_lgData.GeometryNodesToLgNodeInfos[edge.Source].SelectedNeighbor++; //= !nodeInfo.Selected;
}
else
{
if (nodeInfo.GeometryNode.Center == edge.Source.Center)
_lgData.GeometryNodesToLgNodeInfos[edge.Target].SelectedNeighbor--; // = !nodeInfo.Selected;
else
_lgData.GeometryNodesToLgNodeInfos[edge.Source].SelectedNeighbor--; //= !nodeInfo.Selected;
}
}
edges = filteredEdges;
//END-jyoti to select only the neighbors within the current zoom level
if (!nodeInfo.Selected)
_lgData.SelectEdges(edges);
else
{
_lgData.UnselectColoredEdges(edges, color);
//reselect the edges that have been deselected by the complcated case of "both endvertices selection"
foreach (Edge edge in reselectEdges.Keys)
edge.Color = reselectEdges[edge];
_lgData.SelectEdges(reselectEdges.Keys.ToList());
}
}
public void SelectAllEdgesIncidentTo(LgNodeInfo nodeInfo)
{
List<Edge> edges = nodeInfo.GeometryNode.Edges.ToList();
//START-jyoti to select only the neighbors within the current zoom level
List<Edge> filteredEdges = new List<Edge>();
foreach (Edge edge in edges)
{
//if (_lgData.GeometryNodesToLgNodeInfos[edge.Source].ZoomLevel > CurrentZoomLevel ||
// _lgData.GeometryNodesToLgNodeInfos[edge.Target].ZoomLevel > CurrentZoomLevel) continue;
filteredEdges.Add(edge);
if (!nodeInfo.Selected)
{
edge.Color = nodeInfo.Color;
// _lgData.GeometryNodesToLgNodeInfos[edge.Source].SelectedNeighbor++; //= !nodeInfo.Selected;
// _lgData.GeometryNodesToLgNodeInfos[edge.Target].SelectedNeighbor++; // = !nodeInfo.Selected;
}
else
{
// _lgData.GeometryNodesToLgNodeInfos[edge.Source].SelectedNeighbor--; //= !nodeInfo.Selected;
// _lgData.GeometryNodesToLgNodeInfos[edge.Target].SelectedNeighbor--; // = !nodeInfo.Selected;
}
}
edges = filteredEdges;
//END-jyoti to select only the neighbors within the current zoom level
if (!nodeInfo.Selected)
_lgData.SelectEdges(edges);
else
{
_lgData.UnselectEdges(edges);
}
}
public void UpdateVisibleEdgesIncidentTo(LgNodeInfo nodeInfo, int currentLayer)
{
List<Edge> edges = nodeInfo.GeometryNode.Edges.ToList();
int currentZoomFromLayer = Math.Max(0, currentLayer - 1);
//START-jyoti to select only the neighbors within the current zoom level
List<Edge> filteredEdges = new List<Edge>();
foreach (Edge edge in edges)
{
if (_lgData.GeometryNodesToLgNodeInfos[edge.Source].ZoomLevel <= currentZoomFromLayer &&
_lgData.GeometryNodesToLgNodeInfos[edge.Target].ZoomLevel <= currentZoomFromLayer)
filteredEdges.Add(edge);
}
edges = filteredEdges;
//END-jyoti to select only the neighbors within the current zoom level
if (nodeInfo.Selected)
_lgData.SelectEdges(edges, Math.Min(currentLayer, _lgLayoutSettings.maximumNumOfLayers));
}
public void SelectEdge(LgEdgeInfo ei)
{
var edges = new List<Edge> { ei.Edge };
_lgData.SelectEdges(edges);
}
public void DeselectAllEdges()
{
_lgData.PutOffAllEdges();
}
public void RunMds()
{
//DistributeUniformlyRandom();
//return;
var multipliers = new Dictionary<Tuple<Node, Node>, double>();
//foreach (var s in lgData.SortedLgNodeInfos)
//{
// foreach (var t in lgData.SortedLgNodeInfos)
// {
// if (s == t) continue;
// if (s.ZoomLevel < 2 && t.ZoomLevel < 2)
// multipliers.Add(new Tuple<Node, Node>(s.GeometryNode, t.GeometryNode), 10);
// }
//}
foreach (Edge e in GeometryEdgesToLgEdgeInfos.Keys)
{
LgNodeInfo s = _lgData.GeometryNodesToLgNodeInfos[e.Source];
LgNodeInfo t = _lgData.GeometryNodesToLgNodeInfos[e.Target];
double zoomLevel = Math.Max(s.ZoomLevel, t.ZoomLevel);
if (zoomLevel < 5)
{
double mult = 10; // = Math.Pow(10, lgData.Levels.Last().ZoomLevel - zoomLevel);
multipliers.Add(new Tuple<Node, Node>(s.GeometryNode, t.GeometryNode), mult);
e.Length = 3;
//Math.Pow(1.5, lgData.Levels.Last().ZoomLevel - zoomLevel); //lgData.Levels.Last().ZoomLevel - zoomLevel + 1;
//Math.Pow(2, lgData.Levels.Last().ZoomLevel - zoomLevel);
}
//else if(Math.Min(s.ZoomLevel, t.ZoomLevel) < 2)
//{
// e.Length = 0.1;
//}
}
var settings = new MdsLayoutSettings { ScaleX = 600, ScaleY = 600, RunInParallel = false, PivotNumber = 100 };
//var mds = new MDSGraphLayoutWeighted(settings, mainGeometryGraph, multipliers);
var mds = new MdsGraphLayout(settings, _mainGeometryGraph);
mds.Run();
}
public void SelectTopEdgePassingThroughRailWithEndpoint(Rail rail, Set<LgNodeInfo> selectedVnodes)
{
List<Edge> edges =
GetEdgesPassingThroughRail(rail)
.Where(e => selectedVnodes.Contains(_lgData.GeometryNodesToLgNodeInfos[e.Source])
|| selectedVnodes.Contains(_lgData.GeometryNodesToLgNodeInfos[e.Target])).ToList();
if (!edges.Any()) return;
DeselectAllEdges();
Edge edge = edges.OrderByDescending(e => _lgData.GeometryEdgesToLgEdgeInfos[e].Rank).First();
SelectEdge(_lgData.GeometryEdgesToLgEdgeInfos[edge]);
}
Rectangle GetLabelRectForScale(LgNodeInfo nodeInfo, double scale)
{
double labelHeight = _lgLayoutSettings.NodeLabelHeightInInches * _lgLayoutSettings.DpiX / scale /
FitFactor();
double labelWidth = labelHeight * nodeInfo.LabelWidthToHeightRatio;
double nodeDotWidth = GetNodeDotRect(nodeInfo, scale).Width;
//_lgLayoutSettings.NodeDotWidthInInches * _lgLayoutSettings.DpiX / currentScale;
Point offset = Point.Scale(labelWidth + nodeDotWidth * 1.01, labelHeight + nodeDotWidth * 1.01,
nodeInfo.LabelOffset);
double overlapScale = 0.7;
var d = new Point(0.5 * labelWidth, 0.5 * labelHeight) * overlapScale;
return new Rectangle(nodeInfo.Center + offset - d, nodeInfo.Center + offset + d);
}
Rectangle GetLabelRectForScale(LgNodeInfo nodeInfo, LgNodeInfo.LabelPlacement placement, double scale)
{
double labelHeight = _lgLayoutSettings.NodeLabelHeightInInches * _lgLayoutSettings.DpiX / scale /
FitFactor();
double labelWidth = labelHeight * nodeInfo.LabelWidthToHeightRatio;
double nodeDotWidth = GetNodeDotRect(nodeInfo, scale).Width;
//_lgLayoutSettings.NodeDotWidthInInches * _lgLayoutSettings.DpiX / currentScale;
Point offset = Point.Scale(labelWidth + nodeDotWidth * 1.01, labelHeight + nodeDotWidth * 1.01,
LgNodeInfo.GetLabelOffset(placement));
var d = new Point(0.5 * labelWidth, 0.5 * labelHeight);
return new Rectangle(nodeInfo.Center + offset - d, nodeInfo.Center + offset + d);
}
Rectangle GetNodeDotRect(LgNodeInfo node, double scale)
{
var rect = new Rectangle(node.Center);
rect.Pad(NodeDotWidth(scale) / 2);
return rect;
}
double NodeDotWidth(double scale)
{
return _lgLayoutSettings.NodeDotWidthInInches * _lgLayoutSettings.DpiX / scale / FitFactor();
}
private void InsertCandidateLabelsGreedily(List<LgNodeInfo> candidates, double _scale)
{
var scale = CurrentZoomLevel;
var labelRTree = new RTree<LgNodeInfo>();
// insert all nodes inserted before
foreach (var node in _railGraph.Nodes)
{
var ni = _lgData.GeometryNodesToLgNodeInfos[node];
// add all node dots
labelRTree.Add(GetNodeDotRect(ni, scale), ni);
if (ni.LabelVisibleFromScale <= scale)
{
Rectangle labelRect = GetLabelRectForScale(ni, scale);
labelRTree.Add(labelRect, ni);
}
}
foreach (LgNodeInfo node in candidates)
{
if (node.LabelVisibleFromScale <= scale)
{
// already inserted before
continue;
}
LgNodeInfo.LabelPlacement[] positions =
{
LgNodeInfo.LabelPlacement.Bottom,
LgNodeInfo.LabelPlacement.Right,
LgNodeInfo.LabelPlacement.Left,
LgNodeInfo.LabelPlacement.Top
};
bool couldPlace = false;
var labelRect = new Rectangle();
LgNodeInfo.LabelPlacement pl = LgNodeInfo.LabelPlacement.Bottom;
foreach (LgNodeInfo.LabelPlacement placement in positions)
{
pl = placement;
labelRect = GetLabelRectForScale(node, pl, scale);
if (!labelRTree.IsIntersecting(labelRect))
{
couldPlace = true;
break;
}
}
if (couldPlace)
{
labelRTree.Add(labelRect, node);
SelectedNodeLabels[node] = pl;
}
}
}
int InsertLabelsGreedily(double scale)
{
int labeledNodes = 0;
int iLevel = 0;
while (iLevel < _lgData.Levels.Count - 1 && scale >= _lgData.Levels[iLevel].ZoomLevel)
{
iLevel++;
}
var nodes = GetNodeInfosOnLevelLeq(iLevel);
var labelRTree = new RTree<LgNodeInfo>();
var skippedRTree = new RTree<LgNodeInfo>();
// insert all nodes inserted before
foreach (LgNodeInfo node in nodes)
{
// add all node dots
labelRTree.Add(GetNodeDotRect(node, scale), node);
if (node.LabelVisibleFromScale > 0 && node.LabelVisibleFromScale < scale)
{
Rectangle labelRect = GetLabelRectForScale(node, scale);
labelRTree.Add(labelRect, node);
labeledNodes++;
}
}
foreach (LgNodeInfo node in nodes)
{
if (node.LabelVisibleFromScale > 0 && node.LabelVisibleFromScale < scale)
{
// already inserted before
continue;
}
LgNodeInfo.LabelPlacement[] positions =
{
LgNodeInfo.LabelPlacement.Bottom,
LgNodeInfo.LabelPlacement.Right,
LgNodeInfo.LabelPlacement.Left,
LgNodeInfo.LabelPlacement.Top
};
bool couldPlace = false;
var labelRect = new Rectangle();
foreach (LgNodeInfo.LabelPlacement placement in positions)
{
node.LabelPosition = placement;
labelRect = GetLabelRectForScale(node, scale);
if (!labelRTree.IsIntersecting(labelRect))
{
couldPlace = true;
break;
}
}
// uncomment: insert no labels until Johann Sebastian Bach can be labeled
if (!couldPlace) break;
// finally, test if inserting would overlap too much important skipped nodes
if (couldPlace)
{
var overlappedSkipped = skippedRTree.GetAllIntersecting(labelRect);
if (overlappedSkipped.Any())
{
if (DoesOverlapTooManyImportant(node, overlappedSkipped))
{
couldPlace = false;
}
}
}
if (!couldPlace)
{
node.LabelVisibleFromScale = 0;
skippedRTree.Add(labelRect, node);
}
else
{
if (node.LabelVisibleFromScale <= 0)
node.LabelVisibleFromScale = scale;
labelRTree.Add(labelRect, node);
labeledNodes++;
}
}
return labeledNodes;
}
private bool DoesOverlapTooManyImportant(LgNodeInfo node, IEnumerable<LgNodeInfo> overlappedNodes)
{
// rank high == important
double nodeWeight = node.Rank;
double overlappedWeight = overlappedNodes.Sum(n => n.Rank);
return nodeWeight * 20.0 < overlappedWeight;
}
class RankComparer : IComparer<Node> {
readonly Dictionary<Node, LgNodeInfo> _table;
public RankComparer(Dictionary<Node, LgNodeInfo> geometryNodesToLgNodeInfos)
{
_table = geometryNodesToLgNodeInfos;
}
public int Compare(Node a, Node b)
{
return _table[b].Rank.CompareTo(_table[a].Rank);
}
}
public bool RectIsEmptyStartingFromLevel(Rectangle tileBox, int iLevel)
{
for (int i = iLevel; i < _lgData.Levels.Count; i++)
{
if (!_lgData.Levels[i].RectIsEmptyOnLevel(tileBox))
return false;
}
return true;
}
public int GetNumberOfLevels()
{
return _lgData.Levels.Count;
}
LgNodeInfo FindClosestNodeInfoForMouseClickOnLevel(Point mouseDownPositionInGraph, int iLevel)
{
if (iLevel >= _lgData.Levels.Count) return null;
var level = _lgData.Levels[iLevel];
var hitRectWidth = NodeDotWidth(CurrentZoomLevel) / 2;
var rect = new Rectangle(new Size(hitRectWidth, hitRectWidth), mouseDownPositionInGraph);
var intersected = level.NodeInfoTree.GetAllIntersecting(rect);
if (!intersected.Any()) return null;
double dist = double.PositiveInfinity;
LgNodeInfo closest = null;
foreach (var ni in intersected)
{
var t = (ni.Center - mouseDownPositionInGraph).LengthSquared;
if (t < dist)
{
dist = t;
closest = ni;
}
}
return closest;
}
LgNodeInfo FindClosestNodeInfoForMouseClickBelowCurrentLevel(Point mouseDownPositionInGraph)
{
var iLevel = _lgData.GetLevelIndexByScale(CurrentZoomLevel);
for (int i = iLevel + 1; i < _lgData.LevelNodeCounts.Count; i++)
{
LgNodeInfo closest = FindClosestNodeInfoForMouseClickOnLevel(mouseDownPositionInGraph, i);
if (closest != null) return closest;
}
return null;
}
public void AnalyzeClick(Point mouseDownPositionInGraph, int downCount)
{
var closest = FindClosestNodeInfoForMouseClickBelowCurrentLevel(mouseDownPositionInGraph);
if (closest == null) return;
SelectAllEdgesIncidentTo(closest);
var edges = closest.GeometryNode.Edges.ToList();
_railGraph.Edges.InsertRange(edges);
closest.Selected = true;
_lgData.SelectedNodeInfos.Insert(closest);
_railGraph.Nodes.Insert(closest.GeometryNode);
RunOnViewChange();
}
public Node AnalyzeClickForInvisibleNode(Point mouseDownPositionInGraph, int downCount)
{
var closest = FindClosestNodeInfoForMouseClickBelowCurrentLevel(mouseDownPositionInGraph);
if (closest == null) return null;
SelectAllEdgesIncidentTo(closest);
var edges = closest.GeometryNode.Edges.ToList();
_railGraph.Edges.InsertRange(edges);
closest.Selected = true;
_lgData.SelectedNodeInfos.Insert(closest);
_railGraph.Nodes.Insert(closest.GeometryNode);
RunOnViewChange();
return closest.GeometryNode;
}
public bool NumberOfNodesOfLastLayerIntersectedRectIsLessThanBound(int iLevel, Rectangle rect, int bound)
{
int lastLevel = GetNumberOfLevels() - 1;
var level = _lgData.Levels[lastLevel];
var zoom = Math.Pow(2, iLevel);
return level.NodeInfoTree.NumberOfIntersectedIsLessThanBound(rect, bound, node => node.ZoomLevel > zoom);
}
public bool TileIsEmpty(Rectangle rectangle)
{
int lastLevel = GetNumberOfLevels() - 1;
var level = _lgData.Levels[lastLevel];
LgNodeInfo t;
return !level.NodeInfoTree.OneIntersecting(rectangle, out t);
}
public IEnumerable<Node> GetTileNodes(Tuple<int, int, int> tile)
{
var grid = new GridTraversal(this._mainGeometryGraph.BoundingBox, tile.Item1);
var rect = grid.GetTileRect(tile.Item2, tile.Item3);
return
_lgData.Levels[GetNumberOfLevels() - 1].NodeInfoTree.GetAllIntersecting(rect)
.Select(nodeInfo => nodeInfo.GeometryNode);
}
}
}
Reference in a new issue View git blame Copy permalink