static void RouteEdges(LgLayoutSettings lgLayoutSettings,
GeometryGraph tmpGraphForRouting,
LgData lgData,
LgLevel level)
{
int routedEdges = 0;
Console.WriteLine("\nrouting for level {0}", level.ZoomLevel);
var router = new SplineRouter(tmpGraphForRouting, lgLayoutSettings.EdgeRoutingSettings.Padding,
lgLayoutSettings.EdgeRoutingSettings.PolylinePadding, Math.PI / 6,
null)
{
RouteMultiEdgesAsBundles = false,
UseEdgeLengthMultiplier = true,
UsePolylineEndShortcutting = false,
UseInnerPolylingShortcutting = false,
// LineSweeperPorts = GetLineSweeperPorts(tmpGraphForRouting, tileSize),
AllowedShootingStraightLines = false,
ContinueOnOverlaps = true,
CacheCornersForSmoothing = true,
ReplaceEdgeByRails =
e => {
routedEdges++;
if (routedEdges % 1000 == 0)
{
Console.Write(".");
}
level.RegisterRailsOfEdge(lgData.GeometryEdgesToLgEdgeInfos[e]);
},
Bidirectional = true
}; //new BundlingSettings {KeepOverlaps = true, EdgeSeparation = 0, StopAfterShortestPaths = true});
router.Run();
level.CreateRailTree();
foreach (var edge in tmpGraphForRouting.Edges)
{
level.FillRailDictionaryForEdge(edge);
edge.Curve = null;
}
// level.RunLevelStatistics(lgData.GeometryNodesToLgNodeInfos.Where(e=>e.Value.ZoomLevel<=level.ZoomLevel).Select(p=>p.Key));
}
void WriteRailsGeometry(LgLevel level, Dictionary<Rail, int> railIds) {
WriteStartElement(GeometryToken.Rails);
foreach (var rail in level._railDictionary.Values)
WriteRail(rail, railIds[rail]);
WriteEndElement();
}
void WriteLevelRails(LgLevel level, Dictionary<Rail, int> railIds) {
WriteStartElement(GeometryToken.RailsPerEdge);
foreach (var t in level._railsOfEdges) {
WriteEdgeRails(t.Key, t.Value, railIds);
}
WriteEndElement();
WriteRailsGeometry(level, railIds);
}
void WriteLevel(LgLevel level, Dictionary<Rail, int> railsToIds, int nodeCountOnLevel) {
WriteStartElement(GeometryToken.Level);
WriteAttribute(GeometryToken.NodeCountOnLevel, nodeCountOnLevel);
WriteAttribute(GeometryToken.Zoomlevel, level.ZoomLevel);
WriteLevelRails(level, railsToIds);
WriteEndElement();
}
internal LgLevel AddLevel() {
int zoomLevel = (int) Math.Pow(2, _levels.Count());
var level = new LgLevel(zoomLevel, mainGeomGraph);
_levels.Add(level);
return level;
}
Set<Rail> GetRailsThatShouldBeHighlighted(LgLevel level, Set<Edge> edgesToPutOff) {
var ret = new Set<Rail>();
foreach (var edge in SelectedEdges) {
if (edgesToPutOff.Contains(edge)) continue;
Set<Rail> railsOfEdge;
if (level._railsOfEdges.TryGetValue(edge, out railsOfEdge)) {
ret.InsertRange(railsOfEdge);
}
}
return ret;
}
static bool RailBelongsToLevel(LgLevel level, Rail rail) {
return level.ZoomLevel >= rail.ZoomLevel;
}
/*
void HiglightEdge(Edge edge) {
Set<Rail> railsOfEdge = null;
//adding highlight for edge rails in each level
for (int i = levels.Count - 1; i >= 0; i--) {
var level = levels[i];
Set<Rail> railsOfEdgeOfLevelWithHigherZoom;
if (level._railsOfEdges.TryGetValue(edge, out railsOfEdgeOfLevelWithHigherZoom)) {
railsOfEdge = railsOfEdgeOfLevelWithHigherZoom;
}
else {
//the edge is not represented at the level, so we are reusing the rails from the level above
level._railsOfEdges[edge] = railsOfEdge;
foreach (var rail1 in railsOfEdge)
AddRailToRailTreeOfLowerLevel(rail1, level);
}
foreach (var rail1 in railsOfEdge) //highlight every rail: does not matter new or old
rail1.HiglightCount ++;
}
}
*/
static void AddRailToRailTreeOfLowerLevel(Rail rail, LgLevel lowerLevel) {
var pt = rail.PointTuple();
var box = new Rectangle(pt.Item1, pt.Item2);
if (!lowerLevel._railTree.Contains(box, rail))
lowerLevel._railTree.Add(box, rail);
}
static void TransferHighlightedRails(LgLevel level, Edge edge, Set<Rail> railsOfEdge) {
//need to remove those rails later, when putting them off
foreach (var rail in railsOfEdge)
AddRailToRailTreeOfLowerLevel(rail, level);
level._railsOfEdges[edge] = railsOfEdge;
level.HighlightedRails.InsertRange(railsOfEdge);
}
Rail ContinueReadingRail(LgEdgeInfo topRankedEdgoInfo, int zoomLevel, LgLevel level) {
XmlRead();
string pointString;
if (TokenIs(GeometryToken.Arrowhead)) {
Point arrowheadPosition = TryGetPointAttribute(GeometryToken.ArrowheadPosition);
Point attachmentPoint = TryGetPointAttribute(GeometryToken.CurveAttachmentPoint);
Arrowhead ah = new Arrowhead {
TipPosition = arrowheadPosition,
Length = (attachmentPoint - arrowheadPosition).Length
};
XmlRead();
ReadEndElement();
var rail = new Rail(ah, attachmentPoint, topRankedEdgoInfo, zoomLevel);
var tuple = new SymmetricSegment(arrowheadPosition, attachmentPoint);
level._railDictionary[tuple] = rail;
return rail;
}
if (TokenIs(GeometryToken.LineSegment)) {
pointString = GetAttribute(GeometryToken.Points);
var linePoints = ParsePoints(pointString);
Debug.Assert(linePoints.Length == 2);
LineSegment ls = new LineSegment(linePoints[0], linePoints[1]);
XmlRead();
ReadEndElement();
var rail = new Rail(ls, topRankedEdgoInfo, zoomLevel);
var tuple = new SymmetricSegment(ls.Start, ls.End);
level._railDictionary[tuple] = rail;
level._railTree.Add(ls.BoundingBox, rail);
return rail;
}
if (TokenIs(GeometryToken.CubicBezierSegment)) {
pointString = GetAttribute(GeometryToken.Points);
var controlPoints = ParsePoints(pointString);
Debug.Assert(controlPoints.Length == 4);
var bs = new CubicBezierSegment(controlPoints[0], controlPoints[1], controlPoints[2], controlPoints[3]);
XmlRead();
ReadEndElement();
var rail = new Rail(bs, topRankedEdgoInfo, zoomLevel);
var tuple = new SymmetricSegment(bs.Start, bs.End);
level._railDictionary[tuple] = rail;
return rail;
}
throw new Exception();
}
void ReadRail(LgLevel level) {
string railId = GetAttribute(GeometryToken.Id);
int zoomLevel = (int) GetDoubleAttribute(GeometryToken.Zoomlevel);
double minPassigEdgeZoomLevel =
(double) GetDoubleAttributeOrDefault(GeometryToken.MinPassingEdgeZoomLevel, zoomLevel);
var topRankedEdgoInfo = GetTopRankedEdgeInfoOfRail(railId);
Rail rail = ContinueReadingRail(topRankedEdgoInfo, zoomLevel, level);
rail.MinPassingEdgeZoomLevel = minPassigEdgeZoomLevel;
idToRails[railId] = rail;
}
void ReadRails(LgLevel level) {
//CheckToken(GeometryToken.Rails);
//XmlRead();
//while (TokenIs(GeometryToken.Rail)) {
// ReadRail(level);
//}
CheckToken(GeometryToken.Rails);
if (XmlReader.IsEmptyElement) {
XmlRead();
return;
}
XmlRead();
while (TokenIs(GeometryToken.Rail)) {
ReadRail(level);
}
ReadEndElement();
}
void FillRailsOfEdges(LgLevel level, Dictionary<string, Set<string>> edgeIdToEdgeRailsSet) {
foreach (var edgeRails in edgeIdToEdgeRailsSet) {
var edge = idToEdges[edgeRails.Key];
var railSet = new Set<Rail>(edgeRails.Value.Where(s => s != "").Select(r => idToRails[r]));
level._railsOfEdges[edge] = railSet;
}
}
void ReadLevel(LgData lgData, int zoomLevel) {
int levelNodeCount = GetIntAttribute(GeometryToken.NodeCountOnLevel);
if (lgData.LevelNodeCounts == null) {
lgData.LevelNodeCounts = new List<int>();
}
lgData.LevelNodeCounts.Add(levelNodeCount);
LgLevel level = new LgLevel(zoomLevel, _graph);
lgData.Levels.Add(level);
XmlRead();
Dictionary<string, Set<string>> edgeIdToEdgeRailsSet = new Dictionary<string, Set<string>>();
ReadRailIdsPerEdgeIds(lgData, edgeIdToEdgeRailsSet);
ReadRails(level);
ReadEndElement();
FillRailsOfEdges(level, edgeIdToEdgeRailsSet);
}
