GraphDrawer.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Shapes;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Collections;
using System.Globalization;

namespace EdgeClustering
{
    /// \author Manuel Keglevic
    /// \author Thomas Schulz
    /// <summary>
    /// This class is responsible for drawing the original graph, all 
    /// intermediate results and the enhanced graph.
    /// </summary>
    class GraphDrawer:FrameworkElement
    {
        /// \author Manuel Keglevic
        /// \author Thomas Schulz
        /// <summary>
        /// Struct for visibility and color settings for each item drawn by the GraphDrawer.
        /// </summary>
        public struct Settings
        {
            public static bool graphEdgesVisible = true;
            public static bool segmentsVisible = false;
            public static bool mergedSegmentsVisible = false;
            public static bool kernelPeaksVisible = false;
            public static bool controlMeshEdgesVisible = true;
            public static bool controlPointsVisible = false;

            public static bool controlMeshVisible = true;
            public static bool enhancedGraphVisible = true;

            public static Color GraphColor = Colors.Black;
            public static Color SegmentsColor = Colors.Red;
            public static Color MergedSegmentsColor = Colors.BlueViolet;
            public static Color KDEPeakColor = Colors.Green;
            public static Color ControlMeshEdgesColor = Colors.Aquamarine;
            public static Color ControlPointsColor = Colors.HotPink;
            public static Color ControlMeshColor = Colors.Green;
            public static Color EnhancedGraphColor = Colors.GreenYellow;
        }

        

        private Graph graph;
        public Graph Graph
        {
            set { graph = value; }
        }

        private int windowSize;

        /// <summary>
        /// Generates a new Graph drawer and initializes it.
        /// </summary>
        /// <param name="windowSize"></param>
        public GraphDrawer(int windowSize)
        {
            this.Width = windowSize;
            this.Height = windowSize;

            this.Clip = new RectangleGeometry(new Rect(0, 0, windowSize, windowSize));
            this.ClipToBounds = true;

            this.windowSize = windowSize;
        }

     
        /// <summary>
        /// Draws everything
        /// </summary>
        /// <param name="dc"></param>
        protected override void OnRender(System.Windows.Media.DrawingContext dc)
        {
            if (graph == null)
                return;

            
            DrawGrid(dc, Colors.Gray);
            if((Settings.enhancedGraphVisible && graph.ComputingStage >=6) || Settings.graphEdgesVisible)
                DrawGraphPoints(dc, graph.Points);                      //Draw graph Nodes

            if (Settings.graphEdgesVisible)
                DrawGraphEdges(dc, graph.SimpleEdges, Settings.GraphColor);              //Draw graph Edges

            if (graph.ComputingStage >= 1 && Settings.segmentsVisible)        //Stage 1 - Segment Angles
                DrawSegmentAngles(dc, Settings.SegmentsColor,graph.Grid);

            if (graph.ComputingStage >= 2 && Settings.kernelPeaksVisible)    //Stage 2 - kde peaks 
                DrawKernelPeak(dc, Settings.KDEPeakColor, graph.KernelPeaks);

            if (graph.ComputingStage >= 3 && Settings.mergedSegmentsVisible)
                DrawMergedSegments(dc,graph.MergedSegments, Settings.MergedSegmentsColor);

            if (graph.ComputingStage >= 4 && Settings.controlMeshEdgesVisible)
                DrawMeshEdges(dc, Settings.ControlMeshEdgesColor, graph.MeshEdges);

            if (graph.ComputingStage >= 5 && Settings.controlMeshVisible)
                DrawControlMesh(dc, Settings.ControlMeshColor, graph.ControlMesh.Edges, graph.ControlMesh.Vertices);

            if (graph.ComputingStage >= 6 && Settings.controlPointsVisible)
                DrawControlPoints(dc, Settings.ControlPointsColor, graph.EnhancedEdges);



            if (graph.ComputingStage >= 6 && Settings.enhancedGraphVisible)
                DrawEnhancedGraph(dc, Settings.EnhancedGraphColor, graph.EnhancedEdges);
            //DrawStreamGeometry(dc);

            //
        }

        /// <summary>
        /// Draws the Cardinal Splines representing the edge clustered graph. For each edge the control points are sorted
        /// by the distance to the starting point. After that the Cardinal Splines are built using the endpoints and the 
        /// sorted control points.
        /// </summary>
        /// <param name="dc"></param>
        /// <param name="c"></param>
        /// <param name="edges">enhanced edges with control point information</param>
        private void DrawEnhancedGraph(DrawingContext dc, Color c, List<EnhancedEdge> edges)
        {
            SolidColorBrush Brush = new SolidColorBrush(c);
            //Brush.Opacity = 0.6;
            Pen Pen = new Pen(Brush, 4);

            double delta = (double)windowSize / Graph.Settings.GridSize;

            foreach (EnhancedEdge ee in edges)
            {
                

                List<Point> points = new List<Point>();

                ControlMeshVertex vA,vB;
                vA = new ControlMeshVertex(ee.A.X,ee.A.Y);
                vB = new ControlMeshVertex(ee.B.X,ee.B.Y);

                Point end;

                //Reihenfolge von den Punkte wegen sortierung
                if (vA.CompareTo(vB) < 0)
                {
                    ee.SortControlPoints(vA.Point);
                    points.Add(new Point(vA.X*delta,vA.Y*delta));
                    end = vB.Point;
                }
                else
                {
                    ee.SortControlPoints(vB.Point);
                    points.Add(new Point(vB.X*delta,vB.Y*delta));
                    end = vA.Point;
                }

                

                foreach (ControlMeshVertex v in ee.ControlPoints)
                { 
                    points.Add(new Point(v.X*delta,v.Y*delta));
                }
                points.Add(new Point(end.X*delta,end.Y*delta));

                dc.DrawGeometry(null, Pen, CardinalSpline.CalculateCardinalSplinePath(points.ToArray(), 0.5));
            }
        }

        /// <summary>
        /// Draws the control points.
        /// </summary>
        /// <param name="dc"></param>
        /// <param name="c">color</param>
        /// <param name="edges">list of enhanced edges containing the control point information.</param>
        private void DrawControlPoints(DrawingContext dc, Color c, List<EnhancedEdge> edges)
        {
            SolidColorBrush pointBrush = new SolidColorBrush(c);
            Pen pointsPen = new Pen(pointBrush, 4);

            double delta = (double)windowSize / Graph.Settings.GridSize;

            foreach (EnhancedEdge ee in edges)
                foreach (ControlMeshVertex p in ee.ControlPoints)
                    dc.DrawEllipse(null, pointsPen, new Point(p.X * delta, p.Y * delta), 4, 4);
        }

        /// <summary>
        /// Draws the Control Mesh with the given Color.
        /// </summary>
        /// <param name="dc"></param>
        /// <param name="c">color</param>
        /// <param name="edges">list of Control Mesh edges</param>
        /// <param name="vertices">list of Control Mesh vertices</param>
        private void DrawControlMesh(DrawingContext dc, Color c, List<ControlMeshEdge> edges, List<ControlMeshVertex> vertices)
        {
            SolidColorBrush edgeBrush = new SolidColorBrush(c);
            //edgeBrush.Opacity = 0.6;
            Pen pen = new Pen(edgeBrush, 3);

            double delta = (double)windowSize / Graph.Settings.GridSize;

            foreach(ControlMeshEdge e in edges)
                dc.DrawLine(pen,new Point(e.V1.X*delta,e.V1.Y*delta),new Point(e.V2.X*delta,e.V2.Y*delta));

            foreach(ControlMeshVertex v in vertices)
                dc.DrawRectangle(null,pen,new Rect(v.X*delta -2,v.Y*delta -2,4,4)); 
        }

        /// <summary>
        /// Draws the control mesh edges computed for the mergedsegments.
        /// </summary>
        /// <param name="dc"></param>
        /// <param name="c"></param>
        private void DrawMeshEdges(DrawingContext dc, Color c,List<SimpleEdge> meshEdges)
        {
            SolidColorBrush edgeBrush = new SolidColorBrush(c);
            //edgeBrush.Opacity = 0.5;
            Pen pen = new Pen(edgeBrush, 4);
            Point p1, p2;

            double delta = (double)windowSize / Graph.Settings.GridSize;

            foreach (SimpleEdge se in meshEdges)
            {
                p1 = new Point(se.A.X * delta, se.A.Y * delta);
                p2 = new Point(se.B.X * delta, se.B.Y * delta);
                dc.DrawLine(pen, p1, p2);
            }
        }

        /// <summary>
        /// Draws the merged segments.
        /// </summary>
        /// <param name="dc"></param>
        /// <param name="mergedSegments">List of merged segments.</param>
        private void DrawMergedSegments(DrawingContext dc, List<MergedSegment> mergedSegments, Color color)
        {

            SolidColorBrush brush = new SolidColorBrush(color);
            //brush.Opacity = 0.5;
            Pen pen = new Pen(brush, 2);

            double delta = (double)windowSize / Graph.Settings.GridSize;

            for (int i = 0; i < mergedSegments.Count; i++)
            {
                foreach (MergedSegment.Segment s in mergedSegments[i].segments)
                {

                    FormattedText label = new FormattedText(
                             i + "",
                             CultureInfo.GetCultureInfo("de"),
                            FlowDirection.LeftToRight,
                            new Typeface("Verdana"),
                            8,
                            Brushes.Black);

                    dc.DrawText(label, new Point((s.x + 0.5) * delta, (s.y + 0.5) * delta));


                    FormattedText averageAngle = new FormattedText(
                            String.Format("{0:0.0}", mergedSegments[i].averageAngle),
                             CultureInfo.GetCultureInfo("de"),
                            FlowDirection.LeftToRight,
                            new Typeface("Verdana"),
                            4,
                            Brushes.Gray);

                    dc.DrawText(averageAngle, new Point((s.x) * delta, (s.y) * delta));

                    DrawAngle(dc, pen, s.x, s.y, mergedSegments[i].averageAngle);
                }
            }
        }

        /// <summary>
        /// Draws the output of the kde computation.
        /// </summary>
        /// <param name="dc"></param>
        /// <param name="color"></param>
        private void DrawKernelPeak(DrawingContext dc, Color color, double[,] kernelPeaks)
        {
            SolidColorBrush brush = new SolidColorBrush(color);
            //brush.Opacity = 0.5;
            Pen pen = new Pen(brush, 2);

            double delta = (double)windowSize / Graph.Settings.GridSize;

            for (int x = 0; x < Graph.Settings.GridSize; x++)
            {
                for (int y = 0; y < Graph.Settings.GridSize; y++)
                {
                    if (kernelPeaks[x, y] != -1)  //Draw if data for this segment
                        DrawAngle(dc, pen, x, y, kernelPeaks[x, y]);
                }
            }
        }

        /// <summary>
        /// Draws the segment elements stored in the grid.
        /// </summary>
        /// <param name="dc">drawing context</param>
        /// <param name="color">color</param>
        /// <param name="grid">grid containing list of segment angles</param>
        private void DrawSegmentAngles(DrawingContext dc, Color color, ArrayList[,] grid)
        {

            SolidColorBrush brush = new SolidColorBrush(color);
            //brush.Opacity = 0.3;
            Pen pen = new Pen(brush, 4);

            double delta = (double)windowSize / Graph.Settings.GridSize;

            //Schleife über alle Grid Elemente
            for (int x = 0; x < Graph.Settings.GridSize; x++)
            {
                for (int y = 0; y < Graph.Settings.GridSize; y++)
                {
                    if (grid[x, y] != null)
                        foreach (double d in grid[x, y])
                            DrawAngle(dc, pen, x, y, d);
                }
            }
        }

        /// <summary>
        /// Draws an line representing a angle at the given position in the grid.
        /// </summary>
        /// <param name="dc">drawing context</param>
        /// <param name="pen">pen</param>
        /// <param name="x">x position on grid</param>
        /// <param name="y">y postion on grid</param>
        /// <param name="angle">angle between 0..180</param>
        private void DrawAngle(DrawingContext dc, Pen pen, int x, int y, double angle)
        {
            double delta = (double)windowSize / Graph.Settings.GridSize;

            Point p1 = new Point((x + 0.5 + Math.Cos(angle * Math.PI / 180.0) * 0.5) * delta, (y + 0.5 + Math.Sin(angle * Math.PI / 180.0) * 0.5) * delta);
            Point p2 = new Point((x + 0.5 - Math.Cos(angle * Math.PI / 180.0) * 0.5) * delta, (y + 0.5 - Math.Sin(angle * Math.PI / 180.0) * 0.5) * delta);
            dc.DrawLine(pen, p1, p2);
        }

        /// <summary>
        /// Draws the grid Pattern.
        /// </summary>
        /// <param name="dc"></param>
        /// <param name="color"></param>
        private void DrawGrid(System.Windows.Media.DrawingContext dc, Color color)
        {
            SolidColorBrush gridBrush = new SolidColorBrush(color);
            Pen gridPen = new Pen(gridBrush, 0.5);

            Point a, b;
            double delta = (double)windowSize / Graph.Settings.GridSize;

            a = new Point(0, 0);
            b = new Point(0, windowSize);

            //Vertikale linien
            for (int i = 0; i <= Graph.Settings.GridSize; i++)
            {
                a.X = i * delta;
                b.X = i * delta;
                dc.DrawLine(gridPen, a, b);
            }

            a.X = 0;
            b.X = windowSize;

            //Horizontale Linien
            for (int i = 0; i <= Graph.Settings.GridSize; i++)
            {
                a.Y = i * delta;
                b.Y = i * delta;
                dc.DrawLine(gridPen, a, b);
            }
        }

        /// <summary>
        /// Draws the given points.
        /// </summary>
        /// <param name="dc"></param>
        /// <param name="points"></param>
        private void DrawGraphPoints(DrawingContext dc, PointCollection points)
        {
            double scale = (double)windowSize / graph.MaxPointValue;

            SolidColorBrush pointBrush = new SolidColorBrush(Colors.LightGreen);
            Pen pointsPen = new Pen(pointBrush, 4);

            foreach (Point p in points)
                dc.DrawEllipse(null, pointsPen, new Point(p.X*scale,p.Y*scale), 4, 4);
        }

        /// <summary>
        /// Draws the given list of edges.
        /// </summary>
        /// <param name="dc"></param>
        /// <param name="edges"></param>
        private void DrawGraphEdges(DrawingContext dc, List<SimpleEdge> edges, Color color)
        {
            double scale = (double)windowSize / graph.MaxPointValue;

            SolidColorBrush edgeBrush = new SolidColorBrush(color);
            //edgeBrush.Opacity = 0.5;
            color.A = 0xFF;
            Pen pen = new Pen(edgeBrush, 4);

            foreach (SimpleEdge e in edges)
                dc.DrawLine(pen, new Point(e.A.X * scale, e.A.Y * scale), new Point(e.B.X * scale, e.B.Y * scale));
        }

        /// <summary>
        /// Test function for CardinalSplie drawing
        /// </summary>
        /// <param name="dc"></param>
        /// <param name="penLine"></param>
        /// <param name="penPoints"></param>
        public void DrawStreamGeometry(DrawingContext dc)
        {
            SolidColorBrush edgeBrush = new SolidColorBrush(Colors.Black);
            //edgeBrush.Opacity = 0.5;
            Pen penLine = new Pen(edgeBrush, 4);

            SolidColorBrush pointBrush = new SolidColorBrush(Colors.LightGreen);
            Pen penPoints = new Pen(pointBrush, 4);

            Point[] pts = new Point[] { new Point(100, 50), new Point(50, 200), new Point(200, 200), new Point(250, 250), new Point(250, 300) };

            dc.DrawGeometry(null, penLine, CardinalSpline.CalculateCardinalSplinePath(pts, 0.5));

            foreach (Point p in pts)
            {
                dc.DrawEllipse(null, penPoints, p, 4, 4);
            }
        }
    }
}

---