Exemplo n.º 1
0
        /// <summary>
        /// Fonction pour styliser un noeuds dans un graphe provenant de la fusion de 2 graphes qui groupe plusieurs noeuds
        /// </summary>
        /// <param name="node">Noeuds MSAGL à styliser</param>
        /// <param name="cmap">Color map pour les noeuds ayant été visités par les 2 graphes</param>
        /// <param name="cmap_first">Color map pour les noeuds ayant été visité seulement par le premier graphe</param>
        /// <param name="cmap_second">Color map pour les noeuds ayant été visité seulement par le second graphe</param>
        public void styleNodeMergedGrouped(Node node, ColorMap cmap, ColorMap cmap_first, ColorMap cmap_second)
        {
            this.defaultNodeStyle(node, cmap);

            int nodeSize = getNumberChildren(new HashSet <string>()) + 1;

            string groupedTooltip = "Nombre de noeuds : " + nodeSize.ToString();

            groupedTooltip += "\nNombre de noeuds visités : " + (getNumberVisitedChildren(new HashSet <string>()) + 1).ToString();
            groupedTooltip += "\nHeuristique max : " + childsMaxHeuristic(new HashSet <string>()).ToString();
            groupedTooltip += "\nHeuristique min : " + childsMinHeuristic(new HashSet <string>()).ToString();

            node.Attr.Tooltip = groupedTooltip;

            node.LabelText        = "";
            node.Attr.LabelMargin = (int)Math.Pow(nodeSize, 0.66) + 3;


            if (this.isVisited())
            {
                if (isVisitedBoth())
                {
                    node.LabelText      = order_visited.ToString() + "-" + order_visited_second.ToString();
                    node.Attr.FillColor = cmap.getColor(real_final_value);
                }
                else if (visited)
                {
                    node.LabelText      = order_visited.ToString();
                    node.Attr.FillColor = cmap_first.getColor(heuristic_value);
                }
                else
                {
                    node.LabelText      = order_visited_second.ToString();
                    node.Attr.FillColor = cmap_second.getColor(heuristic_value_second);
                }
            }
        }
Exemplo n.º 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">Booléen qui indique si on doit afficher le nom de l'arc</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(Color.Yellow, Color.Red, heuristicMax(), heuristicMin());


            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 <CustomNode, int> > queue = new Queue <Tuple <CustomNode, int> >();

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

            while (queue.Any())
            {
                Tuple <CustomNode, int> tuple = queue.Dequeue();
                CustomNode 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);

                actu.styleNode(msagl_source_node, cmap, profondeur == group_level);


                foreach (CustomEdge edge in actu.successors.Values)
                {
                    CustomNode dest = 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.in_selected_path || 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.in_selected_path)
                        {
                            next_profondeur = 0;
                        }

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

            return(graph);
        }