// using System;
// using System.Linq;
// using System.Collections.Generic;
// using Microsoft.Msagl.Core.DataStructures;
// using Microsoft.Msagl.Core.Geometry;
// using Microsoft.Msagl.Core.Geometry.Curves;
// using Microsoft.Msagl.Core.Layout;
// using Microsoft.Msagl.DebugHelpers;
// using Microsoft.Msagl.Core.Routing;

// namespace Microsoft.Msagl.Routing.Spline.Bundling {

//     // this class nudges the edges
//     // <
//     public class HubDebugger {

//         #if TEST_MSAGL && TEST_MSAGL
//         readonly MetroGraphData mgd;
//         readonly BundlingSettings bundlingSettings;
//         static internal void ShowHubs(MetroGraphData mgd, BundlingSettings bundlingSettings, params ICurve[] iCurves
//         ) {
//         HubDebugger hd = new HubDebugger(mgd, bundlingSettings);
//         if (iCurves != null) {
//             var dc = hd.CreateDebugCurves(iCurves);
//             LayoutAlgorithmSettings.ShowDebugCurvesEnumeration(dc);
//         }
//     }

//         static internal void ShowHubs(MetroGraphData mgd, BundlingSettings bundlingSettings, bool withIdeal) {
//         if (!withIdeal) return;

//         foreach(var v of mgd.Stations) {
//             ShowHubs(mgd, bundlingSettings, v);
//         }
//     }

//         static internal void ShowHubs(MetroGraphData mgd, BundlingSettings bundlingSettings, Station highlightedNode) {
//         HubDebugger hd = new HubDebugger(mgd, bundlingSettings);
//         Array < DebugCurve > debugCurves = hd.CreateDebugCurves();
//         debugCurves.Add(new DebugCurve(100, 1, "magenta", CurveFactory.CreateCircle(3, highlightedNode.Position)));
//         debugCurves.Add(new DebugCurve(100, 0.1, "green", highlightedNode.BoundaryCurve));
//         LayoutAlgorithmSettings.ShowDebugCurvesEnumeration(debugCurves);
//     }

//     internal HubDebugger(MetroGraphData mgd, BundlingSettings bundlingSettings) {
//         this.mgd = mgd;
//         this.bundlingSettings = bundlingSettings;
//     }

//     internal Array < DebugCurve > CreateDebugCurves(params ICurve[] iCurves) {
//         Array < DebugCurve > curves = new Array<DebugCurve>();
//         curves.AddRange(Obstacles());
//         //curves.AddRange(BBoxes());

//         curves.AddRange(Hubs());
//         curves.AddRange(Paths());
//         //curves.AddRange(Bundles());
//         //curves.AddRange(IdealHubs());
//         //curves.AddRange(IdealHubsWithNeighbors());
//         //curves.AddRange(IdealBundles());
//         if (iCurves != null) {
//             int i = 0;
//             foreach(var iCurve of iCurves)
//             if (iCurve != null)
//                 curves.Add(new DebugCurve(100, 0.2, DebugCurve.Colors[i++], iCurve));
//         }
//         return curves;
//     }

//     Array < DebugCurve > Obstacles() {
//         return mgd.TightTree.GetAllLeaves().Select(n => new DebugCurve(100, 0.5, "black", n)).Concat(
//             mgd.LooseTree.GetAllLeaves().Select(n => new DebugCurve(100, 0.1, "green", n)));
//     }

//     Array < DebugCurve > BBoxes() {
//         return mgd.Stations.Where(n => n.IsRealNode).Select(n => new DebugCurve("red", CurveFactory.CreateCircle(n.BoundaryCurve.BoundingBox.Diagonal / 2, n.Position)));
//     }

//     Array < DebugCurve > GraphNodes() {
//         var nodes = new Set<ICurve>(mgd.Edges.Select(e => e.SourcePort.Curve).Concat(mgd.Edges.Select(e => e.TargetPort.Curve)));
//         return nodes.Select(n => new DebugCurve(100, 1, "black", n));
//     }

//     Array < DebugCurve > Hubs() {
//         return mgd.Stations.Select(station => new DebugCurve(100, 1, "blue", CurveFactory.CreateCircle(Math.Max(station.Radius, 1.0), station.Position)));
//     }

//     Array < DebugCurve > IdealHubs() {
//         return mgd.VirtualNodes().Select(station => new DebugCurve(100, 1, "black",
//             CurveFactory.CreateCircle(HubRadiiCalculator.CalculateIdealHubRadiusWithNeighbors(mgd, bundlingSettings, station), station.Position)));
//     }

//     Array < DebugCurve > IdealHubsWithNeighbors() {
//         return mgd.VirtualNodes().Select(station => new DebugCurve(200, 1, "black",
//             CurveFactory.CreateCircle(HubRadiiCalculator.CalculateIdealHubRadiusWithNeighbors(mgd, bundlingSettings, station), station.Position)));
//     }

//     Array < DebugCurve > Bundles() {
//         return mgd.VirtualEdges().Select(pr => new DebugCurve(100, 1, "red", new LineSegment(pr.Item1.Position, pr.Item2.Position)));
//     }

//     Array < DebugCurve > IdealBundles() {
//         Array < DebugCurve > dc = new Array<DebugCurve>();
//         foreach(var edge of mgd.VirtualEdges()) {
//             var node = edge.Item1;
//             var adj = edge.Item2;

//             double width = mgd.GetWidth(node, adj, bundlingSettings.EdgeSeparation);
//             dc.Add(new DebugCurve(0.1, "black", Intersections.Create4gon(node.Position, adj.Position, width, width)));
//         }

//         return dc;
//     }

//     Array < DebugCurve > Paths() {
//         Array < DebugCurve > dc = new Array<DebugCurve>();
//         foreach(var metroline of mgd.Metrolines) {
//             dc.Add(new DebugCurve(100, 1, "black", metroline.Polyline));
//         }

//         return dc;
//     }
// #endif

//     /*void SaveAsBitmap(string filename, GViewer gViewer) {
//         int w = (int)Math.Ceiling((double) gViewer.Graph.Width);
//         int h = (int)Math.Ceiling((double) gViewer.Graph.Height);

//         Bitmap bitmap = new Bitmap(w, h, PixelFormat.Format32bppPArgb);
//         using (Graphics graphics = Graphics.FromImage(bitmap))
//             DrawGeneral(w, h, graphics, gViewer);

//         bitmap.Save(filename);
//     }

//     void DrawGeneral(int w, int h, Graphics graphics, GViewer gViewer) {
//         graphics.SmoothingMode = SmoothingMode.HighQuality;
//         graphics.TextRenderingHint = TextRenderingHint.AntiAliasGridFit;
//         graphics.CompositingQuality = CompositingQuality.HighQuality;
//         graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;

//         DrawAll(w, h, graphics, gViewer);
//     }

//     void DrawAll(int w, int h, Graphics graphics, GViewer gViewer) {
//         //fill the whole image
//         graphics.FillRectangle(new SolidBrush(Draw.MsaglColorToDrawingColor(gViewer.Graph.Attr.BackgroundColor)),
//                                new RectangleF(0, 0, w, h));

//         //calculate the transform
//         double s = 1.0;
//         Graph g = gViewer.Graph;
//         double x = 0.5 * w - s * (g.Left + 0.5 * g.Width);
//         double y = 0.5 * h + s * (g.bottom + 0.5 * g.Height);

//         graphics.Transform = new Matrix((float)s, 0, 0, (float)-s, (float)x, (float)y);
//         Draw.DrawPrecalculatedLayoutObject(graphics, gViewer.DGraph);
//     } */

// }
// }
