Beispiel #1
0
        /// <summary>
        /// Create a new set of statistics based on a graph
        /// </summary>
        /// <param name="g">The graph to base the stats on</param>
        /// <returns>A GraphStatistics object representing the stats of the graph</returns>
        public static GraphStatistics From(Graph g)
        {
            float minX = g.nodes[0].position.X, minY = g.nodes[0].position.Y;
            float maxX = g.nodes[0].position.X, maxY = g.nodes[0].position.Y;

            foreach (var n in g.nodes)
            {
                if (n.position.X < minX)
                {
                    minX = n.position.X;
                }
                if (n.position.X > maxX)
                {
                    maxX = n.position.X;
                }

                if (n.position.Y < minY)
                {
                    minY = n.position.Y;
                }
                if (n.position.Y > maxY)
                {
                    maxY = n.position.Y;
                }
            }

            GraphStatistics stats = new GraphStatistics
            {
                Height = maxY - minY,
                Width  = maxX - minX
            };

            stats.GraphArea = new RectangleF(minX, minY, stats.Width, stats.Height);

            // Calculate stuff with edges
            float longest_edge  = 0;
            float shortest_edge = 1;

            foreach (Edge e in g.edges)
            {
                float l = e.Length;
                if (l > longest_edge)
                {
                    longest_edge = l;
                }
                if (l < shortest_edge)
                {
                    shortest_edge = l;
                }
                stats.EdgeLenghtTotal += l;
            }
            stats.EdgeRatio = longest_edge / shortest_edge;

            IEnumerable <float> edge_lengths = g.edges.Select(s => s.Length);

            stats.EdgeMean   = (float)mean(edge_lengths);
            stats.EdgeStdDev = (float)stddev(edge_lengths, stats.EdgeMean);

            return(stats);
        }
 /// <summary>
 /// Calculate the required Bitmap size
 /// </summary>
 /// <param name="stats">The statistics to work with</param>
 /// <param name="intendedWidth">The intended height of the bitmap, in pixels</param>
 /// <param name="intendedHeight">The intended height of the bitmap, in pixels</param>
 /// <param name="boundary">The boundary around the graph on the image, so that there's a bit of clear space around the graph</param>
 /// <returns>A rectangle containing the bitmap size</returns>
 private void CalculateScale(GraphStatistics stats, int intendedWidth, int intendedHeight, int boundary)
 {
     _xMultiplier = (intendedWidth - (2 * boundary)) / stats.Width;
     _yMultiplier = (intendedHeight - (2 * boundary)) / stats.Height;
     _xOffset     = -stats.GraphArea.X + ((float)boundary) / _xMultiplier;
     _yOffset     = -stats.GraphArea.Y + ((float)boundary) / _yMultiplier;
 }
Beispiel #3
0
        private static results runner(Graph g, string outputFile, Algorithm a)
        {
            Visualizer v = new Visualizer();
            int        i = 0;

            a.start(g);
            var start     = Process.GetCurrentProcess().TotalProcessorTime;
            var stopwatch = Stopwatch.StartNew();

            while (!a.step(g))
            {
                i++;
                if (outputFile != null)
                {
                    string s = String.Format("{0}.{1}", outputFile, i);
                    v.Visualize(g, s);
                }
            }
            stopwatch.Stop();
            var stop = Process.GetCurrentProcess().TotalProcessorTime;

            if (outputFile != null)
            {
                v.Visualize(g, outputFile, 1024, 1024);
            }

            results r = new results();

            r.iterations = i + 1;
            r.runtime    = stopwatch.ElapsedMilliseconds;//(stop - start).TotalMilliseconds;
            r.stats      = GraphStatistics.From(g);
            r.graph      = g;
            return(r);
        }
        /// <summary>
        /// Start visualizing
        /// </summary>
        /// <param name="g">The graph to Visualize</param>
        /// <param name="path">The path to write an image to</param>
        /// <param name="imageWidth">The width of the image file</param>
        /// <param name="imageHeight">The height of the image file</param>
        /// <param name="boundary">The boundary around the graph on the image, so that there's a bit of clear space around the graph</param>
        /// <param name="nodeSize">The diameter of the nodes, in pixels</param>
        public void Visualize(Graph g, string path, int imageWidth = 300, int imageHeight = 300, int boundary = 30, int nodeSize = 5)
        {
            _stats = GraphStatistics.From(g);
            CalculateScale(_stats, imageWidth, imageHeight, boundary);

            _bitmap   = new Bitmap(imageWidth, imageHeight);
            _graphics = Graphics.FromImage(_bitmap);
            _graphics.FillRectangle(_backgroundColor, 0, 0, _bitmap.Width, _bitmap.Height);

            NodeSize = nodeSize;

            DrawGraph(g, path);

            _graphics.Dispose();
            _bitmap.Dispose();
        }