mpl_properties.py

   1 import pylab as P
   2 import pygtk
   3 import gtk
   4 import gobject
   5
   6 def print_fig_prop(fig):
   7     for ind_ax, ax in enumerate(P.figure(fig).axes):
   8         print "*** Axe %d ***"%ind_ax
   9         print "Xmin : %g"%ax.get_xlim()[0]
  10         print "Xmax : %g"%ax.get_xlim()[1]
  11         print "Ymin : %g"%ax.get_ylim()[0]
  12         print "Ymax : %g"%ax.get_ylim()[1]
  13         print "Fontsize (X) : %g"%ax.get_xticklabels()[0].get_fontsize()
  14         print "Fontsize (Y) : %g"%ax.get_yticklabels()[0].get_fontsize()
  15         print "Title : " + ax.title.get_text()
  16         print "Title fontsize : %g"%ax.title.get_fontsize()
  17         print "X label : " + ax.xaxis.get_label().get_text()
  18         print "X label fontsize : %g"%ax.xaxis.get_label().get_fontsize()
  19         print "Y label : " + ax.yaxis.get_label().get_text()
  20         print "Y label fontsize : %g"%ax.yaxis.get_label().get_fontsize()
  21
  22         for ind_line, line in enumerate(ax.lines):
  23             print "  *** Line %d ***"%ind_line
  24             print "  Style : " + line.get_linestyle()
  25             print "  Marker : " + line.get_marker()
  26             print "  Line Width : %.1f"%line.get_linewidth()
  27             print "  Color : " + line.get_color()
  28         for ind_im, im in enumerate(ax.images):
  29             print "  *** Image %d ***"%ind_im
  30             print "  Colormap : " + im.cmap.name
  31             print "  Interpolation : " + im.get_interpolation()
  32             print "  Extent : [%g, %g, %g, %g]"%(im.get_extent()[0],im.get_extent()[1],im.get_extent()[2],im.get_extent()[3], )
  33
  34 class properties:
  35
  36     def row_activated(self, treeview):
  37         model, iter = treeview.get_selection().get_selected()
  38         type = model.get_value(iter, 1)
  39         self.type_selected = type
  40         obj = model.get_value(iter,2)
  41         self.selected = model.get_value(iter,2)
  42         self.fig = model.get_value(iter, 3)
  43         if type == 'line':
  44             self.display_line(obj)
  45         elif type == 'axe':
  46             self.display_axe(obj)
  47         elif type == 'image':
  48             self.display_image(obj)
  49         elif type == 'figure':
  50             self.display_figure(obj)
  51         elif type == 'text':
  52             self.display_text(obj)
  53
  54     def get_value(self, obj, name):
  55         if name == 'linestyle':
  56             return obj.get_linestyle()
  57         elif name == 'marker':
  58             return obj.get_marker()
  59         elif name == 'linewidth':
  60             return obj.get_linewidth()
  61         elif name == 'color':
  62             return obj.get_color()
  63         elif name == 'xmin':
  64             return obj.get_xlim()[0]
  65         elif name == 'xmax':
  66             return obj.get_xlim()[1]
  67         elif name == 'ymin':
  68             return obj.get_ylim()[0]
  69         elif name == 'ymax':
  70             return obj.get_ylim()[1]
  71         elif name == 'title':
  72             return obj.title.get_text()
  73         elif name == 'titlefontsize':
  74             return obj.title.get_fontsize()
  75         elif name == 'xlabel':
  76             return obj.xaxis.get_label().get_text()
  77         elif name == 'ylabel':
  78             return obj.yaxis.get_label().get_text()
  79         elif name == 'xfontsize':
  80             return obj.xaxis.get_ticklabels()[0].get_fontsize()
  81         elif name == 'yfontsize':
  82             return obj.yaxis.get_ticklabels()[0].get_fontsize()
  83         elif name == 'xlabelfontsize':
  84             return obj.xaxis.get_label().get_fontsize()
  85         elif name == 'ylabelfontsize':
  86             return obj.yaxis.get_label().get_fontsize()
  87         elif name == 'figwidth':
  88 ##            return obj.window.get_size()[0]
  89             return obj.get_figwidth()
  90         elif name == 'figheight':
  91 ##            return obj.window.get_size()[1]
  92             return obj.get_figheight()
  93         elif name == 'xpos':
  94             return obj.get_position()[0]
  95         elif name == 'ypos':
  96             return obj.get_position()[1]
  97         elif name == 'width':
  98             return obj.get_position()[2]
  99         elif name == 'height':
 100             return obj.get_position()[3]
 101         elif name == 'xbegin':
 102             return obj.get_extent()[0]
 103         elif name == 'xend':
 104             return obj.get_extent()[1]
 105         elif name == 'ybegin':
 106             return obj.get_extent()[2]
 107         elif name == 'yend':
 108             return obj.get_extent()[3]
 109         elif name == 'cmap':
 110             return obj.cmap.name
 111         elif name == 'interp':
 112             return obj.get_interpolation()
 113         elif name == 'label':
 114             return obj.get_label()
 115         elif name == 'textx':
 116             return obj.get_position()[0]
 117         elif name == 'texty':
 118             return obj.get_position()[1]
 119         elif name == 'text':
 120             return obj.get_text()
 121         elif name == 'textfontsize':
 122             return obj.get_fontsize()
 123         elif name == 'textrotation':
 124             return obj.get_rotation()
 125         elif name == 'markersize':
 126             return obj.get_markersize()
 127         elif name == 'markerfacecolor':
 128             return obj.get_markerfacecolor()
 129         elif name == 'markeredgecolor':
 130             return obj.get_markeredgecolor()
 131         elif name == 'markeredgewidth':
 132             return obj.get_markeredgewidth()
 133
 134
 135     def set_value(self, obj, name, value):
 136         if name == 'linestyle':
 137             obj.set_linestyle(value)
 138         elif name == 'marker':
 139             obj.set_marker(value)
 140         elif name == 'linewidth':
 141             obj.set_linewidth(float(value))
 142         elif name == 'color':
 143             obj.set_color(value)
 144         elif name == 'xmin' or name == 'xmax':
 145             obj.set_xlim([float(self.param['xmin'].get_text()), float(self.param['xmax'].get_text())])
 146         elif name == 'ymin' or name == 'ymax':
 147             obj.set_ylim([float(self.param['ymin'].get_text()), float(self.param['ymax'].get_text())])
 148         elif name == 'title':
 149             obj.title.set_text(value)
 150         elif name == 'titlefontsize':
 151             obj.title.set_fontsize(float(value))
 152         elif name == 'xlabel':
 153             obj.xaxis.get_label().set_text(value)
 154         elif name == 'ylabel':
 155             obj.yaxis.get_label().set_text(value)
 156         elif name == 'xfontsize':
 157             for tick in obj.xaxis.get_ticklabels():
 158                 tick.set_fontsize(float(value))
 159         elif name == 'yfontsize':
 160             for tick in obj.yaxis.get_ticklabels():
 161                 tick.set_fontsize(float(value))
 162         elif name == 'xlabelfontsize':
 163             obj.xaxis.get_label().set_fontsize(float(value))
 164         elif name == 'ylabelfontsize':
 165             obj.yaxis.get_label().set_fontsize(float(value))
 166 ##        elif name == 'figwidth' or name == 'figheight':
 167 ##            obj.resize(int(self.param['figwidth'].get_text()),int(self.param['figheight'].get_text()) )
 168         elif name == 'figwidth':
 169             obj.set_figwidth(float(value))
 170         elif name == 'figheight':
 171             obj.set_figheight(float(value))
 172         elif name == 'xpos' or name =='ypos' or name == 'width' or name == 'height':
 173             a = float(self.param['xpos'].get_text())
 174             b = float(self.param['ypos'].get_text())
 175             c = float(self.param['width'].get_text())
 176             d = float(self.param['height'].get_text())
 177             obj.set_position([a,b,c,d])
 178         elif name == 'cmap':
 179             obj.set_cmap(getattr(P.cm, value))
 180         elif name == 'interp':
 181             obj.set_interpolation(value)
 182         elif name == 'label':
 183             obj.set_label(value)
 184         elif name == 'textx':
 185             obj.set_x(float(value))
 186         elif name == 'texty':
 187             obj.set_y(float(value))
 188         elif name == 'text':
 189             obj.set_text(value)
 190         elif name == 'textfontsize':
 191             obj.set_fontsize(float(value))
 192         elif name == 'textrotation':
 193             obj.set_rotation(float(value))
 194         elif name == 'markersize':
 195             obj.set_markersize(float(value))
 196         elif name == 'markerfacecolor':
 197             obj.set_markerfacecolor(value)
 198         elif name == 'markeredgecolor':
 199             obj.set_markeredgecolor(value)
 200         elif name == 'markeredgewidth':
 201             obj.set_markeredgewidth(float(value))
 202
 203     def remove(self, widget):
 204         self.paramtable.remove(widget)
 205
 206     def add_row(self, name, title, obj, line):
 207         tmp = gtk.Label(title)
 208         tmp.show()
 209         self.paramtable.attach(tmp,0,1,line,line+1, yoptions=gtk.FILL)
 210
 211         default = self.get_value(obj, name)
 212 ##         if default == None or default == 'None':
 213 ##             default = ''
 214         if not self.param_treestore.has_key(name):
 215             self.param[name] = gtk.Entry(255)
 216             self.param[name].set_text(str(default))
 217             self.param[name].connect("activate", self.apply)
 218         else:
 219             self.param[name] = gtk.ComboBox(self.param_treestore[name])
 220             cell = gtk.CellRendererText()
 221             self.param[name].pack_start(cell, True)
 222             self.param[name].add_attribute(cell, 'text', 0)
 223             ii=0
 224             while self.param_treestore[name][ii][0] != default:
 225                 ii = ii+1
 226             self.param[name].set_active(ii)
 227             self.param[name].connect("changed", self.apply)
 228         self.param[name].show()
 229         self.paramtable.attach(self.param[name], 1, 2, line, line+1, yoptions=gtk.FILL)
 230
 231     def display_line(self, line):
 232         self.paramtable.foreach(self.remove)
 233         self.param.clear()
 234         self.paramtable.resize(2, len(self.param_lines_order))
 235         for ii, name in enumerate(self.param_lines_order):
 236             self.add_row(name, self.param_names[name], line, ii)
 237
 238     def display_axe(self, ax):
 239         self.paramtable.foreach(self.remove)
 240         self.param.clear()
 241         self.paramtable.resize(2, len(self.param_axe_order))
 242         for ii,name in enumerate(self.param_axe_order):
 243             self.add_row(name, self.param_names[name], ax, ii)
 244
 245     def display_figure(self, figure):
 246         self.paramtable.foreach(self.remove)
 247         self.param.clear()
 248         self.paramtable.resize(2, len(self.param_figure_order))
 249         for ii, name in enumerate(self.param_figure_order):
 250             self.add_row(name, self.param_names[name], figure, ii)
 251
 252     def display_text(self, text):
 253         self.paramtable.foreach(self.remove)
 254         self.param.clear()
 255         self.paramtable.resize(2, len(self.param_text_order))
 256         for ii, name in enumerate(self.param_text_order):
 257             self.add_row(name, self.param_names[name], text, ii)
 258
 259     def display_image(self, im):
 260         self.paramtable.foreach(self.remove)
 261         self.param.clear()
 262         self.paramtable.resize(2, len(self.param_image_order))
 263         for ii, name in enumerate(self.param_image_order):
 264             self.add_row(name, self.param_names[name], im, ii)
 265
 266     def apply(self, widget):
 267         obj = self.selected
 268         for name, button in self.param.items():
 269             if not self.param_treestore.has_key(name):
 270                 value = button.get_text()
 271             else:
 272                 iter = button.get_active_iter()
 273                 value = self.param_treestore[name].get_value(iter, 0)
 274             self.set_value(obj, name, value)
 275         P.figure(self.fig)
 276         P.draw()
 277         self.row_activated(self.treeview)
 278
 279     def save(self, widget):
 280         model, iter = self.treeview.get_selection().get_selected()
 281         if self.type_selected == 'line':
 282             line = model.get_value(iter,2)
 283             x = P.transpose(P.array([line.get_xdata(), line.get_ydata()]))
 284             fileselection = gtk.FileSelection('Save ' + model.get_value(iter,0) + ' data in...')
 285             fileselection.ok_button.connect("clicked", self.go_save, fileselection, x)
 286             fileselection.cancel_button.connect("clicked", lambda w: fileselection.destroy())
 287             fileselection.show()
 288     def go_save(self, widget, win, data):
 289         name = win.get_filename()
 290         P.save(name, data)
 291         win.destroy()
 292
 293     def delete(self, widget):
 294         model, iter = self.treeview.get_selection().get_selected()
 295         if self.type_selected=='axe':
 296             P.delaxes(self.selected)
 297             P.figure(self.fig)
 298             P.draw()
 299         elif self.type_selected=='figure':
 300             P.close(self.fig)
 301         elif self.type_selected=='line':
 302             axe = model.get_value(model.iter_parent(iter), 2)
 303             del axe.lines[model.get_value(iter, 4)]
 304             P.figure(self.fig)
 305             P.draw()
 306         elif self.type_selected=='image':
 307             axe = model.get_value(model.iter_parent(iter), 2)
 308             del axe.images[model.get_value(iter, 4)]
 309             P.figure(self.fig)
 310             P.draw()
 311         elif self.type_selected=='text':
 312             axe = model.get_value(model.iter_parent(iter), 2)
 313             del axe.texts[model.get_value(iter, 4)]
 314             P.figure(self.fig)
 315             P.draw()
 316         self.treestore.remove(iter)
 317         self.paramtable.foreach(self.remove)
 318         self.param.clear()
 319         self.update(None)
 320
 321     def update(self, widget):
 322         self.treestore.clear()
 323         for figure in P.matplotlib._pylab_helpers.Gcf.get_all_fig_managers():
 324             fig = figure.num
 325             iter_fig = self.treestore.append(None, ['Figure %d'%fig, 'figure' ,P.figure(fig), fig, fig])
 326             for ind_ax, ax in enumerate(P.figure(fig).axes):
 327                 iter_ax = self.treestore.append(iter_fig, ['Axe %d'%ind_ax, 'axe' ,ax, fig, ind_ax])
 328                 for ind_line, line in enumerate(ax.lines):
 329                     iter = self.treestore.append(iter_ax, ['Line %d'%ind_line, 'line', line, fig, ind_line])
 330                 for ind_im, im in enumerate(ax.images):
 331                     iter = self.treestore.append(iter_ax, ['Image %d'%ind_im, 'image',im, fig, ind_im])
 332                 for ind_text, text in enumerate(ax.texts):
 333                     iter = self.treestore.append(iter_ax, ['Text %d'%ind_text, 'text', text, fig, ind_text])
 334         try:
 335             self.fig=fig
 336         except:
 337             self.window.destroy()
 338
 339     def copy(self, widget):
 340         model, iter = self.treeview.get_selection().get_selected()
 341         type_to_copy = model.get_value(iter, 1)
 342         element_to_copy = model.get_value(iter, 2)
 343         if type_to_copy == 'figure':
 344             return
 345         self.wincopy = gtk.Window(gtk.WINDOW_TOPLEVEL)
 346         self.wincopy.set_transient_for(self.window)
 347         self.wincopy.set_modal(True)
 348         self.wincopy.set_title('Copy ' + model.get_value(iter, 0) + ' to...')
 349         self.wincopy.set_default_size(200,100)
 350         vbox = gtk.VBox()
 351         self.wincopy.add(vbox)
 352         scroll = gtk.ScrolledWindow()
 353         scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
 354         vbox.pack_start(scroll)
 355         model_filter = model.filter_new()
 356         model_filter.set_visible_func(self.visible_model, type_to_copy)
 357         self.treeview_copy = gtk.TreeView(model_filter)
 358         renderer = gtk.CellRendererText()
 359         column = gtk.TreeViewColumn('Object ID', renderer, text=0)
 360         self.treeview_copy.set_headers_visible(False)
 361         self.treeview_copy.append_column(column)
 362         self.treeview_copy.show()
 363         scroll.add(self.treeview_copy)
 364         scroll.show()
 365         hbox = gtk.HBox()
 366         vbox.pack_start(hbox)
 367         button = gtk.Button('Cancel')
 368         button.connect("clicked", self.close_copy)
 369         button.show()
 370         hbox.pack_start(button)
 371         button = gtk.Button('Copy')
 372         button.connect("clicked", self.do_copy, type_to_copy, element_to_copy)
 373         button.show()
 374         hbox.pack_start(button)
 375         hbox.show()
 376         vbox.show()
 377         self.wincopy.show()
 378
 379     def do_copy(self, widget, type, element):
 380         model_to, iter_to = self.treeview_copy.get_selection().get_selected()
 381         dest = model_to.get_value(iter_to, 2)
 382         if type == 'line':
 383             line = P.Line2D(element.get_xdata(), element.get_ydata(),
 384                             linewidth=element.get_linewidth(), linestyle=element.get_linestyle(),
 385                             color=element.get_color(), marker=element.get_marker())
 386             dest.add_line(line)
 387         elif type == 'image':
 388             dest.images.append(element)
 389         elif type == 'text':
 390             dest.text(element.get_position()[0], element.get_position()[1],
 391                       element.get_text(), fontsize=element.get_fontsize())
 392         self.close_copy(None)
 393         self.update(None)
 394
 395     def close_copy(self, widget):
 396         self.wincopy.destroy()
 397
 398     def visible_model(self, model, iter, data):
 399         type = model.get_value(iter, 1)
 400         if data == 'axe':
 401             if type == 'figure':
 402                 return True
 403             else:
 404                 return False
 405         else:
 406             if type == 'figure' or type == 'axe':
 407                 return True
 408             else:
 409                 return False
 410
 411     def end_of_program(self, widget, data=None):
 412         if P.backends.backend[:3]=='GTK':
 413             self.window.destroy()
 414         else:
 415             gtk.main_quit()
 416
 417     def __init__(self):
 418         self.selected=None
 419         self.param={}
 420         marker_types = ['.', ',', 'o', '^', 'v', '<', '>', 's', '+', 'x',
 421                         'D', 'd', '1', '2', '3', '4', 'h', 'H',
 422                         'p', '|', '_', 'None']
 423         marker_treestore = gtk.TreeStore(str)
 424         for marker in marker_types:
 425             marker_treestore.append(None, [marker])
 426         line_types = ['-', '--', '-.', ':', 'steps', 'None']
 427         line_treestore = gtk.TreeStore(str)
 428         [line_treestore.append(None, [ii]) for ii in line_types]
 429         self.param_names = {'label': 'Label',
 430                             'linestyle': 'Line style',
 431                             'marker': 'Marker',
 432                             'markersize': 'Marker Size',
 433                             'markerfacecolor': 'Marker Face Color',
 434                             'markeredgecolor': 'Marker Edge Color',
 435                             'markeredgewidth': 'Marker Edge Width',
 436                             'linewidth': 'Line Width',
 437                             'color': 'Color',
 438                             'cmap': 'Colormap',
 439                             'interp': 'Interpolation',
 440                             'label': 'Label',
 441                             'xpos': 'X position',
 442                             'ypos': 'Y position',
 443                             'width': 'Width',
 444                             'height': 'Height',
 445                             'xmin': 'X min',
 446                             'xmax': 'X max',
 447                             'ymin': 'Y min',
 448                             'ymax': 'Y max',
 449                             'title': 'Title',
 450                             'titlefontsize': 'Title fontsize',
 451                             'xlabel': 'X label',
 452                             'ylabel': 'Y label',
 453                             'xlabelfontsize': 'Fontsize (X label)',
 454                             'ylabelfontsize': 'Fontsize (Y label)',
 455                             'xfontsize': 'Fontsize (X ticks)',
 456                             'yfontsize': 'Fontsize (Y ticks)',
 457                             'figwidth': 'Width',
 458                             'figheight': 'Height',
 459                             'textx': 'X position',
 460                             'texty': 'Y position',
 461                             'text': 'Text',
 462                             'textfontsize': 'Fontsize',
 463                             'textrotation': 'Rotation'}
 464
 465         self.param_lines_order = ['label', 'linestyle', 'color', 'linewidth',
 466                                   'marker', 'markersize', 'markerfacecolor', 'markeredgecolor', 'markeredgewidth']
 467         self.param_image_order = ['label', 'cmap', 'interp']
 468         self.param_axe_order = ['xpos', 'ypos', 'width', 'height',
 469                                 'xmin', 'xmax', 'ymin', 'ymax',
 470                                 'title', 'titlefontsize',
 471                                 'xlabel', 'xlabelfontsize',
 472                                 'ylabel', 'ylabelfontsize',
 473                                 'xfontsize', 'yfontsize']
 474         self.param_figure_order = ['figwidth', 'figheight']
 475         self.param_text_order = ['textx', 'texty', 'text', 'textfontsize',
 476                                  'color', 'textrotation']
 477         self.param_treestore = {'marker': marker_treestore,
 478                                 'linestyle': line_treestore}
 479
 480         self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
 481         self.window.set_title('Graphics properties')
 482         self.window.set_default_size(300, 400)
 483         self.window.connect("delete_event", self.end_of_program)
 484         self.window.connect("destroy", self.end_of_program)
 485         vbox = gtk.VBox()
 486         hbox = gtk.HBox()
 487         self.paramtable = gtk.Table()
 488         self.paramtable.show()
 489         self.treestore = gtk.TreeStore(gobject.TYPE_STRING, str, object, int, int)
 490         self.treeview = gtk.TreeView(self.treestore)
 491         self.treeview.set_headers_visible(False)
 492         renderer = gtk.CellRendererText()
 493         self.column = gtk.TreeViewColumn('Object ID', renderer, text=0)
 494         self.treeview.append_column(self.column)
 495
 496         self.treeview.connect("cursor-changed", self.row_activated)
 497         scroll = gtk.ScrolledWindow()
 498         scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
 499         scroll.add(self.treeview)
 500         scroll.show()
 501         self.update(None)
 502         hbox.pack_start(scroll)
 503
 504         viewport = gtk.Viewport()
 505         viewport.add(self.paramtable)
 506         viewport.show()
 507         scroll = gtk.ScrolledWindow()
 508         scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
 509         scroll.add(viewport)
 510         scroll.show()
 511         hbox.pack_start(scroll)
 512
 513         bottom=gtk.HBox()
 514         button = gtk.Button('Update')
 515         button.connect("clicked", self.update)
 516         button.show()
 517         bottom.pack_start(button)
 518         button = gtk.Button('Copy')
 519         button.connect("clicked", self.copy)
 520         button.show()
 521         bottom.pack_start(button)
 522         button = gtk.Button('Delete')
 523         button.connect("clicked", self.delete)
 524         button.show()
 525         bottom.pack_start(button)
 526         bottom.show()
 527         button = gtk.Button('Save data')
 528         button.connect("clicked", self.save)
 529         button.show()
 530         bottom.pack_start(button)
 531         bottom.show()
 532         button = gtk.Button('Apply')
 533         button.connect("clicked", self.apply)
 534         button.show()
 535         bottom.pack_start(button)
 536         bottom.show()
 537
 538         vbox.pack_start(hbox)
 539         vbox.pack_start(bottom, False)
 540         self.window.add(vbox)
 541         self.treeview.show()
 542         hbox.show()
 543         vbox.show()
 544         self.window.show()
 545         gtk.main()
 546