Python FigureCanvasTkAgg.pack方法代码示例

# 需要导入模块: from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg [as 别名]
# 或者: from matplotlib.backends.backend_tkagg.FigureCanvasTkAgg import pack [as 别名]
class FigureWidget:
    def __init__(self, parent, fig):
        self.FigureRoot = parent
        self.FigureRoot.title("Time Series Plot")
        self.canvas = FigureCanvasTkAgg(fig, master=self.FigureRoot)
        self.canvas = self.canvas.get_tk_widget()
        self.canvas.pack(fill=BOTH,expand=YES)

    def UpdatePlot(self, fig):
        self.canvas.destroy()
        self.canvas = FigureCanvasTkAgg(fig, master=self.FigureRoot)
        self.canvas = self.canvas.get_tk_widget()
        self.canvas.pack(fill=BOTH,expand=YES)

    def destroy(self):
        self.FigureRoot.destroy()

# 需要导入模块: from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg [as 别名]
# 或者: from matplotlib.backends.backend_tkagg.FigureCanvasTkAgg import pack [as 别名]
class LeftFrame(Frame):
    """
    Classe pour la "frame" qui sera la partie gauche de l'insterface.
    Celle-ci accueillera les grilles et les plots des statistiques
    """
    def __init__(self, parent):
        Frame.__init__(self, parent)
        self.parent = parent
        self.canvas = None
        self.nb_colonnes = 0
        self.nb_lignes = 0
        self.pas_colonne = 0
        self.pas_ligne = 0
        self.initialize()

    def initialize(self):
        self.affiche_grille(self.parent.grilles[0])
        self.rescale()

    def clean(self):
        """
        Vide le contenu de la frame en supprimant les objets contenus dans celle-ci,
        en vue de le remplacer par autre chose
        """
        for i in self.winfo_children():
            i.destroy()

    def rescale(self):
        """
        Change l'échelle prise par la fenêtre pour un affichage plus pratique,
        on n'a alors plus qu'à spécifier les coordonnées comme dans la grille et cette fonction repositionne tout
        pour que l'affichage fasse la taille de la fenêtre
        """
        if self.canvas is not None and self.pas_colonne != 0 and self.pas_ligne != 0:
            self.canvas.scale(ALL, -1, -1, self.pas_colonne, self.pas_ligne)

    def afficher_resultat(self, resultat, tps_creat=None, tps_calc=None):
        """
        Affiche pour chaque instance du fichier d'entrée:
        la chaîne de caractère représentant le chemin emprunté par le robot,
        ainsi que le temps de création du graphe et le temps de calcul de ce résultat
        :param resultat: liste des chaines de caractères résultats du calcul du chemin le plus rapide des instances
        :param tps_creat: temps de création du graphe pour chaque instance
        :param tps_calc: temps de calcul du chemin le plus rapide pour chaque instance (sans la création du graphe)
        :type resultat: list
        :type tps_creat: list
        :type tps_calc: list
        """
        self.clean()
        if tps_creat:
            label = Label(self,
                          text="La moyenne du temps de création de graphe sur ce fichier est : " +
                               str(np.mean(tps_creat)) + " secondes")
            label.pack()
        if tps_calc:
            label = Label(self,
                          text="La moyenne du temps de calcul du chemin le plus rapide sur ce fichier est : " +
                               str(np.mean(tps_calc)) + " secondes")
            label.pack()
        for i in range(len(resultat)):
            label = Label(self, text="Problème n°"+str(i))
            label.pack()
            label_res = Label(self, text=resultat[i])
            label_res.pack()
            if tps_creat:
                label_tps_creat = Label(self, text="La création du graphe a pris " + str(tps_creat[i]) + " secondes")
                label_tps_creat.pack()
            if tps_calc:
                label_tps_calc = Label(self, text="Le calcul de la solution a pris " + str(tps_calc[i]) + " secondes")
                label_tps_calc.pack()

    def affiche_grille(self, grille):  # Ne pas oublier de faire un rescale après appel à cette fonction !!!
        """
        Affiche la grille passée en paramètre dans la partie gauche de la fenêtre
        :param grille: grille représentant le dépôt constituée de 3 éléments :
            - un tuple pour le nombre de lignes et de colonnes
            - une liste représentant les lignes du dépôt avec les '0' et '1'
            - une liste pour les coordonnées du point de départ, d'arrivée, et l'orientation du robot au départ
        :type grille: list
        """
        self.clean()
        # Récupération des éléments de la grille
        self.nb_lignes, self.nb_colonnes = grille[0]
        lignes = grille[1]
        ligne = grille[2]
        self.canvas = Canvas(self, width=leftframewidth, height=leftframeheight)
        # Récupération des données du problème
        self.pas_colonne = leftframewidth//(self.nb_colonnes + 2)
        self.pas_ligne = leftframeheight//(self.nb_lignes + 2)
        rayon = 1/2  # rayon des cercles du robot au départ et à l'arrivée
        # Dessin du quadrillage
        for i in range(0, self.nb_lignes):
            for j in range(0, self.nb_colonnes):
                if lignes[i][j] == '0':
                    rectangle(self.canvas, j, i, j+1, i+1)
                else:
                    rectangle(self.canvas, j, i, j+1, i+1, color=couleur_obstacles)
        # Dessin du point de départ du robot avec sa flèche
        dessine_depart(self.canvas, int(ligne[1]), int(ligne[0]), rayon, ligne[-1])
        # Dessin du point d'arrivée du robot
#.........这里部分代码省略.........

# 需要导入模块: from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg [as 别名]
# 或者: from matplotlib.backends.backend_tkagg.FigureCanvasTkAgg import pack [as 别名]
class LakeSurvey(tk.Frame):

    def __init__(self, parent, controller):
        tk.Frame.__init__(self, parent)

        self.titleframe = tk.Frame(self)
        self.titleframe.pack()

        self.comboframe = tk.Frame(self)
        self.comboframe.pack()

        self.canvasframe = tk.Frame(self)
        self.canvasframe.pack()


        self.label = tk.Label(self.titleframe, text='Fish survey for: '+DEFAULT_LAKE, font=LARGE_FONT)
        self.label.pack(anchor='center', pady=10)

        self.combovals = data['lakeName'].unique()
        self.combovals.sort()
        self.var = StringVar()
        self.lakecombo = ttk.Combobox(self.comboframe, textvariable=self.var)
        self.lakecombo.config(values=list(self.combovals))
        self.lakecombo.bind('<<ComboboxSelected>>', lambda x: change_lake(self.var.get()))
        self.lakecombo.pack(side=tk.LEFT, anchor='center', padx=10, pady=10)

        self.button1 = ttk.Button(self.comboframe, text='Refresh',
                                  command=lambda: self.refresh_button())
        self.button1.pack(side=tk.LEFT, anchor='center')

        self.button2 = ttk.Button(self.comboframe, text='Home',
                                  command=lambda: controller.show_frame(StartPage))
        self.button2.pack(side=tk.LEFT, anchor='center')

        self.canvasframe.canvas = self.lake_plot()
        self.canvas.pack(fill=tk.BOTH, expand=True, padx=100)

    def lake_plot(self):
        f = plt.figure()
        a = f.add_subplot(111)

        q1 = data[data['lakeName'] == DEFAULT_LAKE]
        df = q1[['avgLen', 'avgWt', 'fishType']]

        n = np.arange(len(df['fishType']))

        a.clear()
        a.bar(n, df['avgLen'], DEFAULT_WIDTH, label='Average Length')
        a.bar(n+DEFAULT_WIDTH, df['avgWt'], DEFAULT_WIDTH, label='Average Weight', color='g')
        a.set_xticks(n+DEFAULT_WIDTH)
        a.set_xticklabels(list(df['fishType']),rotation=0, fontsize='small')
        a.legend(bbox_to_anchor=(.8, 1.02), loc=8, ncol=2)
        a.grid(False)

        self.canvas = FigureCanvasTkAgg(f, self)
        self.canvas = self.canvas.get_tk_widget()

        return self.canvas

    def refresh_button(self):
        self.label.config(text='Fish survey for: '+DEFAULT_LAKE)
        self.canvas.destroy()
        self.canvasframe.canvas = self.lake_plot()
        self.canvas.pack(fill=tk.BOTH, expand=True, padx=100)

    def set_option(self):
        global DEFAULT_LAKE
        DEFAULT_LAKE = self.lakecombo.values.get()