C# Edge类代码示例

        internal static GeometryGraph CreateAndLayoutGraph()
        {
            double w = 30;
            double h = 20;
            GeometryGraph graph = new GeometryGraph();
            Node a = new Node( new Ellipse(w, h, new P()),"a");
            Node b = new Node( CurveFactory.CreateRectangle(w, h, new P()),"b");
            Node c = new Node( CurveFactory.CreateRectangle(w, h, new P()),"c");
            Node d = new Node(CurveFactory.CreateRectangle(w, h, new P()), "d");

            graph.Nodes.Add(a);
            graph.Nodes.Add(b);
            graph.Nodes.Add(c);
            graph.Nodes.Add(d);
            Edge e = new Edge(a, b) { Length = 10 };
            graph.Edges.Add(e);
            graph.Edges.Add(new Edge(b, c) { Length = 3 });
            graph.Edges.Add(new Edge(b, d) { Length = 4 });

            //graph.Save("c:\\tmp\\saved.msagl");
            var settings = new Microsoft.Msagl.Layout.MDS.MdsLayoutSettings();
            LayoutHelpers.CalculateLayout(graph, settings, null);

            return graph;
        }

 private Edge(Edge prev)
 {
     qPrev = prev;
     prev.qNext = this;
     LFace = null;
     Token = 0;
 }

        public void test3()
        {
            UndirectedGraph<int, Edge<int>> graph = new UndirectedGraph<int, Edge<int>>(true);

            // Add vertices to the graph
            graph.AddVertex(0);
            graph.AddVertex(1);
            graph.AddVertex(2);
            graph.AddVertex(3);
            graph.AddVertex(4);
            // Create the edges
            Edge<int> e0_1 = new Edge<int>(0, 1);
            Edge<int> e0_2 = new Edge<int>(0, 2);
            Edge<int> e1_4 = new Edge<int>(1, 4);
            Edge<int> e3_4 = new Edge<int>(3, 4);
            Edge<int> e0_3 = new Edge<int>(0, 3);
            Edge<int> e1_2 = new Edge<int>(1, 2);
            // Add the edges
            graph.AddEdge(e0_1);
            graph.AddEdge(e0_2);
            graph.AddEdge(e1_2);
            graph.AddEdge(e1_4);
            graph.AddEdge(e3_4);
            graph.AddEdge(e0_3);

            List<int> path = new List<int>();

            HamiltonianDefiner definer = new HamiltonianDefiner(graph);
            bool isHamiltonian = definer.isHamiltonianGraph(path);
            Assert.AreEqual(isHamiltonian, true);
        }

        /// <summary>
        /// Class constructor.
        /// </summary>
        
        /// <date>2013-07-23</date>
        public HalfEdge(Edge objEdge, Point objSiteLeft, Point objSiteRight)
        {
            this.Site = objSiteLeft;
            this.Edge = objEdge;

            // 'angle' is a value to be used for properly sorting the
            // halfsegments counterclockwise. By convention, we will
            // use the angle of the line defined by the 'site to the left'
            // to the 'site to the right'.
            // However, border edges have no 'site to the right': thus we
            // use the angle of line perpendicular to the halfsegment (the
            // edge should have both end points defined in such case.)
            if (objSiteRight != null)
            {
                this.Angle = Math.Atan2(objSiteRight.y - objSiteLeft.y, objSiteRight.x - objSiteLeft.x);
            }
            else
            {
                if (objEdge.SiteLeft == objSiteLeft)
                {
                    this.Angle = Math.Atan2(objEdge.VertexB.x - objEdge.VertexA.x, objEdge.VertexA.y - objEdge.VertexB.y);
                }
                else
                {
                    this.Angle = Math.Atan2(objEdge.VertexA.x - objEdge.VertexB.x, objEdge.VertexB.y - objEdge.VertexA.y);
                }
            }
        }

        public IEnumerable<int> FindTourStartingFrom(Edge startEdge)
        {
            this.InitializeVisit();

            this.VisitNode(startEdge.Head);
            yield return startEdge.Head;

            this.VisitNode(startEdge.Tail);
            yield return startEdge.Tail;

            int currentNode = startEdge.Tail;

            TaskLogger.Text = "Computing nearest neighbor tour...";

            while (unvisitedNodes.ItemsCount > 0)
            {
                int nearestUnvisitedNode = this.FindNearestUnvisitedNode(currentNode);

                this.VisitNode(nearestUnvisitedNode);
                yield return nearestUnvisitedNode;

                currentNode = nearestUnvisitedNode;

                TaskLogger.Progress = 100.0 * visitedNodes.ItemsCount / nodes.Length;
            }
        }

        /// <summary>
        /// Creates stub edges for all the intersections in this
        /// Edge (if any) and inserts them into the graph.
        /// </summary>
        /// <param name="edge"></param>
        /// <param name="l"></param>
        public virtual void ComputeEdgeEnds(Edge edge, IList l)
        {
            EdgeIntersectionList eiList = edge.EdgeIntersectionList;       
            // ensure that the list has entries for the first and last point of the edge
            eiList.AddEndpoints();

            IEnumerator it = eiList.GetEnumerator();
            EdgeIntersection eiPrev = null;
            EdgeIntersection eiCurr = null;
            // no intersections, so there is nothing to do
            if (! it.MoveNext()) return;
            EdgeIntersection eiNext = (EdgeIntersection) it.Current;
            do 
            {
                eiPrev = eiCurr;
                eiCurr = eiNext;
                eiNext = null;
                
                if (it.MoveNext())
                    eiNext = (EdgeIntersection)it.Current;                

                if (eiCurr != null) 
                {
                    CreateEdgeEndForPrev(edge, l, eiCurr, eiPrev);
                    CreateEdgeEndForNext(edge, l, eiCurr, eiNext);
                }
            } 
            while (eiCurr != null);
        }

 public EdgeViewModel(int index, Edge edge, BoundaryCondition condition)
 {
     Index = index;
     Edge = edge;
     Condition = condition;
     Types = new ObservableCollection<BoundaryConditionsType>(getTypesOfBoundaryConditions());
 }

        public NeuralNetwork(int countInputNodes, int countOutputNodes, int countHiddenNodes)
        {
            input_nodes = new List<Node>();
            hidden_nodes = new List<Node>();
            output_nodes = new List<Node>();

            // add input nodes
            for (int i = 0; i < countInputNodes; i++)
                input_nodes.Add(new Node());
            // add hidden nodes
            for (int i = 0; i < countHiddenNodes; i++)
                hidden_nodes.Add(new Node());
            // add output nodes
            for (int i = 0; i < countOutputNodes; i++)
                output_nodes.Add(new Node());

            // create edges from data to input
            for (int i = 0; i < input_nodes.Count; i++)
                input_nodes[i].AddEdge(true, new Edge(null, input_nodes[i], 0));

            // create edges from input to hidden
            Edge newEdge;
            for(int i  =0; i < input_nodes.Count; i++)
                for(int j = 0; j < hidden_nodes.Count; j++)
                {
                    newEdge = new Edge(input_nodes[i], hidden_nodes[j], 0);
                }

            // create edges from hidden to output

            // create edges from output to output data
        }

        public EdgeList(Edge edge)
        {
            _edges = new List<Edge>();
            _edges.Add(edge);

            _weight = edge.Weight;
        }

        public static void Main(string[] args)
        {
            Console.Title = "Graph";

            Vertex jana = new Vertex();
            Vertex philip = new Vertex();
            Vertex markus = new Vertex();

            Edge relMarkusPhilip = new Edge();
            Edge relJanaPhilip= new Edge();

            jana.Data.Add("Class", "Person");
            philip.Data.Add("Class", "Person");
            markus.Data.Add("Class", "Person");

            jana.Data.Add("Name", "Jana");
            philip.Data.Add("Name", "Philip");
            markus.Data.Add("Name", "Markus");

            relJanaPhilip.Data.Add("Class", "Friend");
            relMarkusPhilip.Data.Add("Class", "Friend");

            relMarkusPhilip.ConnectVertices(ref markus, ref philip);
            relJanaPhilip.ConnectVertices(ref jana, ref philip);

            List<Edge> results = markus.SearchVertices("Friend");

            foreach (Edge e in results)
                Console.WriteLine(e.Data["Class"]);

            Console.ReadLine();
        }

 public void Add( Edge edge )
 {
     if( !TryAdd( edge ) )
     {
         throw new ArgumentException( "Edge already exists: " + edge.Id );
     }
 }

        public void FindShortestPathForSimpleUndirectedGraphUsingDijkstraAlgorithm()
        {
            var graph = new UndirectedGraph<object, Edge<object>>(true);
            object v1 = "vertex1";
            object v2 = "vertex2";
            object v3 = "vertex3";
            var e1 = new Edge<object>(v1, v2);
            var e2 = new Edge<object>(v2, v3);
            var e3 = new Edge<object>(v3, v1);
            graph.AddVertex(v1);
            graph.AddVertex(v2);
            graph.AddVertex(v3);
            graph.AddEdge(e1);
            graph.AddEdge(e2);
            graph.AddEdge(e3);

            var algorithm = new UndirectedDijkstraShortestPathAlgorithm<object, Edge<object>>(graph, edge => (double)1);
            var observer = new UndirectedVertexPredecessorRecorderObserver<object, Edge<object>>();
            using (observer.Attach(algorithm))
            {
                algorithm.Compute(v1);
            }

            IEnumerable<Edge<object>> path;
            observer.TryGetPath(v3, out path);

            foreach (var edge in path)
            {
                Console.WriteLine(edge);
            }
        }

		public static Graph Read(StreamReader stream)
		{
			int.Parse(stream.ReadLine());
			int E = int.Parse(stream.ReadLine());

			var graph = new Graph();

			for(int i = 0; i < E; ++i)
			{
				string[] r = stream.ReadLine().Trim().Split(' ');
				r = r.Where (x => x.Length > 0).ToArray();

				var edge = new Edge()
				{
					From = int.Parse(r[0]),
					To = int.Parse(r[1]),
					Weight = float.Parse(r[2]),
				};

				if(!graph.Vertices.ContainsKey(edge.From))
				{
					graph.Vertices[edge.From] = new List<Edge>();
				}
				graph.Vertices[edge.From].Add(edge);
			}

			return graph;
		}

        /// <summary>
        /// create a geometry edge, the geometry source and target have to be set already
        /// </summary>
        /// <param name="drawingEdge"></param>
        /// <param name="msaglGraph"></param>
        /// <returns></returns>
        static Core.Layout.Edge CreateGeometryEdgeAndAddItToGeometryGraph(Edge drawingEdge, GeometryGraph msaglGraph) {
            var msaglEdge = CreateGeometryEdgeFromDrawingEdge(drawingEdge);

            msaglGraph.Edges.Add(msaglEdge);
            
            return msaglEdge;
        }

        public void FisrstSampleInput()
        {
            int nodesCount = 4;

            var edges = new List<Edge>
            {
                new Edge(0, 1, 9),
                new Edge(0, 3, 4),
                new Edge(3, 1, 6),
                new Edge(3, 2, 11),
                new Edge(1, 2, 5)
            };

            var expectedEdges = new Edge[]
            {
                edges[1],
                edges[4],
                edges[2]
            };

            var actualEdges = KruskalAlgorithm.Kruskal(nodesCount, edges);

            CollectionAssert.AreEqual(expectedEdges, actualEdges);
            Assert.AreEqual(15, actualEdges.Sum(e => e.Weight));
        }