void RunShortestPathsToEveryOtherNode(LgNodeInfo lgNodeInfo)
{
var shortestPathToAllOthers = new ShortestPathToAllOthers(lgNodeInfo,
lgData.GeometryNodesToLgNodeInfos);
shortestPathToAllOthers.Run();
}
internal List <Point> GetPathOnSavedTrajectory(LgNodeInfo s, LgNodeInfo t, List <Point> trajectory,
bool shrinkDistances)
{
if (trajectory == null || trajectory.Count < 2)
{
return(GetPath(s, t, true));
}
var path = new List <Point> {
trajectory[0]
};
for (int i = 0; i < trajectory.Count - 1; i++)
{
var p0 = trajectory[i];
var p1 = trajectory[i + 1];
var refinedPath = GetPointsOfVerticesOverlappingSegment(p0, p1);
for (int j = 1; j < refinedPath.Count; j++)
{
path.Add(refinedPath[j]);
}
}
return(path);
}
void ProcessEdge(Edge edge, LgNodeInfo otherVert, double cost)
{
if (otherVert.Processed)
{
return;
}
var len = (edge.Source.Center - edge.Target.Center).Length;
double newCost = len + cost;
if (newCost >= otherVert.Cost)
{
return;
}
otherVert.Prev = edge;
if (otherVert.Cost == double.PositiveInfinity)
{
otherVert.Cost = newCost;
q.Enqueue(otherVert, newCost);
}
else
{
otherVert.Cost = newCost;
q.DecreasePriority(otherVert, newCost);
}
}
void AddNodeBoundaryToPointIndices(LgNodeInfo ni)
{
foreach (var polylinePoint in ni.BoundaryOnLayer.PolylinePoints)
{
IndexAPoint(polylinePoint.Point);
}
}
void AddVisibleNode(LgNodeInfo nodeInfo)
{
if (nodeInfo.ZoomLevel <= CurrentZoomLevel)
{
AddFullyVisibleNodeToRailGraph(nodeInfo);
}
else if (nodeInfo.ZoomLevel <= CurrentZoomLevel * lgLayoutSettings.SattelliteZoomFactor)
{
visibleNodeSet.Insert(nodeInfo);
nodeInfo.Kind = LgNodeInfoKind.Satellite;
nodeInfo.Scale = FigureOutSatelliteScale(nodeInfo);
AddAllParentsToOpenNodes(nodeInfo.GeometryNode);
// foreach (var cluster in nodeInfo.GeometryNode.AllClusterAncestors) {
// if (cluster == geometryGraph.RootCluster) continue;
// var clusterInfo = lgData.GeometryNodesToLgNodeInfos[cluster];
// if (clusterInfo.ZoomLevel <= CurrentZoomLevel) {
// OpenNodeInfosSet.Insert(clusterInfo);
// clusterInfo.IsOpen = true;
// } else {
// SatelliteSet.Insert(clusterInfo);
// }
// }
}
else
{
lgLayoutSettings.BackgroundImageIsHidden = false;
}
}
Dictionary <VisibilityEdge, VisibilityVertex> GetEdgeSnapAtVertexMap(LgNodeInfo nodeInfo)
{
var ret = new Dictionary <VisibilityEdge, VisibilityVertex>();
var center = nodeInfo.Center;
RbTree <VisibilityVertex> nodeBoundaryRbTree =
new RbTree <VisibilityVertex>((a, b) => CompareByAngleFromNodeCenter(a, b, center));
foreach (var p in nodeInfo.BoundaryOnLayer)
{
nodeBoundaryRbTree.Insert(_visGraph.AddVertex(p));
}
var nodeInfoCenterV = VisGraph.FindVertex(center);
if (nodeInfoCenterV == null)
{
return(ret);
}
foreach (var e in nodeInfoCenterV.OutEdges)
{
SnapToAfterBefore(e.Target, nodeBoundaryRbTree, center, ret, e);
}
foreach (var e in nodeInfoCenterV.InEdges)
{
SnapToAfterBefore(e.Source, nodeBoundaryRbTree, center, ret, e);
}
return(ret);
}
public static void ScaleNode(LgNodeInfo node, double xScale, double yScale)
{
var delta = node.BoundingBox.Center;
node.GeometryNode.BoundaryCurve.Translate(-delta);
node.GeometryNode.BoundaryCurve = node.GeometryNode.BoundaryCurve.ScaleFromOrigin(xScale, yScale);
node.GeometryNode.BoundaryCurve.Translate(delta);
}
void AddFullyVisibleNodeToRailGraph(LgNodeInfo nodeInfo)
{
// Debug.Assert(nodeInfo.IsOpen == false);
nodeInfo.Kind = LgNodeInfoKind.FullyVisible;
visibleNodeSet.Insert(nodeInfo);
nodeInfo.Scale = 1;
AddAllParentsToOpenNodes(nodeInfo.GeometryNode);
}
void WriteLgNodeInfo(LgNodeInfo lgNodeInfo)
{
WriteStartElement(GeometryToken.LgNodeInfo);
WriteAttribute(GeometryToken.Id, nodeIds[lgNodeInfo.GeometryNode]);
WriteAttribute(GeometryToken.Rank, lgNodeInfo.Rank);
WriteAttribute(GeometryToken.Zoomlevel, lgNodeInfo.ZoomLevel);
WriteEndElement();
}
internal List <Point> GetTrajectory(LgNodeInfo s, LgNodeInfo t)
{
List <Point> path;
var tuple = new SymmetricTuple <LgNodeInfo>(s, t);
EdgeTrajectories.TryGetValue(tuple, out path);
return(path);
}
void AddNodeToInserted(LgNodeInfo ni)
{
_insertedNodes.Add(ni);
var rect = new Rectangle(ni.Center, ni.Center);
_insertedNodesTree.Add(rect, ni);
_insertedNodeRectsTree.Add(rect, rect);
}
internal List <Point> GetPath(LgNodeInfo s, LgNodeInfo t, bool shrinkDistances, Tiling g)
{
var vs = VisGraph.FindVertex(g.nodeToLoc[s.GeometryNode]);
Debug.Assert(vs != null);
var vt = VisGraph.FindVertex(g.nodeToLoc[t.GeometryNode]);
Debug.Assert(vt != null);
return(GetPath(vs, vt, shrinkDistances, g));
}
internal List <Point> GetPath(LgNodeInfo s, LgNodeInfo t, bool shrinkDistances)
{
var vs = VisGraph.FindVertex(s.Center);
Debug.Assert(vs != null);
var vt = VisGraph.FindVertex(t.Center);
Debug.Assert(vt != null);
return(GetPath(vs, vt, shrinkDistances));
}
static void SortPointByAngles(LgNodeInfo nodeInfo, Point[] polySplitArray)
{
var angles = new double[polySplitArray.Length];
for (int i = 0; i < polySplitArray.Length; i++)
{
angles[i] = Point.Angle(new Point(1, 0), polySplitArray[i] - nodeInfo.Center);
}
Array.Sort(angles, polySplitArray);
}
double FigureOutSatelliteScale(LgNodeInfo satellite)
{
var lower = satellite.ZoomLevel / lgLayoutSettings.SattelliteZoomFactor;
var upper = satellite.ZoomLevel;
return(Math.Sqrt(0.8 * (CurrentZoomLevel - lower) / (upper - lower) + 0.2));
// Debug.Assert(0 <= a && a <= 1);
// var ret = a + (1.0 - a)*0.1;
// return ret;
}
void WriteLgNodeInfo(LgNodeInfo lgNodeInfo)
{
WriteStartElement(GeometryToken.LgNodeInfo);
WriteAttribute(GeometryToken.Id, nodeIds[lgNodeInfo.GeometryNode]);
WriteAttribute(GeometryToken.Rank, lgNodeInfo.Rank);
WriteAttribute(GeometryToken.Zoomlevel, lgNodeInfo.ZoomLevel);
WriteAttribute(GeometryToken.LabelVisibleFromScale, lgNodeInfo.LabelVisibleFromScale);
WriteAttribute(GeometryToken.LabelOffset, lgNodeInfo.LabelOffset);
WriteAttribute(GeometryToken.LabelWidthToHeightRatio, lgNodeInfo.LabelWidthToHeightRatio);
WriteEndElement();
}
internal void SetTrajectoryAndAddEdgesToUsed(LgNodeInfo s, LgNodeInfo t, List <Point> path)
{
var t1 = new SymmetricTuple <LgNodeInfo>(s, t);
if (_edgeTrajectories.ContainsKey(t1))
{
return;
}
_edgeTrajectories[t1] = path;
PathRouter.MarkEdgesUsedAlongPath(path);
}
internal void AddVisGraphEdgesFromNodeCenterToNodeBorder(LgNodeInfo nodeInfo)
{
var vc = VisGraph.AddVertex(nodeInfo.Center);
vc.IsTerminal = true; // we don't need to register this node in the tree
foreach (var pt in nodeInfo.BoundaryOnLayer.PolylinePoints)
{
var vv = GetOrFindVisibilityVertex(pt.Point);
var edge = VisibilityGraph.AddEdge(vc, vv);
edge.IsPassable = () => EdgeIsPassable(edge);
}
}
Set <LgNodeInfo> GetAdjacentProcessed(LgNodeInfo ni)
{
var nodes = new Set <LgNodeInfo>(from edge in ni.GeometryNode.Edges
let s = GeometryNodesToLgNodeInfos[edge.Source]
let t = GeometryNodesToLgNodeInfos[edge.Target]
select ni == s ? t : s
into v
where v.Processed
select v);
return(nodes);
}
void ProcessNode(LgNodeInfo nodeInfo)
{
nodeInfo.Processed = true;
foreach (Edge edge in nodeInfo.GeometryNode.OutEdges)
{
ProcessEdge(edge, geometryNodesToLgNodes[edge.Target], nodeInfo.Cost);
}
foreach (Edge edge in nodeInfo.GeometryNode.InEdges)
{
ProcessEdge(edge, geometryNodesToLgNodes[edge.Source], nodeInfo.Cost);
}
}
public ShortestPathToAllOthers(LgNodeInfo source,
Dictionary <Node, LgNodeInfo> geometryNodesToLgNodes)
{
this.source = source;
this.geometryNodesToLgNodes = geometryNodesToLgNodes;
foreach (var lgNodeInfo in geometryNodesToLgNodes.Values)
{
lgNodeInfo.Cost = double.PositiveInfinity;
lgNodeInfo.InQueue = false;
lgNodeInfo.Processed = false;
lgNodeInfo.Prev = null;
}
}
bool GettingTooCloseToNode(LgNodeInfo lgNodeInfo, Point a, Point b)
{
var center = lgNodeInfo.Center;
if (a == center || b == center)
{
return(false);
}
var closestPoint = Point.ClosestPointAtLineSegment(center, a, b);
var where = Curve.PointRelativeToCurveLocation(closestPoint, lgNodeInfo.BoundaryOnLayer);
return(where == PointLocation.Inside);
}
void IncludeEdgeFromShortestPathTree(LgNodeInfo lgNodeInfo)
{
for (int i = 0; i < _nodeCountOnLevel; i++)
{
var otherNodeInfo = nodeZoomLevelCalculator.SortedLgNodeInfos[i];
if (lgNodeInfo != otherNodeInfo)
{
var edgeRank = lgNodeInfo.Rank + otherNodeInfo.Rank;
foreach (var e in EdgesOfPath(lgNodeInfo, otherNodeInfo))
{
UpdateEdgeInfoZoomLevel(e, edgeRank);
}
}
}
}
IEnumerable <Edge> EdgesOfPath(LgNodeInfo a, LgNodeInfo b)
{
if (b.Prev == null)
{
yield break;
}
do
{
var e = b.Prev;
yield return(e);
b = e.Source == b.GeometryNode
? lgData.GeometryNodesToLgNodeInfos[e.Target]
: lgData.GeometryNodesToLgNodeInfos[e.Source];
} while (b != a);
}
void RegisterPathEdgeNode(Node node)
{
LgNodeInfo nodeInfo = lgData.GeometryNodesToLgNodeInfos[node];
if (nodeInfo.Kind == LgNodeInfoKind.FullyVisible)
{
return;
}
if (node is Cluster)
{
AddFullyVisibleNodeToRailGraph(lgData.GeometryNodesToLgNodeInfos[node]);
return;
}
nodeInfo.Kind = LgNodeInfoKind.PathNode;
visibleNodeSet.Insert(nodeInfo);
AddAllParentsToOpenNodes(node);
}
internal void ModifySkeletonWithNewBoundaryOnLayer(LgNodeInfo nodeInfo)
{
Dictionary <VisibilityEdge, VisibilityVertex> edgeSnapMap = GetEdgeSnapAtVertexMap(nodeInfo);
foreach (var t in edgeSnapMap)
{
VisibilityEdge edge = t.Key;
VisibilityGraph.RemoveEdge(edge);
var midleV = edgeSnapMap[edge];
if (nodeInfo.Center != edge.SourcePoint)
{
VisibilityGraph.AddEdge(edge.Source, midleV);
}
else
{
VisibilityGraph.AddEdge(midleV, edge.Target);
}
}
}
bool GettingTooCloseToNode(LgNodeInfo lgNodeInfo, Point a, Point b)
{
var center = lgNodeInfo.Center;
if (a == center || b == center)
{
return(false);
}
var closestPoint = Point.ClosestPointAtLineSegment(center, a, b);
var where = Curve.PointRelativeToCurveLocation(closestPoint, lgNodeInfo.BoundaryOnLayer);
return(where == PointLocation.Inside);
/*
* LayoutAlgorithmSettings.ShowDebugCurves(
* new Microsoft.Msagl.DebugHelpers.DebugCurve(100, 0.1, "blue", lgNodeInfo.BoundaryOnLayer),
* new DebugHelpers.DebugCurve(100, 0.1, "red", new LineSegment(a, b)));
*
* return true; // the intersection is not at the end of the [a,b]
*/
}
internal VNode(Node node, LgNodeInfo lgNodeInfo, FrameworkElement frameworkElementOfNodeForLabelOfLabel,
Func <Edge, VEdge> funcFromDrawingEdgeToVEdge, Func <double> pathStrokeThicknessFunc)
{
PathStrokeThicknessFunc = pathStrokeThicknessFunc;
LgNodeInfo = lgNodeInfo;
Node = node;
FrameworkElementOfNodeForLabel = frameworkElementOfNodeForLabelOfLabel;
this.funcFromDrawingEdgeToVEdge = funcFromDrawingEdgeToVEdge;
CreateNodeBoundaryPath();
if (FrameworkElementOfNodeForLabel != null)
{
FrameworkElementOfNodeForLabel.Tag = this; //get a backpointer to the VNode
Common.PositionFrameworkElement(FrameworkElementOfNodeForLabel, node.GeometryNode.Center, 1);
Panel.SetZIndex(FrameworkElementOfNodeForLabel, Panel.GetZIndex(BoundaryPath) + 1);
}
SetupSubgraphDrawing();
Node.GeometryNode.BeforeLayoutChangeEvent += GeometryNodeBeforeLayoutChangeEvent;
Node.Attr.VisualsChanged += (a, b) => Invalidate();
}
internal bool HasSavedTrajectory(LgNodeInfo s, LgNodeInfo t)
{
var t1 = new SymmetricTuple <LgNodeInfo>(s, t);
return(EdgeTrajectories.ContainsKey(t1));
}
void PerformNodeInsertion(LgNodeInfo node, Tuple <int, int> tile)
{
_nodeTileTable[tile]++;
AddNodeToInserted(node);
//orb.DrawDilated(node.BoundingBox);
}
