Exemple #1
0
        /// <summary>
        /// Retourne un Graph MSAGL comprenant tous les noeuds du graph, ou seulement les noeuds visités
        /// Le Graph MSAGL peut ensuite être affiché dans la vue
        /// </summary>
        /// <param name="only_visited">Inclure seulement les noeuds visité dans le visuel</param>
        /// <param name="edge_name">Afficher les nom des arcs dans la visualisation</param>
        /// <returns>Graph MSAGL pouvant être afficher dans la vue</returns>
        private Graph getVisualGraphClassic(bool only_visited, bool edge_name)
        {
            Graph graph = new Graph();

            ColorMap cmap        = new ColorMap(new Color(255, 255, 210, 210), Color.Red, realValueMax(), realValueMin());
            ColorMap cmap_first  = new ColorMap(new Color(255, 230, 255, 230), Color.Green, firstHeuristicMax(), firstheuristicMin());
            ColorMap cmap_second = new ColorMap(new Color(255, 240, 240, 255), Color.Blue, secondHeuristicMax(), secondHeuristicMin());

            foreach (CustomNodeMerged source in nodes.Values)
            {
                foreach (CustomEdge link in source.successors.Values)
                {
                    CustomNodeMerged dest = (CustomNodeMerged)link.dest;

                    // Si l'on ne veut afficher que les noeuds visités
                    if (only_visited && !dest.isVisited())
                    {
                        continue;
                    }

                    Edge msagl_edge = graph.AddEdge(source.id, dest.id);

                    Node msagl_source_node = msagl_edge.SourceNode;
                    Node msagl_dest_node   = msagl_edge.TargetNode;

                    source.styleNodeMerged(msagl_source_node, cmap, cmap_first, cmap_second);
                    dest.styleNodeMerged(msagl_dest_node, cmap, cmap_first, cmap_second);

                    // On change le style de l'arc en fonction des noeuds de départs et d'arrivés
                    link.styleEdge(msagl_edge, edge_name);
                }
            }

            return(graph);
        }
Exemple #2
0
        /// <summary>
        /// Retourne un Graph MSAGL avec les noeuds qui ne sont pas dans selected_path groupés
        /// </summary>
        /// <param name="only_visited">Inclure seulement les noeuds visité dans le visuel</param>
        /// <param name="edge_name">Afficher les nom des arcs dans la visualisation</param>
        /// <param name="group_level">A partir de quel niveau de profondeur du selected path on doit grouper les noeuds</param>
        /// <returns>Graph MSAGL pouvant être afficher dans la vue</returns>
        private Graph getVisualGraphGrouped(bool only_visited, bool edge_name, int group_level)
        {
            Graph graph = new Graph();

            ColorMap cmap        = new ColorMap(new Color(255, 255, 210, 210), Color.Red, realValueMax(), realValueMin());
            ColorMap cmap_first  = new ColorMap(new Color(255, 230, 255, 230), Color.Green, firstHeuristicMax(), firstheuristicMin());
            ColorMap cmap_second = new ColorMap(new Color(255, 240, 240, 255), Color.Blue, secondHeuristicMax(), secondHeuristicMin());

            HashSet <string> visited = new HashSet <string>();

            // Parcours en largeur du graph pour afficher seulement les noeuds à un certains niveau de distance du selected path
            // Les autres noeuds sont groupés en un seul noeuds
            // L'entier dans le tuple correspond au niveau de distance du selected path
            Queue <Tuple <CustomNodeMerged, int> > queue = new Queue <Tuple <CustomNodeMerged, int> >();

            queue.Enqueue(new Tuple <CustomNodeMerged, int>(root, 0));

            while (queue.Any())
            {
                Tuple <CustomNodeMerged, int> tuple = queue.Dequeue();
                CustomNodeMerged actu = tuple.Item1;
                int profondeur        = tuple.Item2;

                if (visited.Contains(actu.id))
                {
                    continue;
                }
                visited.Add(actu.id);

                Node msagl_source_node = graph.AddNode(actu.id);

                if (profondeur == group_level)
                {
                    actu.styleNodeMergedGrouped(msagl_source_node, cmap, cmap_first, cmap_second);
                }
                else
                {
                    actu.styleNodeMerged(msagl_source_node, cmap, cmap_first, cmap_second);
                }


                foreach (CustomEdge edge in actu.successors.Values)
                {
                    CustomNodeMerged dest = (CustomNodeMerged)edge.dest;

                    if (only_visited && !dest.isVisited())
                    {
                        continue;
                    }

                    // On ajoute que les noeuds du selected path ou avec un profondeur inférieur à la profondeur max
                    if (dest.inSelectedPath() || profondeur < group_level)
                    {
                        Edge msagl_edge = graph.AddEdge(actu.id, dest.id);

                        edge.styleEdge(msagl_edge, edge_name);
                        int next_profondeur = profondeur + 1;

                        if (dest.inSelectedPath())
                        {
                            next_profondeur = 0;
                        }

                        queue.Enqueue(new Tuple <CustomNodeMerged, int>(dest, next_profondeur));
                    }
                }
            }

            return(graph);
        }