ControlMesh.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Triangulator;
using System.Windows;

namespace EdgeClustering
{
    /// \author Manuel Keglevic
    /// \author Thomas Schulz
    /// <summary>
    /// Provides functions and data structure to compute the control mesh.
    /// </summary>
    class ControlMesh
    {
        List<ControlMeshEdge> edges = new List<ControlMeshEdge>();
        
        /// <summary>
        /// Control Mesh Edges
        /// </summary>
        public List<ControlMeshEdge> Edges
        {
            get { return edges; }
        }

        List<ControlMeshVertex> vertices = new List<ControlMeshVertex>();
        /// <summary>
        /// Control Mesh Vertices
        /// </summary>
        public List<ControlMeshVertex> Vertices
        {
            get { return vertices; }
        }

        //private List<EnhancedEdge> enhancedEdges = new List<EnhancedEdge>();

        /// <summary>
        /// Generates a control mesh consisting only of the edges in 
        /// <code>initialEdges</code>.
        /// </summary>
        /// <param name="initialEdges">The control edges for the test control
        /// mesh</param>
        public void GenerateTestControlMesh(List<SimpleEdge> initialEdges)
        {
            edges = new List<ControlMeshEdge>();
            vertices = new List<ControlMeshVertex>();

            foreach (SimpleEdge s in initialEdges)
            {
                ControlMeshVertex v1,v2;
                v1 = new ControlMeshVertex(s.A.X,s.A.Y);
                v2 = new ControlMeshVertex(s.B.X,s.B.Y);

                //Check if v1 exists
                if (!vertices.Contains(v1))
                    vertices.Add(v1);
                else
                    v1 = vertices[vertices.IndexOf(v1)];
                
                //Check if v2 exists
                if (!vertices.Contains(v2))
                    vertices.Add(v2);
                else
                    v2 = vertices[vertices.IndexOf(v2)];

                //Add edge
                edges.Add(new ControlMeshEdge(ref v1,ref v2));
            }
        }

        /// <summary>
        /// Converts the list of SimpleEdges <code>originalEdges</code> to 
        /// EnhancedEdges and calls ControlMeshEdge#Intersect() for each 
        /// control mesh edge in this control mesh.
        /// </summary>
        /// <param name="originalEdges">List of original edges in the graph</param>
        /// <returns>The new EnhancedEdges with the control points from the 
        /// intersection</returns>
        public List<EnhancedEdge> Intersect(List<SimpleEdge> originalEdges)
        {
            List<EnhancedEdge> enhancedEdges = new List<EnhancedEdge>();

            foreach (SimpleEdge s in originalEdges)
                enhancedEdges.Add(new EnhancedEdge(new SimpleEdge(
                    new Point(s.A.X / Graph.gridScale, s.A.Y / Graph.gridScale), 
                    new Point(s.B.X / Graph.gridScale, s.B.Y / Graph.gridScale))));

            for (int i = 0; i < edges.Count; i++)
                edges[i].Intersect(ref enhancedEdges);

            return enhancedEdges;
        }

        /// <summary>
        /// Calculates the Control Mesh by using Delaunay Triangulation.
        /// </summary>
        /// <param name="initialEdges">initial Edges used for the triangulation</param>
        public void CalculateControlMesh(List<SimpleEdge> initialEdges)
        {
            vertices = new List<ControlMeshVertex>();
            edges = new List<ControlMeshEdge>();

            foreach (SimpleEdge s in initialEdges)
            {
                ControlMeshVertex v1, v2;
                v1 = new ControlMeshVertex(s.A.X, s.A.Y);
                v2 = new ControlMeshVertex(s.B.X, s.B.Y);

                //Check if v1 exists
                if (!vertices.Contains(v1))
                    vertices.Add(v1);
                else
                    v1 = vertices[vertices.IndexOf(v1)];

                //Check if v2 exists
                if (!vertices.Contains(v2))
                    vertices.Add(v2);
                else
                    v2 = vertices[vertices.IndexOf(v2)];

                //Add edge
                edges.Add(new ControlMeshEdge(ref v1, ref v2));
            }

            List<Triangulator.Geometry.Triangle> delaunayTriangles = Triangulator.Delaunay.Triangulate(vertices);

            if (delaunayTriangles != null)
            {
                edges = new List<ControlMeshEdge>();

                foreach (Triangulator.Geometry.Triangle t in delaunayTriangles)
                {
                    List<ControlMeshEdge> temp = new List<ControlMeshEdge>();
                    ControlMeshVertex v1, v2, v3;
                    v1 = vertices[t.p1];
                    v2 = vertices[t.p2];
                    v3 = vertices[t.p3];

                    temp.Add(new ControlMeshEdge(ref v1, ref v2));
                    temp.Add(new ControlMeshEdge(ref v2, ref v3));
                    temp.Add(new ControlMeshEdge(ref v3, ref v1));

                    foreach (ControlMeshEdge e in temp)
                    {
                        if (!edges.Contains(e))
                            edges.Add(e);
                    }
                }
            }
        }

    }
}

---