示例#1
0
        static IEnumerable <DebugCurve> DebugSegs(MetroGraphData metroGraphData, IMetroMapOrderingAlgorithm metroMapOrdering)
        {
            var ls = new List <ICurve>();

            foreach (var s in metroGraphData.VirtualNodes())
            {
                foreach (var b in s.BundleBases.Values)
                {
                    foreach (var h in b.OrientedHubSegments)
                    {
                        if (h == null)
                        {
                            continue;
                        }
                        if (h.Segment == null)
                        {
                            var uBase = h.Other.BundleBase;
                            var i     = h.Index;
                            var j     = h.Other.Index;
                            ls.Add(new LineSegment(b.Points[i], uBase.Points[j]));
                        }
                        else
                        {
                            ls.Add(h.Segment);
                        }
                    }
                }
            }

            return(ls.Select(s => new DebugCurve(100, 0.01, "green", s)));
        }
示例#2
0
 static IEnumerable <ICurve> HubSegsOfLine(MetroGraphData metroGraphData, IMetroMapOrderingAlgorithm metroOrdering, Metroline line)
 {
     for (PolylinePoint i = line.Polyline.StartPoint.Next; i.Next != null; i = i.Next)
     {
         yield return(SegOnLineVertex(metroGraphData, metroOrdering, line, i));
     }
 }
示例#3
0
        static internal void ShowHubs(MetroGraphData metroGraphData, IMetroMapOrderingAlgorithm metroMapOrdering, Station station)
        {
            var ttt = GetAllDebugCurves(metroMapOrdering, metroGraphData);

            if (station != null)
            {
                ttt = ttt.Concat(new[] { new DebugCurve(255, 3, "pink", CurveFactory.CreateDiamond(20, 20, station.Position)) });
            }
            LayoutAlgorithmSettings.ShowDebugCurvesEnumeration(ttt);
        }
示例#4
0
        static Point FindCurveEnd(MetroGraphData metroGraphData, IMetroMapOrderingAlgorithm metroOrdering, Metroline metroline)
        {
            Station u = metroGraphData.PointToStations[metroline.Polyline.EndPoint.Prev.Point];
            Station v = metroGraphData.PointToStations[metroline.Polyline.EndPoint.Point];

            BundleBase bb    = v.BundleBases[u];
            int        index = (!bb.IsParent ? metroOrdering.GetLineIndexInOrder(u, v, metroline) : metroOrdering.GetLineIndexInOrder(v, u, metroline));

            return(bb.Points[index]);
        }
示例#5
0
 /// <summary>
 /// bundle-map ordering
 /// </summary>
 void CreateMetroOrdering()
 {
     if (bundlingSettings.UseGreedyMetrolineOrdering)
     {
         metroOrdering = new GeneralMetroMapOrdering(metroGraphData.Metrolines);
     }
     else
     {
         metroOrdering = new LinearMetroMapOrdering(metroGraphData.Metrolines, metroGraphData.PointToStations);
     }
 }
示例#6
0
 static IEnumerable <DebugCurve> BetweenHubs(IMetroMapOrderingAlgorithm metroMapOrdering, MetroGraphData metroGraphData)
 {
     foreach (Metroline ml in metroGraphData.Metrolines)
     {
         List <Tuple <Point, Point> > segs = GetInterestingSegs(metroGraphData, metroMapOrdering, ml);
         string color = GetMonotoneColor(ml.Polyline.Start, ml.Polyline.End, segs);
         foreach (var seg in segs)
         {
             yield return(new DebugCurve(100, ml.Width, color, new LineSegment(seg.Item1, seg.Item2)));
         }
     }
 }
示例#7
0
        static ICurve SegOnLineVertex(MetroGraphData metroGraphData, IMetroMapOrderingAlgorithm metroOrdering, Metroline line, PolylinePoint i)
        {
            Station    u  = metroGraphData.PointToStations[i.Prev.Point];
            Station    v  = metroGraphData.PointToStations[i.Point];
            BundleBase h0 = v.BundleBases[u];
            int        j0 = metroOrdering.GetLineIndexInOrder(u, v, line);

            if (h0.OrientedHubSegments[j0] == null || h0.OrientedHubSegments[j0].Segment == null)
            {
                var w         = metroGraphData.PointToStations[i.Next.Point];
                var otherBase = v.BundleBases[w];
                var j1        = metroOrdering.GetLineIndexInOrder(w, v, line);
                return(new LineSegment(h0.Points[j0], otherBase.Points[j1]));
            }

            return(h0.OrientedHubSegments[j0].Segment);
        }
 static IEnumerable<DebugCurve> BetweenHubs(IMetroMapOrderingAlgorithm metroMapOrdering, MetroGraphData metroGraphData) {
     foreach (Metroline ml in metroGraphData.Metrolines) {
         List<Tuple<Point, Point>> segs = GetInterestingSegs(metroGraphData, metroMapOrdering, ml);
         string color = GetMonotoneColor(ml.Polyline.Start, ml.Polyline.End, segs);
         foreach (var seg in segs)
             yield return new DebugCurve(100, ml.Width, color, new LineSegment(seg.Item1, seg.Item2));
     }
 }
 static IEnumerable<DebugCurve> VertexDebugCurves(IMetroMapOrderingAlgorithm metroMapOrdering, MetroGraphData metroGraphData) {
     return DebugCircles(metroGraphData).Concat(DebugHubBases(metroGraphData)).
         Concat(DebugSegs(metroGraphData, metroMapOrdering)).
         Concat(BetweenHubs(metroMapOrdering, metroGraphData));
 }
 static internal IEnumerable<DebugCurve> GetAllDebugCurves(IMetroMapOrderingAlgorithm metroMapOrdering, MetroGraphData metroGraphData) {
     return GraphNodes(metroGraphData).Concat(VertexDebugCurves(metroMapOrdering, metroGraphData)).Concat(DebugEdges(metroGraphData));
 }
 static internal void ShowHubs(MetroGraphData metroGraphData, IMetroMapOrderingAlgorithm metroMapOrdering, Station station) {
     var ttt = GetAllDebugCurves(metroMapOrdering, metroGraphData);
     if (station != null)
         ttt = ttt.Concat(new[] { new DebugCurve(255, 3, "pink", CurveFactory.CreateDiamond(20, 20, station.Position)) });
     LayoutAlgorithmSettings.ShowDebugCurvesEnumeration(ttt);
 }
        static ICurve SegOnLineVertex(MetroGraphData metroGraphData, IMetroMapOrderingAlgorithm metroOrdering, Metroline line, PolylinePoint i) {
            Station u = metroGraphData.PointToStations[i.Prev.Point];
            Station v = metroGraphData.PointToStations[i.Point];
            BundleBase h0 = v.BundleBases[u];
            int j0 = metroOrdering.GetLineIndexInOrder(u, v, line);
            if (h0.OrientedHubSegments[j0] == null || h0.OrientedHubSegments[j0].Segment == null) {
                var w = metroGraphData.PointToStations[i.Next.Point];
                var otherBase = v.BundleBases[w];
                var j1 = metroOrdering.GetLineIndexInOrder(w, v, line);
                return new LineSegment(h0.Points[j0], otherBase.Points[j1]);
            }

            return h0.OrientedHubSegments[j0].Segment;
        }
 static IEnumerable<ICurve> HubSegsOfLine(MetroGraphData metroGraphData, IMetroMapOrderingAlgorithm metroOrdering, Metroline line) {
     for (PolylinePoint i = line.Polyline.StartPoint.Next; i.Next != null; i = i.Next)
         yield return SegOnLineVertex(metroGraphData, metroOrdering, line, i);
 }
 /// <summary>
 /// bundle-map ordering
 /// </summary>
 void CreateMetroOrdering() {
     if (bundlingSettings.UseGreedyMetrolineOrdering)
         metroOrdering = new GeneralMetroMapOrdering(metroGraphData.Metrolines);
     else
         metroOrdering = new LinearMetroMapOrdering(metroGraphData.Metrolines, metroGraphData.PointToStations);
 }
        static List<Tuple<Point, Point>> GetInterestingSegs(MetroGraphData metroGraphData, IMetroMapOrderingAlgorithm metroMapOrdering, Metroline line) {
            var ret = new List<Tuple<Point, Point>>();
            Point start = FindCurveStart(metroGraphData, metroMapOrdering, line);
            var cubicSegs = HubSegsOfLine(metroGraphData, metroMapOrdering, line);
            foreach (var seg in cubicSegs) {
                if (seg == null) continue;
                ret.Add(new Tuple<Point, Point>(start, seg.Start));
                start = seg.End;
            }
            ret.Add(new Tuple<Point, Point>(start, FindCurveEnd(metroGraphData, metroMapOrdering, line)));

            return ret;
        }
示例#16
0
 static internal IEnumerable <DebugCurve> GetAllDebugCurves(IMetroMapOrderingAlgorithm metroMapOrdering, MetroGraphData metroGraphData)
 {
     return(GraphNodes(metroGraphData).Concat(VertexDebugCurves(metroMapOrdering, metroGraphData)).Concat(DebugEdges(metroGraphData)));
 }
示例#17
0
        static List <Tuple <Point, Point> > GetInterestingSegs(MetroGraphData metroGraphData, IMetroMapOrderingAlgorithm metroMapOrdering, Metroline line)
        {
            var   ret       = new List <Tuple <Point, Point> >();
            Point start     = FindCurveStart(metroGraphData, metroMapOrdering, line);
            var   cubicSegs = HubSegsOfLine(metroGraphData, metroMapOrdering, line);

            foreach (var seg in cubicSegs)
            {
                if (seg == null)
                {
                    continue;
                }
                ret.Add(new Tuple <Point, Point>(start, seg.Start));
                start = seg.End;
            }
            ret.Add(new Tuple <Point, Point>(start, FindCurveEnd(metroGraphData, metroMapOrdering, line)));

            return(ret);
        }
示例#18
0
 static IEnumerable <DebugCurve> VertexDebugCurves(IMetroMapOrderingAlgorithm metroMapOrdering, MetroGraphData metroGraphData)
 {
     return(DebugCircles(metroGraphData).Concat(DebugHubBases(metroGraphData)).
            Concat(DebugSegs(metroGraphData, metroMapOrdering)).
            Concat(BetweenHubs(metroMapOrdering, metroGraphData)));
 }
        static IEnumerable<DebugCurve> DebugSegs(MetroGraphData metroGraphData, IMetroMapOrderingAlgorithm metroMapOrdering) {

            var ls = new List<ICurve>();
            foreach (var s in metroGraphData.VirtualNodes()) {
                foreach (var b in s.BundleBases.Values) {
                    foreach (var h in b.OrientedHubSegments) {
                        if (h == null) continue;
                        if (h.Segment == null) {
                            var uBase = h.Other.BundleBase;
                            var i = h.Index;
                            var j = h.Other.Index;
                            ls.Add(new LineSegment(b.Points[i], uBase.Points[j]));
                        }
                        else {
                            ls.Add(h.Segment);
                        }
                    }
                }
            }

            return ls.Select(s => new DebugCurve(100, 0.01, "green", s));
        }
示例#20
0
 internal BundleBasesCalculator(IMetroMapOrderingAlgorithm metroOrdering, MetroGraphData metroGraphData, BundlingSettings bundlingSettings)
 {
     this.metroOrdering    = metroOrdering;
     this.metroGraphData   = metroGraphData;
     this.bundlingSettings = bundlingSettings;
 }
        static Point FindCurveStart(MetroGraphData metroGraphData, IMetroMapOrderingAlgorithm metroOrdering, Metroline metroline) {
            Station u = metroGraphData.PointToStations[metroline.Polyline.StartPoint.Point];
            Station v = metroGraphData.PointToStations[metroline.Polyline.StartPoint.Next.Point];

            BundleBase bb = u.BundleBases[v];
            int index = (!bb.IsParent ? metroOrdering.GetLineIndexInOrder(v, u, metroline) : metroOrdering.GetLineIndexInOrder(u, v, metroline));
            return bb.Points[index];
        }
 internal BundleBasesCalculator(IMetroMapOrderingAlgorithm metroOrdering, MetroGraphData metroGraphData, BundlingSettings bundlingSettings) {
     this.metroOrdering = metroOrdering;
     this.metroGraphData = metroGraphData;
     this.bundlingSettings = bundlingSettings;
 }