| 1 | |
|---|
| 2 | ################################################################################ |
|---|
| 3 | #This software was developed by the University of Tennessee as part of the |
|---|
| 4 | #Distributed Data Analysis of Neutron Scattering Experiments (DANSE) |
|---|
| 5 | #project funded by the US National Science Foundation. |
|---|
| 6 | # |
|---|
| 7 | #See the license text in license.txt |
|---|
| 8 | # |
|---|
| 9 | #copyright 2008, University of Tennessee |
|---|
| 10 | ################################################################################ |
|---|
| 11 | |
|---|
| 12 | |
|---|
| 13 | import wx |
|---|
| 14 | import sys |
|---|
| 15 | import math |
|---|
| 16 | import numpy |
|---|
| 17 | import logging |
|---|
| 18 | from sas.sasgui.plottools.PlotPanel import PlotPanel |
|---|
| 19 | from sas.sasgui.plottools.plottables import Graph |
|---|
| 20 | from sas.sasgui.plottools.TextDialog import TextDialog |
|---|
| 21 | from sas.sasgui.guiframe.events import StatusEvent |
|---|
| 22 | from sas.sasgui.guiframe.events import NewPlotEvent |
|---|
| 23 | from sas.sasgui.guiframe.events import PanelOnFocusEvent |
|---|
| 24 | from sas.sasgui.guiframe.events import SlicerEvent |
|---|
| 25 | from sas.sasgui.guiframe.utils import PanelMenu |
|---|
| 26 | from sas.sasgui.guiframe.local_perspectives.plotting.binder import BindArtist |
|---|
| 27 | from Plotter1D import ModelPanel1D |
|---|
| 28 | from sas.sasgui.plottools.toolbar import NavigationToolBar |
|---|
| 29 | from matplotlib.font_manager import FontProperties |
|---|
| 30 | from graphAppearance import graphAppearance |
|---|
| 31 | (InternalEvent, EVT_INTERNAL) = wx.lib.newevent.NewEvent() |
|---|
| 32 | |
|---|
| 33 | DEFAULT_QMAX = 0.05 |
|---|
| 34 | DEFAULT_QSTEP = 0.001 |
|---|
| 35 | DEFAULT_BEAM = 0.005 |
|---|
| 36 | BIN_WIDTH = 1.0 |
|---|
| 37 | |
|---|
| 38 | |
|---|
| 39 | def find_key(dic, val): |
|---|
| 40 | """return the key of dictionary dic given the value""" |
|---|
| 41 | return [k for k, v in dic.iteritems() if v == val][0] |
|---|
| 42 | |
|---|
| 43 | |
|---|
| 44 | class NavigationToolBar2D(NavigationToolBar): |
|---|
| 45 | """ |
|---|
| 46 | """ |
|---|
| 47 | def __init__(self, canvas, parent=None): |
|---|
| 48 | NavigationToolBar.__init__(self, canvas=canvas, parent=parent) |
|---|
| 49 | |
|---|
| 50 | def delete_option(self): |
|---|
| 51 | """ |
|---|
| 52 | remove default toolbar item |
|---|
| 53 | """ |
|---|
| 54 | #delete reset button |
|---|
| 55 | self.DeleteToolByPos(0) |
|---|
| 56 | #delete dragging |
|---|
| 57 | self.DeleteToolByPos(2) |
|---|
| 58 | #delete unwanted button that configures subplot parameters |
|---|
| 59 | self.DeleteToolByPos(4) |
|---|
| 60 | |
|---|
| 61 | def add_option(self): |
|---|
| 62 | """ |
|---|
| 63 | add item to the toolbar |
|---|
| 64 | """ |
|---|
| 65 | #add button |
|---|
| 66 | id_context = wx.NewId() |
|---|
| 67 | context_tip = 'Graph Menu' |
|---|
| 68 | context = wx.ArtProvider.GetBitmap(wx.ART_LIST_VIEW, wx.ART_TOOLBAR) |
|---|
| 69 | self.InsertSimpleTool(0, id_context, context, context_tip, context_tip) |
|---|
| 70 | wx.EVT_TOOL(self, id_context, self.parent.onToolContextMenu) |
|---|
| 71 | self.InsertSeparator(1) |
|---|
| 72 | #add print button |
|---|
| 73 | id_print = wx.NewId() |
|---|
| 74 | print_bmp = wx.ArtProvider.GetBitmap(wx.ART_PRINT, wx.ART_TOOLBAR) |
|---|
| 75 | self.AddSimpleTool(id_print, print_bmp, 'Print', 'Activate printing') |
|---|
| 76 | wx.EVT_TOOL(self, id_print, self.on_print) |
|---|
| 77 | |
|---|
| 78 | |
|---|
| 79 | class ModelPanel2D(ModelPanel1D): |
|---|
| 80 | """ |
|---|
| 81 | Plot panel for use with the GUI manager |
|---|
| 82 | """ |
|---|
| 83 | |
|---|
| 84 | ## Internal name for the AUI manager |
|---|
| 85 | window_name = "plotpanel" |
|---|
| 86 | ## Title to appear on top of the window |
|---|
| 87 | window_caption = "Plot Panel" |
|---|
| 88 | ## Flag to tell the GUI manager that this panel is not |
|---|
| 89 | # tied to any perspective |
|---|
| 90 | ALWAYS_ON = True |
|---|
| 91 | ## Group ID |
|---|
| 92 | group_id = None |
|---|
| 93 | |
|---|
| 94 | |
|---|
| 95 | def __init__(self, parent, id=-1, data2d=None, color=None, |
|---|
| 96 | dpi=None, style=wx.NO_FULL_REPAINT_ON_RESIZE, **kwargs): |
|---|
| 97 | """ |
|---|
| 98 | Initialize the panel |
|---|
| 99 | """ |
|---|
| 100 | ModelPanel1D.__init__(self, parent, id=id, style=style, **kwargs) |
|---|
| 101 | self.parent = parent |
|---|
| 102 | ## Reference to the parent window |
|---|
| 103 | if hasattr(parent, "parent"): |
|---|
| 104 | self.parent = self.parent.parent |
|---|
| 105 | ## Dictionary containing Plottables |
|---|
| 106 | self.plots = {} |
|---|
| 107 | ## Save reference of the current plotted |
|---|
| 108 | self.data2D = data2d |
|---|
| 109 | ## Unique ID (from gui_manager) |
|---|
| 110 | self.uid = None |
|---|
| 111 | ## Action IDs for internal call-backs |
|---|
| 112 | self.action_ids = {} |
|---|
| 113 | ## Create Artist and bind it |
|---|
| 114 | self.connect = BindArtist(self.subplot.figure) |
|---|
| 115 | ## Beam stop |
|---|
| 116 | self.beamstop_radius = DEFAULT_BEAM |
|---|
| 117 | ## to set the order of lines drawn first. |
|---|
| 118 | self.slicer_z = 5 |
|---|
| 119 | ## Reference to the current slicer |
|---|
| 120 | self.slicer = None |
|---|
| 121 | ## event to send slicer info |
|---|
| 122 | self.Bind(EVT_INTERNAL, self._onEVT_INTERNAL) |
|---|
| 123 | |
|---|
| 124 | self.axes_frozen = False |
|---|
| 125 | ## panel that contains result from slicer motion (ex: Boxsum info) |
|---|
| 126 | self.panel_slicer = None |
|---|
| 127 | self.title_label = None |
|---|
| 128 | self.title_font = None |
|---|
| 129 | self.title_color = 'black' |
|---|
| 130 | ## Graph |
|---|
| 131 | self.graph = Graph() |
|---|
| 132 | self.graph.xaxis("\\rm{Q}", 'A^{-1}') |
|---|
| 133 | self.graph.yaxis("\\rm{Intensity} ", "cm^{-1}") |
|---|
| 134 | self.graph.render(self) |
|---|
| 135 | ## store default value of zmin and zmax |
|---|
| 136 | self.default_zmin_ctl = self.zmin_2D |
|---|
| 137 | self.default_zmax_ctl = self.zmax_2D |
|---|
| 138 | |
|---|
| 139 | def on_plot_qrange(self, event=None): |
|---|
| 140 | """ |
|---|
| 141 | On Qmin Qmax vertical line event |
|---|
| 142 | """ |
|---|
| 143 | # Not implemented |
|---|
| 144 | if event == None: |
|---|
| 145 | return |
|---|
| 146 | event.Skip() |
|---|
| 147 | |
|---|
| 148 | def onLeftDown(self, event): |
|---|
| 149 | """ |
|---|
| 150 | left button down and ready to drag |
|---|
| 151 | |
|---|
| 152 | """ |
|---|
| 153 | # Check that the LEFT button was pressed |
|---|
| 154 | PlotPanel.onLeftDown(self, event) |
|---|
| 155 | ax = event.inaxes |
|---|
| 156 | if ax != None: |
|---|
| 157 | # data coordinate position |
|---|
| 158 | pos_x = "%8.3g" % event.xdata |
|---|
| 159 | pos_y = "%8.3g" % event.ydata |
|---|
| 160 | position = "x: %s y: %s" % (pos_x, pos_y) |
|---|
| 161 | wx.PostEvent(self.parent, StatusEvent(status=position)) |
|---|
| 162 | self.plottable_selected(self.data2D.id) |
|---|
| 163 | self._manager.set_panel_on_focus(self) |
|---|
| 164 | wx.PostEvent(self.parent, PanelOnFocusEvent(panel=self)) |
|---|
| 165 | |
|---|
| 166 | def add_toolbar(self): |
|---|
| 167 | """ |
|---|
| 168 | add toolbar |
|---|
| 169 | """ |
|---|
| 170 | self.enable_toolbar = True |
|---|
| 171 | self.toolbar = NavigationToolBar2D(parent=self, canvas=self.canvas) |
|---|
| 172 | self.toolbar.Realize() |
|---|
| 173 | # On Windows platform, default window size is incorrect, so set |
|---|
| 174 | # toolbar width to figure width. |
|---|
| 175 | _, th = self.toolbar.GetSizeTuple() |
|---|
| 176 | fw, _ = self.canvas.GetSizeTuple() |
|---|
| 177 | self.toolbar.SetSize(wx.Size(fw, th)) |
|---|
| 178 | self.sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND) |
|---|
| 179 | # update the axes menu on the toolbar |
|---|
| 180 | self.toolbar.update() |
|---|
| 181 | |
|---|
| 182 | def plot_data(self, data): |
|---|
| 183 | """ |
|---|
| 184 | Data is ready to be displayed |
|---|
| 185 | |
|---|
| 186 | :TODO: this name should be changed to something more appropriate |
|---|
| 187 | Don't forget that changing this name will mean changing code |
|---|
| 188 | in plotting.py |
|---|
| 189 | |
|---|
| 190 | :param event: data event |
|---|
| 191 | """ |
|---|
| 192 | xlo = None |
|---|
| 193 | xhi = None |
|---|
| 194 | ylo = None |
|---|
| 195 | yhi = None |
|---|
| 196 | if data.__class__.__name__ == 'Data1D': |
|---|
| 197 | return |
|---|
| 198 | ## Update self.data2d with the current plot |
|---|
| 199 | self.data2D = data |
|---|
| 200 | if data.id in self.plots.keys(): |
|---|
| 201 | #replace |
|---|
| 202 | xlo, xhi = self.subplot.get_xlim() |
|---|
| 203 | ylo, yhi = self.subplot.get_ylim() |
|---|
| 204 | self.graph.replace(data) |
|---|
| 205 | self.plots[data.id] = data |
|---|
| 206 | else: |
|---|
| 207 | self.plots[data.id] = data |
|---|
| 208 | self.graph.add(self.plots[data.id]) |
|---|
| 209 | # update qmax with the new xmax of data plotted |
|---|
| 210 | self.qmax = data.xmax |
|---|
| 211 | self.slicer = None |
|---|
| 212 | # Check axis labels |
|---|
| 213 | #TODO: Should re-factor this |
|---|
| 214 | ## render the graph with its new content |
|---|
| 215 | #data2D: put 'Pixel (Number)' for axis title and unit in case of having no detector info and none in _units |
|---|
| 216 | if len(data.detector) < 1: |
|---|
| 217 | if len(data._xunit) < 1 and len(data._yunit) < 1: |
|---|
| 218 | data._xaxis = '\\rm{x}' |
|---|
| 219 | data._yaxis = '\\rm{y}' |
|---|
| 220 | data._xunit = 'pixel' |
|---|
| 221 | data._yunit = 'pixel' |
|---|
| 222 | # graph properties |
|---|
| 223 | self.graph.xaxis(data._xaxis, data._xunit) |
|---|
| 224 | self.graph.yaxis(data._yaxis, data._yunit) |
|---|
| 225 | if self._is_changed_legend_label: |
|---|
| 226 | data.label = self.title_label |
|---|
| 227 | if data.label == None: |
|---|
| 228 | data.label = data.name |
|---|
| 229 | if not self.title_font: |
|---|
| 230 | self.graph.title(data.label) |
|---|
| 231 | self.graph.render(self) |
|---|
| 232 | # Set the axis labels on subplot |
|---|
| 233 | self._set_axis_labels() |
|---|
| 234 | self.draw_plot() |
|---|
| 235 | else: |
|---|
| 236 | self.graph.render(self) |
|---|
| 237 | self.draw_plot() |
|---|
| 238 | self.subplot.set_title(label=data.label, |
|---|
| 239 | fontproperties=self.title_font, |
|---|
| 240 | color=self.title_color) |
|---|
| 241 | self.subplot.figure.canvas.draw_idle() |
|---|
| 242 | ## store default value of zmin and zmax |
|---|
| 243 | self.default_zmin_ctl = self.zmin_2D |
|---|
| 244 | self.default_zmax_ctl = self.zmax_2D |
|---|
| 245 | if not self.is_zoomed: |
|---|
| 246 | return |
|---|
| 247 | # Recover the x,y limits |
|---|
| 248 | if xlo and xhi and ylo and yhi: |
|---|
| 249 | if xlo > data.xmin and xhi < data.xmax and \ |
|---|
| 250 | ylo > data.ymin and yhi < data.ymax: |
|---|
| 251 | self.subplot.set_xlim((xlo, xhi)) |
|---|
| 252 | self.subplot.set_ylim((ylo, yhi)) |
|---|
| 253 | else: |
|---|
| 254 | self.toolbar.update() |
|---|
| 255 | self.is_zoomed = False |
|---|
| 256 | |
|---|
| 257 | def _set_axis_labels(self): |
|---|
| 258 | """ |
|---|
| 259 | Set axis labels |
|---|
| 260 | """ |
|---|
| 261 | data = self.data2D |
|---|
| 262 | # control axis labels from the panel itself |
|---|
| 263 | yname, yunits = data.get_yaxis() |
|---|
| 264 | if self.yaxis_label != None: |
|---|
| 265 | yname = self.yaxis_label |
|---|
| 266 | yunits = self.yaxis_unit |
|---|
| 267 | else: |
|---|
| 268 | self.yaxis_label = yname |
|---|
| 269 | self.yaxis_unit = yunits |
|---|
| 270 | xname, xunits = data.get_xaxis() |
|---|
| 271 | if self.xaxis_label != None: |
|---|
| 272 | xname = self.xaxis_label |
|---|
| 273 | xunits = self.xaxis_unit |
|---|
| 274 | else: |
|---|
| 275 | self.xaxis_label = xname |
|---|
| 276 | self.xaxis_unit = xunits |
|---|
| 277 | self.xaxis(xname, xunits, self.xaxis_font, |
|---|
| 278 | self.xaxis_color, self.xaxis_tick) |
|---|
| 279 | self.yaxis(yname, yunits, self.yaxis_font, |
|---|
| 280 | self.yaxis_color, self.yaxis_tick) |
|---|
| 281 | |
|---|
| 282 | def onContextMenu(self, event): |
|---|
| 283 | """ |
|---|
| 284 | 2D plot context menu |
|---|
| 285 | |
|---|
| 286 | :param event: wx context event |
|---|
| 287 | |
|---|
| 288 | """ |
|---|
| 289 | ids = iter(self._menu_ids) |
|---|
| 290 | slicerpop = PanelMenu() |
|---|
| 291 | slicerpop.set_plots(self.plots) |
|---|
| 292 | slicerpop.set_graph(self.graph) |
|---|
| 293 | |
|---|
| 294 | wx_id = ids.next() |
|---|
| 295 | slicerpop.Append(wx_id, '&Save Image', 'Save image as png') |
|---|
| 296 | wx.EVT_MENU(self, wx_id, self.onSaveImage) |
|---|
| 297 | |
|---|
| 298 | wx_id = ids.next() |
|---|
| 299 | slicerpop.Append(wx_id, '&Print Image', 'Print image') |
|---|
| 300 | wx.EVT_MENU(self, wx_id, self.onPrint) |
|---|
| 301 | |
|---|
| 302 | wx_id = ids.next() |
|---|
| 303 | slicerpop.Append(wx_id, '&Copy to Clipboard', 'Copy to the clipboard') |
|---|
| 304 | wx.EVT_MENU(self, wx_id, self.OnCopyFigureMenu) |
|---|
| 305 | slicerpop.AppendSeparator() |
|---|
| 306 | # saving data |
|---|
| 307 | plot = self.data2D |
|---|
| 308 | wx_id = ids.next() |
|---|
| 309 | slicerpop.Append(wx_id, "&Data Info") |
|---|
| 310 | wx.EVT_MENU(self, wx_id, self._onDataShow) |
|---|
| 311 | |
|---|
| 312 | wx_id = ids.next() |
|---|
| 313 | slicerpop.Append(wx_id, "&Save as a File (DAT)") |
|---|
| 314 | self.action_ids[str(wx_id)] = plot |
|---|
| 315 | wx.EVT_MENU(self, wx_id, self._onSave) |
|---|
| 316 | |
|---|
| 317 | slicerpop.AppendSeparator() |
|---|
| 318 | if len(self.data2D.detector) <= 1: |
|---|
| 319 | item_list = self.parent.get_current_context_menu(self) |
|---|
| 320 | if (not item_list == None) and (not len(item_list) == 0) and\ |
|---|
| 321 | self.data2D.name.split(" ")[0] != 'Residuals': |
|---|
| 322 | for item, wx_id in zip(item_list, [ids.next() for i in range(len(item_list))]): |
|---|
| 323 | try: |
|---|
| 324 | slicerpop.Append(wx_id, item[0], item[1]) |
|---|
| 325 | wx.EVT_MENU(self, wx_id, item[2]) |
|---|
| 326 | except: |
|---|
| 327 | msg = "ModelPanel1D.onContextMenu: " |
|---|
| 328 | msg += "bad menu item %s" % sys.exc_value |
|---|
| 329 | wx.PostEvent(self.parent, StatusEvent(status=msg)) |
|---|
| 330 | slicerpop.AppendSeparator() |
|---|
| 331 | |
|---|
| 332 | wx_id = ids.next() |
|---|
| 333 | slicerpop.Append(wx_id, '&Perform Circular Average') |
|---|
| 334 | wx.EVT_MENU(self, wx_id, self.onCircular) \ |
|---|
| 335 | # For Masked Data |
|---|
| 336 | if not plot.mask.all(): |
|---|
| 337 | wx_id = ids.next() |
|---|
| 338 | slicerpop.Append(wx_id, '&Masked Circular Average') |
|---|
| 339 | wx.EVT_MENU(self, wx_id, self.onMaskedCircular) |
|---|
| 340 | wx_id = ids.next() |
|---|
| 341 | slicerpop.Append(wx_id, '&Sector [Q View]') |
|---|
| 342 | wx.EVT_MENU(self, wx_id, self.onSectorQ) |
|---|
| 343 | wx_id = ids.next() |
|---|
| 344 | slicerpop.Append(wx_id, '&Annulus [Phi View ]') |
|---|
| 345 | wx.EVT_MENU(self, wx_id, self.onSectorPhi) |
|---|
| 346 | wx_id = ids.next() |
|---|
| 347 | slicerpop.Append(wx_id, '&Box Sum') |
|---|
| 348 | wx.EVT_MENU(self, wx_id, self.onBoxSum) |
|---|
| 349 | wx_id = ids.next() |
|---|
| 350 | slicerpop.Append(wx_id, '&Box Averaging in Qx') |
|---|
| 351 | wx.EVT_MENU(self, wx_id, self.onBoxavgX) |
|---|
| 352 | wx_id = ids.next() |
|---|
| 353 | slicerpop.Append(wx_id, '&Box Averaging in Qy') |
|---|
| 354 | wx.EVT_MENU(self, wx_id, self.onBoxavgY) |
|---|
| 355 | if self.slicer != None: |
|---|
| 356 | wx_id = ids.next() |
|---|
| 357 | slicerpop.Append(wx_id, '&Clear Slicer') |
|---|
| 358 | wx.EVT_MENU(self, wx_id, self.onClearSlicer) |
|---|
| 359 | if self.slicer.__class__.__name__ != "BoxSum": |
|---|
| 360 | wx_id = ids.next() |
|---|
| 361 | slicerpop.Append(wx_id, '&Edit Slicer Parameters') |
|---|
| 362 | wx.EVT_MENU(self, wx_id, self._onEditSlicer) |
|---|
| 363 | slicerpop.AppendSeparator() |
|---|
| 364 | |
|---|
| 365 | wx_id = ids.next() |
|---|
| 366 | slicerpop.Append(wx_id, '&Edit Graph Label', 'Edit Graph Label') |
|---|
| 367 | wx.EVT_MENU(self, wx_id, self.onEditLabels) |
|---|
| 368 | slicerpop.AppendSeparator() |
|---|
| 369 | |
|---|
| 370 | # ILL mod here |
|---|
| 371 | |
|---|
| 372 | wx_id = ids.next() |
|---|
| 373 | slicerpop.Append(wx_id, '&Modify graph appearance', 'Modify graph appearance') |
|---|
| 374 | wx.EVT_MENU(self, wx_id, self.modifyGraphAppearance) |
|---|
| 375 | slicerpop.AppendSeparator() |
|---|
| 376 | |
|---|
| 377 | wx_id = ids.next() |
|---|
| 378 | slicerpop.Append(wx_id, '&2D Color Map') |
|---|
| 379 | wx.EVT_MENU(self, wx_id, self._onEditDetector) |
|---|
| 380 | slicerpop.AppendSeparator() |
|---|
| 381 | |
|---|
| 382 | wx_id = ids.next() |
|---|
| 383 | slicerpop.Append(wx_id, '&Toggle Linear/Log Scale') |
|---|
| 384 | wx.EVT_MENU(self, wx_id, self._onToggleScale) |
|---|
| 385 | |
|---|
| 386 | slicerpop.AppendSeparator() |
|---|
| 387 | wx_id = ids.next() |
|---|
| 388 | slicerpop.Append(wx_id, '&Window Title') |
|---|
| 389 | wx.EVT_MENU(self, wx_id, self.onChangeCaption) |
|---|
| 390 | |
|---|
| 391 | try: |
|---|
| 392 | pos_evt = event.GetPosition() |
|---|
| 393 | pos = self.ScreenToClient(pos_evt) |
|---|
| 394 | except: |
|---|
| 395 | pos_x, pos_y = self.toolbar.GetPositionTuple() |
|---|
| 396 | pos = (pos_x, pos_y + 5) |
|---|
| 397 | self.PopupMenu(slicerpop, pos) |
|---|
| 398 | |
|---|
| 399 | def onEditLabels(self, event): |
|---|
| 400 | """ |
|---|
| 401 | Edit legend label |
|---|
| 402 | """ |
|---|
| 403 | try: |
|---|
| 404 | selected_plot = self.plots[self.graph.selected_plottable] |
|---|
| 405 | except: |
|---|
| 406 | selected_plot = self.plots[self.data2D.id] |
|---|
| 407 | label = selected_plot.label |
|---|
| 408 | dial = TextDialog(None, -1, 'Change Label', label) |
|---|
| 409 | if dial.ShowModal() == wx.ID_OK: |
|---|
| 410 | try: |
|---|
| 411 | FONT = FontProperties() |
|---|
| 412 | newlabel = dial.getText() |
|---|
| 413 | font = FONT.copy() |
|---|
| 414 | font.set_size(dial.getSize()) |
|---|
| 415 | font.set_family(dial.getFamily()) |
|---|
| 416 | font.set_style(dial.getStyle()) |
|---|
| 417 | font.set_weight(dial.getWeight()) |
|---|
| 418 | colour = dial.getColor() |
|---|
| 419 | if len(newlabel) > 0: |
|---|
| 420 | # update Label |
|---|
| 421 | selected_plot.label = newlabel |
|---|
| 422 | self.graph.title(newlabel) |
|---|
| 423 | self.title_label = selected_plot.label |
|---|
| 424 | self.title_font = font |
|---|
| 425 | self.title_color = colour |
|---|
| 426 | ## render the graph |
|---|
| 427 | self.subplot.set_title(label=self.title_label, |
|---|
| 428 | fontproperties=self.title_font, |
|---|
| 429 | color=self.title_color) |
|---|
| 430 | self._is_changed_legend_label = True |
|---|
| 431 | self.subplot.figure.canvas.draw_idle() |
|---|
| 432 | except: |
|---|
| 433 | msg = "Add Text: Error. Check your property values..." |
|---|
| 434 | logging.error(msg) |
|---|
| 435 | if self.parent != None: |
|---|
| 436 | wx.PostEvent(self.parent, StatusEvent(status=msg)) |
|---|
| 437 | dial.Destroy() |
|---|
| 438 | |
|---|
| 439 | def _onEditDetector(self, event): |
|---|
| 440 | """ |
|---|
| 441 | Allow to view and edits detector parameters |
|---|
| 442 | |
|---|
| 443 | :param event: wx.menu event |
|---|
| 444 | |
|---|
| 445 | """ |
|---|
| 446 | import detector_dialog |
|---|
| 447 | dialog = detector_dialog.DetectorDialog(self, -1, base=self.parent, |
|---|
| 448 | reset_zmin_ctl=self.default_zmin_ctl, |
|---|
| 449 | reset_zmax_ctl=self.default_zmax_ctl, cmap=self.cmap) |
|---|
| 450 | ## info of current detector and data2D |
|---|
| 451 | xnpts = len(self.data2D.x_bins) |
|---|
| 452 | ynpts = len(self.data2D.y_bins) |
|---|
| 453 | xmax = max(self.data2D.xmin, self.data2D.xmax) |
|---|
| 454 | ymax = max(self.data2D.ymin, self.data2D.ymax) |
|---|
| 455 | qmax = math.sqrt(math.pow(xmax, 2) + math.pow(ymax, 2)) |
|---|
| 456 | ## set dialog window content |
|---|
| 457 | dialog.setContent(xnpts=xnpts, ynpts=ynpts, qmax=qmax, |
|---|
| 458 | beam=self.data2D.xmin, |
|---|
| 459 | zmin=self.zmin_2D, |
|---|
| 460 | zmax=self.zmax_2D) |
|---|
| 461 | if dialog.ShowModal() == wx.ID_OK: |
|---|
| 462 | evt = dialog.getContent() |
|---|
| 463 | self.zmin_2D = evt.zmin |
|---|
| 464 | self.zmax_2D = evt.zmax |
|---|
| 465 | self.cmap = evt.cmap |
|---|
| 466 | dialog.Destroy() |
|---|
| 467 | ## Redraw the current image |
|---|
| 468 | self.image(data=self.data2D.data, |
|---|
| 469 | qx_data=self.data2D.qx_data, |
|---|
| 470 | qy_data=self.data2D.qy_data, |
|---|
| 471 | xmin=self.data2D.xmin, |
|---|
| 472 | xmax=self.data2D.xmax, |
|---|
| 473 | ymin=self.data2D.ymin, |
|---|
| 474 | ymax=self.data2D.ymax, |
|---|
| 475 | zmin=self.zmin_2D, |
|---|
| 476 | zmax=self.zmax_2D, |
|---|
| 477 | cmap=self.cmap, |
|---|
| 478 | color=0, symbol=0, label=self.data2D.name) |
|---|
| 479 | self.subplot.figure.canvas.draw_idle() |
|---|
| 480 | |
|---|
| 481 | def freeze_axes(self): |
|---|
| 482 | """ |
|---|
| 483 | """ |
|---|
| 484 | self.axes_frozen = True |
|---|
| 485 | |
|---|
| 486 | def thaw_axes(self): |
|---|
| 487 | """ |
|---|
| 488 | """ |
|---|
| 489 | self.axes_frozen = False |
|---|
| 490 | |
|---|
| 491 | def onMouseMotion(self, event): |
|---|
| 492 | """ |
|---|
| 493 | """ |
|---|
| 494 | pass |
|---|
| 495 | |
|---|
| 496 | def onWheel(self, event): |
|---|
| 497 | """ |
|---|
| 498 | """ |
|---|
| 499 | pass |
|---|
| 500 | |
|---|
| 501 | def update(self, draw=True): |
|---|
| 502 | """ |
|---|
| 503 | Respond to changes in the model by recalculating the |
|---|
| 504 | profiles and resetting the widgets. |
|---|
| 505 | """ |
|---|
| 506 | self.draw_plot() |
|---|
| 507 | |
|---|
| 508 | def _getEmptySlicerEvent(self): |
|---|
| 509 | """ |
|---|
| 510 | create an empty slicervent |
|---|
| 511 | """ |
|---|
| 512 | return SlicerEvent(type=None, params=None, obj_class=None) |
|---|
| 513 | |
|---|
| 514 | def _onEVT_INTERNAL(self, event): |
|---|
| 515 | """ |
|---|
| 516 | Draw the slicer |
|---|
| 517 | |
|---|
| 518 | :param event: wx.lib.newevent (SlicerEvent) containing slicer |
|---|
| 519 | parameter |
|---|
| 520 | |
|---|
| 521 | """ |
|---|
| 522 | self._setSlicer(event.slicer) |
|---|
| 523 | |
|---|
| 524 | def _setSlicer(self, slicer): |
|---|
| 525 | """ |
|---|
| 526 | Clear the previous slicer and create a new one.Post an internal |
|---|
| 527 | event. |
|---|
| 528 | |
|---|
| 529 | :param slicer: slicer class to create |
|---|
| 530 | |
|---|
| 531 | """ |
|---|
| 532 | ## Clear current slicer |
|---|
| 533 | if not self.slicer == None: |
|---|
| 534 | self.slicer.clear() |
|---|
| 535 | ## Create a new slicer |
|---|
| 536 | self.slicer_z += 1 |
|---|
| 537 | self.slicer = slicer(self, self.subplot, zorder=self.slicer_z) |
|---|
| 538 | self.subplot.set_ylim(self.data2D.ymin, self.data2D.ymax) |
|---|
| 539 | self.subplot.set_xlim(self.data2D.xmin, self.data2D.xmax) |
|---|
| 540 | ## Draw slicer |
|---|
| 541 | self.update() |
|---|
| 542 | self.slicer.update() |
|---|
| 543 | msg = "Plotter2D._setSlicer %s" % self.slicer.__class__.__name__ |
|---|
| 544 | wx.PostEvent(self.parent, StatusEvent(status=msg)) |
|---|
| 545 | # Post slicer event |
|---|
| 546 | event = self._getEmptySlicerEvent() |
|---|
| 547 | event.type = self.slicer.__class__.__name__ |
|---|
| 548 | event.obj_class = self.slicer.__class__ |
|---|
| 549 | event.params = self.slicer.get_params() |
|---|
| 550 | wx.PostEvent(self, event) |
|---|
| 551 | |
|---|
| 552 | def onMaskedCircular(self, event): |
|---|
| 553 | """ |
|---|
| 554 | perform circular averaging on Data2D with mask if it exists |
|---|
| 555 | |
|---|
| 556 | :param event: wx.menu event |
|---|
| 557 | |
|---|
| 558 | """ |
|---|
| 559 | self.onCircular(event, True) |
|---|
| 560 | |
|---|
| 561 | def onCircular(self, event, ismask=False): |
|---|
| 562 | """ |
|---|
| 563 | perform circular averaging on Data2D |
|---|
| 564 | |
|---|
| 565 | :param event: wx.menu event |
|---|
| 566 | |
|---|
| 567 | """ |
|---|
| 568 | # Find the best number of bins |
|---|
| 569 | npt = math.sqrt(len(self.data2D.data[numpy.isfinite(self.data2D.data)])) |
|---|
| 570 | npt = math.floor(npt) |
|---|
| 571 | from sas.sascalc.dataloader.manipulations import CircularAverage |
|---|
| 572 | ## compute the maximum radius of data2D |
|---|
| 573 | self.qmax = max(math.fabs(self.data2D.xmax), |
|---|
| 574 | math.fabs(self.data2D.xmin)) |
|---|
| 575 | self.ymax = max(math.fabs(self.data2D.ymax), |
|---|
| 576 | math.fabs(self.data2D.ymin)) |
|---|
| 577 | self.radius = math.sqrt(math.pow(self.qmax, 2) + math.pow(self.ymax, 2)) |
|---|
| 578 | ##Compute beam width |
|---|
| 579 | bin_width = (self.qmax + self.qmax) / npt |
|---|
| 580 | ## Create data1D circular average of data2D |
|---|
| 581 | Circle = CircularAverage(r_min=0, r_max=self.radius, |
|---|
| 582 | bin_width=bin_width) |
|---|
| 583 | circ = Circle(self.data2D, ismask=ismask) |
|---|
| 584 | from sas.sasgui.guiframe.dataFitting import Data1D |
|---|
| 585 | if hasattr(circ, "dxl"): |
|---|
| 586 | dxl = circ.dxl |
|---|
| 587 | else: |
|---|
| 588 | dxl = None |
|---|
| 589 | if hasattr(circ, "dxw"): |
|---|
| 590 | dxw = circ.dxw |
|---|
| 591 | else: |
|---|
| 592 | dxw = None |
|---|
| 593 | |
|---|
| 594 | new_plot = Data1D(x=circ.x, y=circ.y, dy=circ.dy, dx=circ.dx) |
|---|
| 595 | new_plot.dxl = dxl |
|---|
| 596 | new_plot.dxw = dxw |
|---|
| 597 | new_plot.name = "Circ avg " + self.data2D.name |
|---|
| 598 | new_plot.source = self.data2D.source |
|---|
| 599 | #new_plot.info = self.data2D.info |
|---|
| 600 | new_plot.interactive = True |
|---|
| 601 | new_plot.detector = self.data2D.detector |
|---|
| 602 | |
|---|
| 603 | ## If the data file does not tell us what the axes are, just assume... |
|---|
| 604 | new_plot.xaxis("\\rm{Q}", "A^{-1}") |
|---|
| 605 | if hasattr(self.data2D, "scale") and \ |
|---|
| 606 | self.data2D.scale == 'linear': |
|---|
| 607 | new_plot.ytransform = 'y' |
|---|
| 608 | new_plot.yaxis("\\rm{Residuals} ", "normalized") |
|---|
| 609 | else: |
|---|
| 610 | new_plot.yaxis("\\rm{Intensity} ", "cm^{-1}") |
|---|
| 611 | |
|---|
| 612 | new_plot.group_id = "2daverage" + self.data2D.name |
|---|
| 613 | new_plot.id = "Circ avg " + self.data2D.name |
|---|
| 614 | new_plot.is_data = True |
|---|
| 615 | self.parent.update_theory(data_id=self.data2D.id, \ |
|---|
| 616 | theory=new_plot) |
|---|
| 617 | wx.PostEvent(self.parent, |
|---|
| 618 | NewPlotEvent(plot=new_plot, title=new_plot.name)) |
|---|
| 619 | |
|---|
| 620 | def _onEditSlicer(self, event): |
|---|
| 621 | """ |
|---|
| 622 | Is available only when a slicer is drawn.Create a dialog |
|---|
| 623 | window where the user can enter value to reset slicer |
|---|
| 624 | parameters. |
|---|
| 625 | |
|---|
| 626 | :param event: wx.menu event |
|---|
| 627 | |
|---|
| 628 | """ |
|---|
| 629 | if self.slicer != None: |
|---|
| 630 | from SlicerParameters import SlicerParameterPanel |
|---|
| 631 | dialog = SlicerParameterPanel(self, -1, "Slicer Parameters") |
|---|
| 632 | dialog.set_slicer(self.slicer.__class__.__name__, |
|---|
| 633 | self.slicer.get_params()) |
|---|
| 634 | if dialog.ShowModal() == wx.ID_OK: |
|---|
| 635 | dialog.Destroy() |
|---|
| 636 | |
|---|
| 637 | def onSectorQ(self, event): |
|---|
| 638 | """ |
|---|
| 639 | Perform sector averaging on Q and draw sector slicer |
|---|
| 640 | """ |
|---|
| 641 | from SectorSlicer import SectorInteractor |
|---|
| 642 | self.onClearSlicer(event) |
|---|
| 643 | wx.PostEvent(self, InternalEvent(slicer=SectorInteractor)) |
|---|
| 644 | |
|---|
| 645 | def onSectorPhi(self, event): |
|---|
| 646 | """ |
|---|
| 647 | Perform sector averaging on Phi and draw annulus slicer |
|---|
| 648 | """ |
|---|
| 649 | from AnnulusSlicer import AnnulusInteractor |
|---|
| 650 | self.onClearSlicer(event) |
|---|
| 651 | wx.PostEvent(self, InternalEvent(slicer=AnnulusInteractor)) |
|---|
| 652 | |
|---|
| 653 | def onBoxSum(self, event): |
|---|
| 654 | """ |
|---|
| 655 | """ |
|---|
| 656 | from sas.sasgui.guiframe.gui_manager import MDIFrame |
|---|
| 657 | from boxSum import BoxSum |
|---|
| 658 | self.onClearSlicer(event) |
|---|
| 659 | self.slicer_z += 1 |
|---|
| 660 | self.slicer = BoxSum(self, self.subplot, zorder=self.slicer_z) |
|---|
| 661 | self.subplot.set_ylim(self.data2D.ymin, self.data2D.ymax) |
|---|
| 662 | self.subplot.set_xlim(self.data2D.xmin, self.data2D.xmax) |
|---|
| 663 | self.update() |
|---|
| 664 | self.slicer.update() |
|---|
| 665 | ## Value used to initially set the slicer panel |
|---|
| 666 | params = self.slicer.get_params() |
|---|
| 667 | ## Create a new panel to display results of summation of Data2D |
|---|
| 668 | from slicerpanel import SlicerPanel |
|---|
| 669 | win = MDIFrame(self.parent, None, 'None', (100, 200)) |
|---|
| 670 | new_panel = SlicerPanel(parent=win, id=-1, |
|---|
| 671 | base=self, type=self.slicer.__class__.__name__, |
|---|
| 672 | params=params, style=wx.RAISED_BORDER) |
|---|
| 673 | |
|---|
| 674 | new_panel.window_caption = self.slicer.__class__.__name__ + " " + \ |
|---|
| 675 | str(self.data2D.name) |
|---|
| 676 | new_panel.window_name = self.slicer.__class__.__name__ + " " + \ |
|---|
| 677 | str(self.data2D.name) |
|---|
| 678 | ## Store a reference of the new created panel |
|---|
| 679 | |
|---|
| 680 | ## save the window_caption of the new panel in the current slicer |
|---|
| 681 | self.slicer.set_panel_name(name=new_panel.window_caption) |
|---|
| 682 | ## post slicer panel to guiframe to display it |
|---|
| 683 | from sas.sasgui.guiframe.events import SlicerPanelEvent |
|---|
| 684 | |
|---|
| 685 | win.set_panel(new_panel) |
|---|
| 686 | new_panel.frame = win |
|---|
| 687 | wx.PostEvent(self.parent, SlicerPanelEvent(panel=new_panel, |
|---|
| 688 | main_panel=self)) |
|---|
| 689 | wx.CallAfter(new_panel.frame.Show) |
|---|
| 690 | self.panel_slicer = new_panel |
|---|
| 691 | |
|---|
| 692 | def onBoxavgX(self, event): |
|---|
| 693 | """ |
|---|
| 694 | Perform 2D data averaging on Qx |
|---|
| 695 | Create a new slicer . |
|---|
| 696 | |
|---|
| 697 | :param event: wx.menu event |
|---|
| 698 | """ |
|---|
| 699 | from boxSlicer import BoxInteractorX |
|---|
| 700 | self.onClearSlicer(event) |
|---|
| 701 | wx.PostEvent(self, InternalEvent(slicer=BoxInteractorX)) |
|---|
| 702 | |
|---|
| 703 | def onBoxavgY(self, event): |
|---|
| 704 | """ |
|---|
| 705 | Perform 2D data averaging on Qy |
|---|
| 706 | Create a new slicer . |
|---|
| 707 | |
|---|
| 708 | :param event: wx.menu event |
|---|
| 709 | |
|---|
| 710 | """ |
|---|
| 711 | from boxSlicer import BoxInteractorY |
|---|
| 712 | self.onClearSlicer(event) |
|---|
| 713 | wx.PostEvent(self, InternalEvent(slicer=BoxInteractorY)) |
|---|
| 714 | |
|---|
| 715 | def onClearSlicer(self, event): |
|---|
| 716 | """ |
|---|
| 717 | Clear the slicer on the plot |
|---|
| 718 | """ |
|---|
| 719 | if not self.slicer == None: |
|---|
| 720 | self.slicer.clear() |
|---|
| 721 | self.subplot.figure.canvas.draw() |
|---|
| 722 | self.slicer = None |
|---|
| 723 | # Post slicer None event |
|---|
| 724 | event = self._getEmptySlicerEvent() |
|---|
| 725 | wx.PostEvent(self, event) |
|---|
| 726 | |
|---|
| 727 | def _onSave(self, evt): |
|---|
| 728 | """ |
|---|
| 729 | Save a data set to a dat(text) file |
|---|
| 730 | |
|---|
| 731 | :param evt: Menu event |
|---|
| 732 | |
|---|
| 733 | """ |
|---|
| 734 | event_id = str(evt.GetId()) |
|---|
| 735 | if self.parent != None: |
|---|
| 736 | self._default_save_location = self.parent._default_save_location |
|---|
| 737 | default_name = self.plots[self.graph.selected_plottable].label |
|---|
| 738 | if default_name.count('.') > 0: |
|---|
| 739 | default_name = default_name.split('.')[0] |
|---|
| 740 | default_name += "_out" |
|---|
| 741 | if event_id in self.action_ids: |
|---|
| 742 | self.parent.save_data2d(self.data2D, default_name) |
|---|
| 743 | |
|---|
| 744 | def _onDataShow(self, evt): |
|---|
| 745 | """ |
|---|
| 746 | Show the data set in text |
|---|
| 747 | |
|---|
| 748 | :param evt: Menu event |
|---|
| 749 | |
|---|
| 750 | """ |
|---|
| 751 | menu = evt.GetEventObject() |
|---|
| 752 | event_id = evt.GetId() |
|---|
| 753 | self.set_selected_from_menu(menu, event_id) |
|---|
| 754 | data = self.plots[self.graph.selected_plottable] |
|---|
| 755 | default_name = data.label |
|---|
| 756 | if default_name.count('.') > 0: |
|---|
| 757 | default_name = default_name.split('.')[0] |
|---|
| 758 | #default_name += "_out" |
|---|
| 759 | if self.parent != None: |
|---|
| 760 | self.parent.show_data2d(data, default_name) |
|---|
| 761 | |
|---|
| 762 | def modifyGraphAppearance(self, e): |
|---|
| 763 | self.graphApp = graphAppearance(self, 'Modify graph appearance', legend=False) |
|---|
| 764 | self.graphApp.setDefaults(self.grid_on, self.legend_on, |
|---|
| 765 | self.xaxis_label, self.yaxis_label, |
|---|
| 766 | self.xaxis_unit, self.yaxis_unit, |
|---|
| 767 | self.xaxis_font, self.yaxis_font, |
|---|
| 768 | find_key(self.get_loc_label(), self.legendLoc), |
|---|
| 769 | self.xcolor, self.ycolor, |
|---|
| 770 | self.is_xtick, self.is_ytick) |
|---|
| 771 | self.graphApp.Bind(wx.EVT_CLOSE, self.on_graphApp_close) |
|---|
| 772 | |
|---|
| 773 | def on_graphApp_close(self, e): |
|---|
| 774 | """ |
|---|
| 775 | Gets values from graph appearance dialog and sends them off |
|---|
| 776 | to modify the plot |
|---|
| 777 | """ |
|---|
| 778 | self.onGridOnOff(self.graphApp.get_togglegrid()) |
|---|
| 779 | self.xaxis_label = self.graphApp.get_xlab() |
|---|
| 780 | self.yaxis_label = self.graphApp.get_ylab() |
|---|
| 781 | self.xaxis_unit = self.graphApp.get_xunit() |
|---|
| 782 | self.yaxis_unit = self.graphApp.get_yunit() |
|---|
| 783 | self.xaxis_font = self.graphApp.get_xfont() |
|---|
| 784 | self.yaxis_font = self.graphApp.get_yfont() |
|---|
| 785 | self.is_xtick = self.graphApp.get_xtick_check() |
|---|
| 786 | self.is_ytick = self.graphApp.get_ytick_check() |
|---|
| 787 | if self.is_xtick: |
|---|
| 788 | self.xaxis_tick = self.xaxis_font |
|---|
| 789 | if self.is_ytick: |
|---|
| 790 | self.yaxis_tick = self.yaxis_font |
|---|
| 791 | |
|---|
| 792 | self.xaxis(self.xaxis_label, self.xaxis_unit, |
|---|
| 793 | self.graphApp.get_xfont(), self.graphApp.get_xcolor(), |
|---|
| 794 | self.xaxis_tick) |
|---|
| 795 | self.yaxis(self.yaxis_label, self.yaxis_unit, |
|---|
| 796 | self.graphApp.get_yfont(), self.graphApp.get_ycolor(), |
|---|
| 797 | self.yaxis_tick) |
|---|
| 798 | |
|---|
| 799 | self.graphApp.Destroy() |
|---|
