Exemplo n.º 1
0
        private void RemoveEdgeOrSplitVertex(CommunityStructure tempCS)
        {
            double maxEdge = double.MinValue;
            Edge   e       = null;

            foreach (KeyValuePair <Edge, double> keypair in edgeBetweenness)
            {
                if (keypair.Value >= maxEdge)
                {
                    maxEdge = keypair.Value;
                    e       = keypair.Key;
                }
            }

            // tìm danh sách các đỉnh có vertex betweenness lớn hơn max edge betweeness
            List <Node> CandidateNode = new List <Node>();

            foreach (KeyValuePair <Node, double> keypair in vertexBetweenness)
            {
                if (keypair.Value > maxEdge && keypair.Key.AdjacencyNodes.Count >= 4)
                {
                    CandidateNode.Add(keypair.Key);
                }
            }

            if (CandidateNode.Count == 0)
            {
                RemoveEdge(e, tempCS);
            }
            else
            {
                // tính split betweenness của các đỉnh trong danh sách trên
                PairBetweenness maxSplitbetweenness = CalculatePairBetweenness(CandidateNode);

                if (maxSplitbetweenness.SplitBetweenness >= maxEdge)
                {
                    SplitVertex(maxSplitbetweenness, tempCS);
                }
                else
                {
                    RemoveEdge(e, tempCS);
                }
            }
        }
Exemplo n.º 2
0
        private DGraph SplitVertex(PairBetweenness pairBetweenness, CommunityStructure pTempCS)
        {
            countSplit++;
            string[] labelA = pairBetweenness.Clique[0].Label.Split('_');
            string[] labelB = pairBetweenness.Clique[1].Label.Split('_');

            Node splitNode = pairBetweenness.Vertex;

            // Tách nút splitNode thành 2 nút
            Node splitedNodeA = new Node(splitNode.Label + "-" + string.Join("-", labelA), new Point(splitNode.Location.X + Format.Setting.NodeSize, splitNode.Location.Y + Format.Setting.NodeSize));
            Node splitedNodeB = new Node(splitNode.Label + "-" + string.Join("-", labelB), new Point(splitNode.Location.X - Format.Setting.NodeSize, splitNode.Location.Y - Format.Setting.NodeSize));

            WriteLog("Split: " + splitedNodeA.Label + "/" + splitedNodeB.Label + "\t" + pairBetweenness.SplitBetweenness.ToString("0.00"));

            // xóa nút splitNode
            graph.Nodes.Remove(splitNode);
            vertexBetweenness.Remove(splitNode);

            // Thêm 2 nút mới tạo vào đồ thị
            graph.Nodes.Add(splitedNodeA);
            graph.Nodes.Add(splitedNodeB);
            vertexBetweenness.Add(splitedNodeA, 0);
            vertexBetweenness.Add(splitedNodeB, 0);

            foreach (Edge e in splitNode.AdjacencyEdges)
            {
                Edge newe = null;
                if (labelA.Contains(e.NodeA.Label))
                {
                    newe = graph.CreateLink(e.NodeA, splitedNodeA);
                }
                else if (labelA.Contains(e.NodeB.Label))
                {
                    newe = graph.CreateLink(e.NodeB, splitedNodeA);
                }
                else if (labelB.Contains(e.NodeA.Label))
                {
                    newe = graph.CreateLink(e.NodeA, splitedNodeB);
                }
                else if (labelB.Contains(e.NodeB.Label))
                {
                    newe = graph.CreateLink(e.NodeB, splitedNodeB);
                }

                graph.Edges.Remove(e);
                edgeBetweenness.Remove(e);
                edgeBetweenness.Add(newe, 0);

                if (e.NodeA != splitNode)
                {
                    e.NodeA.AdjacencyEdges.Remove(e);
                    e.NodeA.AdjacencyNodes.Remove(splitNode);
                }
                else
                {
                    e.NodeB.AdjacencyEdges.Remove(e);
                    e.NodeB.AdjacencyNodes.Remove(splitNode);
                }
            }

            foreach (DGraph subgraph in pTempCS)
            {
                if (subgraph.Nodes.Contains(splitNode))
                {
                    return(subgraph);
                }
            }
            return(null);
        }
Exemplo n.º 3
0
        private PairBetweenness CalculatePairBetweenness(List <Node> CandidateNode)
        {
            Dictionary <Node, PairBetweenness> pair = new Dictionary <Node, PairBetweenness>();

            // tạo clique của từng pair
            foreach (Node node in CandidateNode)
            {
                PairBetweenness p = new PairBetweenness();
                p.VertexBetweenness = this.vertexBetweenness;
                p.Graph             = this.graph;
                p.Vertex            = node;

                for (int i = 0; i < node.AdjacencyNodes.Count; i++)
                {
                    p.Clique.Add(node.AdjacencyNodes[i]);
                    for (int j = i + 1; j < node.AdjacencyNodes.Count; j++)
                    {
                        Edge e = new Edge(node.AdjacencyNodes[i], node.AdjacencyNodes[j]);
                        p.Edges.Add(e);
                        p.Values.Add(e, 0);
                    }
                }
                pair.Add(node, p);
            }

            #region tinh_pair

            for (int i = 0; i < graph.Nodes.Count; i++)
            {
                Node a = graph.Nodes[i];
                for (int j = 0; j < graph.Nodes.Count; j++) // điều này không tối ưu
                {
                    if (i == j)
                    {
                        continue;
                    }
                    Node b = graph.Nodes[j];
                    List <List <TreeNode <Node> > > paths = GetAllShortestPath(graph, a, b);
                    double p = 1.0 / paths.Count;

                    foreach (List <TreeNode <Node> > path in paths)
                    {
                        for (int _i = 1; _i < path.Count - 1; _i++)
                        {
                            if (pair.ContainsKey(path[_i].Value))
                            {
                                pair[path[_i].Value].SetValue(path[_i - 1].Value, path[_i + 1].Value, p);
                            }
                        }
                    }
                }
            }

            #endregion tinh_pair

            double          max     = double.MinValue;
            PairBetweenness maxPair = null;
            foreach (KeyValuePair <Node, PairBetweenness> keypair in pair)
            {
                keypair.Value.CalculateSplitBetweenness();
                if (maxPair == null)
                {
                    maxPair = keypair.Value;
                    max     = maxPair.SplitBetweenness;
                    continue;
                }
                if (keypair.Value.SplitBetweenness > max)
                {
                    max     = keypair.Value.SplitBetweenness;
                    maxPair = keypair.Value;
                }
            }

            return(maxPair);
        }