Ignore:
Timestamp:
May 26, 2017 7:41:44 AM (7 years ago)
Author:
Piotr Rozyczko <rozyczko@…>
Branches:
ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc
Children:
c1e380e
Parents:
6964d44 (diff), 7132e49 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' into ESS_GUI

Location:
src/sas/sasgui/guiframe/local_perspectives
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • src/sas/sasgui/guiframe/local_perspectives/data_loader/data_loader.py

    rfe1eb94 r235f514  
    77import wx 
    88import logging 
     9 
     10logger = logging.getLogger(__name__) 
    911 
    1012from sas.sascalc.dataloader.loader import Loader 
    … …  
    7375        path = None 
    7476        self._default_save_location = self.parent._default_save_location 
    75         if self._default_save_location == None: 
     77        if self._default_save_location is None: 
    7678            self._default_save_location = os.getcwd() 
    7779 
    … …  
    9092        if dlg.ShowModal() == wx.ID_OK: 
    9193            file_list = dlg.GetPaths() 
    92             if len(file_list) >= 0 and not file_list[0] is None: 
     94            if len(file_list) >= 0 and file_list[0] is not None: 
    9395                self._default_save_location = os.path.dirname(file_list[0]) 
    9496                path = self._default_save_location 
    … …  
    114116        path = None 
    115117        self._default_save_location = self.parent._default_save_location 
    116         if self._default_save_location == None: 
     118        if self._default_save_location is None: 
    117119            self._default_save_location = os.getcwd() 
    118120        dlg = wx.DirDialog(self.parent, "Choose a directory", 
    … …  
    160162                message += "\tError: {0}\n".format(error_data) 
    161163        else: 
    162             logging.error("Loader returned an invalid object:\n %s" % str(item)) 
     164            logger.error("Loader returned an invalid object:\n %s" % str(item)) 
    163165            data_error = True 
    164166 
    … …  
    182184                log_msg += "Please try to open that file from \"open project\"" 
    183185                log_msg += "or \"open analysis\" menu." 
    184                 logging.info(log_msg) 
     186                logger.info(log_msg) 
    185187                file_errors[basename] = [log_msg] 
    186188                continue 
    … …  
    212214 
    213215            except: 
    214                 logging.error(sys.exc_value) 
     216                logger.error(sys.exc_value) 
    215217 
    216218                error_message = "The Data file you selected could not be loaded.\n" 

  • src/sas/sasgui/guiframe/local_perspectives/plotting/Arc.py

    rd85c194 r7432acb  
    7171        x = [] 
    7272        y = [] 
    73         if theta1 != None: 
     73        if theta1 is not None: 
    7474            self.theta1 = theta1 
    75         if theta2 != None: 
     75        if theta2 is not None: 
    7676            self.theta2 = theta2 
    7777        while self.theta2 < self.theta1: 
    … …  
    8181        npts = int((self.theta2 - self.theta1) / (math.pi / 120)) 
    8282 
    83         if r == None: 
     83        if r is None: 
    8484            self.radius = math.sqrt(math.pow(self._mouse_x, 2) + \ 
    8585                                     math.pow(self._mouse_y, 2)) 

  • src/sas/sasgui/guiframe/local_perspectives/plotting/Edge.py

    rd85c194 r7432acb  
    6363        Draw the new roughness on the graph. 
    6464        """ 
    65         if r1 != None: 
     65        if r1 is not None: 
    6666            self.r1 = r1 
    67         if r2 != None: 
     67        if r2 is not None: 
    6868            self.r2 = r2 
    69         if theta != None: 
     69        if theta is not None: 
    7070            self.theta = theta 
    7171        x1 = self.r1 * math.cos(self.theta) 

  • src/sas/sasgui/guiframe/local_perspectives/plotting/Plotter1D.py

    r9687d58 rc416a17  
    1  
    21################################################################################ 
    32# This software was developed by the University of Tennessee as part of the 
    … …  
    1413import sys 
    1514import math 
    16 import numpy 
     15import numpy as np 
    1716import logging 
    1817from sas.sasgui.plottools.PlotPanel import PlotPanel 
    … …  
    2423from appearanceDialog import appearanceDialog 
    2524from graphAppearance import graphAppearance 
     25 
     26logger = logging.getLogger(__name__) 
    2627 
    2728DEFAULT_QMAX = 0.05 
    … …  
    181182        # So manually recode the size (=x_size) and compare here. 
    182183        # Massy code to work around:< 
    183         if self.parent._mgr != None: 
     184        if self.parent._mgr is not None: 
    184185            max_panel = self.parent._mgr.GetPane(self) 
    185186            if max_panel.IsMaximized(): 
    186187                self.parent._mgr.RestorePane(max_panel) 
    187188                max_panel.Maximize() 
    188         if self.x_size != None: 
     189        if self.x_size is not None: 
    189190            if self.x_size == self.GetSize(): 
    190191                self.resizing = False 
    … …  
    210211        On Qmin Qmax vertical line event 
    211212        """ 
    212         if event == None: 
     213        if event is None: 
    213214            return 
    214215        event.Skip() 
    215216        active_ctrl = event.active 
    216         if active_ctrl == None: 
     217        if active_ctrl is None: 
    217218            return 
    218219        if hasattr(event, 'is_corfunc'): 
    … …  
    229230                colors.append('purple') 
    230231                values.append(min(x_data.max(), float(ctrl[2].GetValue()))) 
    231             if self.ly == None: 
     232            if self.ly is None: 
    232233                self.ly = [] 
    233234                for c, v in zip(colors, values): 
    … …  
    239240                xval = float(active_ctrl.GetValue()) 
    240241                position = self.get_data_xy_vals(xval) 
    241                 if position != None and not self.is_corfunc: 
     242                if position is not None and not self.is_corfunc: 
    242243                    wx.PostEvent(self.parent, StatusEvent(status=position)) 
    243244            except: 
    244                 logging.error(sys.exc_value) 
     245                logger.error(sys.exc_value) 
    245246            if not event.leftdown: 
    246247                # text event 
    … …  
    255256                        self.canvas.draw() 
    256257                except: 
    257                     logging.error(sys.exc_value) 
     258                    logger.error(sys.exc_value) 
    258259                event.Skip() 
    259260                return 
    … …  
    288289        :Param value: float 
    289290        """ 
    290         idx = (numpy.abs(array - value)).argmin() 
     291        idx = (np.abs(array - value)).argmin() 
    291292        return int(idx)  # array.flat[idx] 
    292293 
    … …  
    334335        if hasattr(event, "action"): 
    335336            dclick = event.action == 'dclick' 
    336             if ax == None or dclick: 
     337            if ax is None or dclick: 
    337338                # remove the vline 
    338339                self._check_zoom_plot() 
    … …  
    340341                self.q_ctrl = None 
    341342                return 
    342         if self.ly != None and event.xdata != None: 
     343        if self.ly is not None and event.xdata is not None: 
    343344            # Selecting a new line if cursor lines are displayed already 
    344345            dqmin = math.fabs(event.xdata - self.ly[0].get_xdata()) 
    … …  
    359360        Move the cursor line to write Q range 
    360361        """ 
    361         if self.q_ctrl == None: 
     362        if self.q_ctrl is None: 
    362363            return 
    363364        # release a q range vline 
    364         if self.ly != None and not self.leftdown: 
     365        if self.ly is not None and not self.leftdown: 
    365366            for ly in self.ly: 
    366367                ly.set_alpha(0.7) 
    … …  
    368369            return 
    369370        ax = event.inaxes 
    370         if ax == None or not hasattr(event, 'action'): 
     371        if ax is None or not hasattr(event, 'action'): 
    371372            return 
    372         end_drag = event.action != 'drag' and event.xdata != None 
     373        end_drag = event.action != 'drag' and event.xdata is not None 
    373374        nop = len(self.plots) 
    374375        pos_x, _ = float(event.xdata), float(event.ydata) 
    … …  
    409410            self.q_ctrl[vl_ind].SetValue(str(pos_x)) 
    410411        except: 
    411             logging.error(sys.exc_value) 
     412            logger.error(sys.exc_value) 
    412413 
    413414    def set_resizing(self, resizing=False): 
    … …  
    512513        ax = event.inaxes 
    513514        PlotPanel.onLeftDown(self, event) 
    514         if ax != None: 
     515        if ax is not None: 
    515516            try: 
    516517                pos_x = float(event.xdata)  # / size_x 
    … …  
    616617            # add menu of other plugins 
    617618            item_list = self.parent.get_current_context_menu(self) 
    618             if (not item_list == None) and (not len(item_list) == 0): 
     619            if (item_list is not None) and (len(item_list)): 
    619620                for item, wx_id in zip(item_list, [ids.next() for i in range(len(item_list))]): 
    620  
    621621                    try: 
    622622                        plot_menu.Append(wx_id, item[0], name) 
    … …  
    682682 
    683683 
    684         if self.position != None: 
     684        if self.position is not None: 
    685685            wx_id = ids.next() 
    686686            self._slicerpop.Append(wx_id, '&Add Text') 
    … …  
    731731                self.subplot.set_ylim(y_range) 
    732732                self.subplot.figure.canvas.draw_idle() 
     733                self.is_zoomed = True 
    733734        d.Destroy() 
    734735 
    … …  
    758759            default_name = default_name.split('.')[0] 
    759760        default_name += "_out" 
    760         if self.parent != None: 
     761        if self.parent is not None: 
    761762            self.parent.save_data1d(data, default_name) 
    762763 
    … …  
    776777            default_name = default_name.split('.')[0] 
    777778        # default_name += "_out" 
    778         if self.parent != None: 
     779        if self.parent is not None: 
    779780            self.parent.show_data1d(data, default_name) 
    780781 
    … …  
    808809        curr_label = self.appearance_selected_plot.label 
    809810 
    810         if curr_color == None: 
     811        if curr_color is None: 
    811812            curr_color = self._color_labels['Blue'] 
    812813            curr_symbol = 13 

  • src/sas/sasgui/guiframe/local_perspectives/plotting/Plotter2D.py

    rb2b36932 r7432acb  
    1414import sys 
    1515import math 
    16 import numpy 
     16import numpy as np 
    1717import logging 
    1818from sas.sasgui.plottools.PlotPanel import PlotPanel 
    … …  
    3030from graphAppearance import graphAppearance 
    3131(InternalEvent, EVT_INTERNAL) = wx.lib.newevent.NewEvent() 
     32 
     33logger = logging.getLogger(__name__) 
    3234 
    3335DEFAULT_QMAX = 0.05 
    … …  
    142144        """ 
    143145        # Not implemented 
    144         if event == None: 
     146        if event is None: 
    145147            return 
    146148        event.Skip() 
    … …  
    154156        PlotPanel.onLeftDown(self, event) 
    155157        ax = event.inaxes 
    156         if ax != None: 
     158        if ax is not None: 
    157159            # data coordinate position 
    158160            pos_x = "%8.3g" % event.xdata 
    … …  
    225227        if self._is_changed_legend_label: 
    226228            data.label = self.title_label 
    227         if data.label == None: 
     229        if data.label is None: 
    228230            data.label = data.name 
    229231        if not self.title_font: 
    … …  
    262264        # control axis labels from the panel itself 
    263265        yname, yunits = data.get_yaxis() 
    264         if self.yaxis_label != None: 
     266        if self.yaxis_label is not None: 
    265267            yname = self.yaxis_label 
    266268            yunits = self.yaxis_unit 
    … …  
    269271            self.yaxis_unit = yunits 
    270272        xname, xunits = data.get_xaxis() 
    271         if self.xaxis_label != None: 
     273        if self.xaxis_label is not None: 
    272274            xname = self.xaxis_label 
    273275            xunits = self.xaxis_unit 
    … …  
    318320        if len(self.data2D.detector) <= 1: 
    319321            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            if ((item_list is not None) and len(item_list) and 
     323                self.data2D.name.split(" ")[0] != 'Residuals'): 
    322324                for item, wx_id in zip(item_list, [ids.next() for i in range(len(item_list))]): 
    323325                    try: 
    … …  
    353355            slicerpop.Append(wx_id, '&Box Averaging in Qy') 
    354356            wx.EVT_MENU(self, wx_id, self.onBoxavgY) 
    355             if self.slicer != None: 
     357            if self.slicer is not None: 
    356358                wx_id = ids.next() 
    357359                slicerpop.Append(wx_id, '&Clear Slicer') 
    … …  
    432434            except: 
    433435                msg = "Add Text: Error. Check your property values..." 
    434                 logging.error(msg) 
    435                 if self.parent != None: 
     436                logger.error(msg) 
     437                if self.parent is not None: 
    436438                    wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    437439        dial.Destroy() 
    … …  
    531533        """ 
    532534        ## Clear current slicer 
    533         if not self.slicer == None: 
     535        if self.slicer is not None: 
    534536            self.slicer.clear() 
    535537        ## Create a new slicer 
    … …  
    567569        """ 
    568570        # Find the best number of bins 
    569         npt = math.sqrt(len(self.data2D.data[numpy.isfinite(self.data2D.data)])) 
     571        npt = math.sqrt(len(self.data2D.data[np.isfinite(self.data2D.data)])) 
    570572        npt = math.floor(npt) 
    571573        from sas.sascalc.dataloader.manipulations import CircularAverage 
    … …  
    627629 
    628630        """ 
    629         if self.slicer != None: 
     631        if self.slicer is not None: 
    630632            from SlicerParameters import SlicerParameterPanel 
    631633            dialog = SlicerParameterPanel(self, -1, "Slicer Parameters") 
    … …  
    717719        Clear the slicer on the plot 
    718720        """ 
    719         if not self.slicer == None: 
     721        if self.slicer is not None: 
    720722            self.slicer.clear() 
    721723            self.subplot.figure.canvas.draw() 
    … …  
    733735        """ 
    734736        event_id = str(evt.GetId()) 
    735         if self.parent != None: 
     737        if self.parent is not None: 
    736738            self._default_save_location = self.parent._default_save_location 
    737739        default_name = self.plots[self.graph.selected_plottable].label 
    … …  
    757759            default_name = default_name.split('.')[0] 
    758760        #default_name += "_out" 
    759         if self.parent != None: 
     761        if self.parent is not None: 
    760762            self.parent.show_data2d(data, default_name) 
    761763 

  • src/sas/sasgui/guiframe/local_perspectives/plotting/SectorSlicer.py

    r83eb5208 rc416a17  
    442442                self.restore() 
    443443                return 
    444  
    445444        self.phi = numpy.fabs(self.theta2 - self.theta) 
    446445        if self.phi > numpy.pi: 

  • src/sas/sasgui/guiframe/local_perspectives/plotting/SimplePlot.py

    rb742b2b9 r7432acb  
    8787            pos = (pos_x, pos_y + 5) 
    8888        self.PopupMenu(slicerpop, pos) 
    89         if self.scale != None: 
     89        if self.scale is not None: 
    9090            self.parent.scale2d = self.scale 
    9191 
    … …  
    106106            self.leftdown = True 
    107107            ax = event.inaxes 
    108             if ax != None: 
     108            if ax is not None: 
    109109                self.xInit, self.yInit = event.xdata, event.ydata 
    110110                try: 
    … …  
    123123        """ 
    124124        self.resizing = False 
    125         if self.x_size != None: 
     125        if self.x_size is not None: 
    126126            if self.x_size == self.GetSize(): 
    127127                self.canvas.set_resizing(self.resizing) 
    … …  
    161161        self.plots[plot.name] = plot 
    162162        # Axis scales 
    163         if plot.xtransform != None: 
     163        if plot.xtransform is not None: 
    164164            self.xLabel = plot.xtransform 
    165         if plot.ytransform != None: 
     165        if plot.ytransform is not None: 
    166166            self.yLabel = plot.ytransform 
    167167        # Init graph 

  • src/sas/sasgui/guiframe/local_perspectives/plotting/SlicerParameters.py

    rd85c194 r235f514  
    4646        """ 
    4747        event.Skip() 
    48         if event.obj_class == None: 
     48        if event.obj_class is None: 
    4949            self.set_slicer(None, None) 
    5050        else: 
    … …  
    5757        self.bck.Clear(True) 
    5858        self.type = type 
    59         if type == None: 
     59        if type is None: 
    6060            label = "Right-click on 2D plot for slicer options" 
    6161            title = wx.StaticText(self, -1, label, style=wx.ALIGN_LEFT) 

  • src/sas/sasgui/guiframe/local_perspectives/plotting/binder.py

    rd85c194 r463e7ffc  
    44import logging 
    55import sys 
     6 
     7logger = logging.getLogger(__name__) 
    68 
    79class Selection(object): 
    … …  
    7072            canvas.mpl_disconnect(canvas.scroll_pick_id) 
    7173        except: 
    72             logging.error(sys.exc_value) 
     74            logger.error(sys.exc_value) 
    7375        self.canvas = canvas 
    7476        self.figure = figure 

  • src/sas/sasgui/guiframe/local_perspectives/plotting/boxMask.py

    rd85c194 r7432acb  
    123123                                         x2=self.vertical_lines.x2, 
    124124                                         width=self.vertical_lines.half_width) 
    125         # if self.is_inside != None: 
     125        # if self.is_inside is not None: 
    126126        out = self._post_data() 
    127127        return out 

  • src/sas/sasgui/guiframe/local_perspectives/plotting/boxSum.py

    r83eb5208 rc416a17  
    362362        Draw the new roughness on the graph. 
    363363        """ 
    364         if center_x != None: 
     364        if center_x is not None: 
    365365            self.x = center_x 
    366         if center_y != None: 
     366        if center_y is not None: 
    367367            self.y = center_y 
    368368        self.center_marker.set(xdata=[self.x], ydata=[self.y]) 

  • src/sas/sasgui/guiframe/local_perspectives/plotting/detector_dialog.py

    r0783a2e r7432acb  
    9090            zmin = self.reset_zmin_ctl 
    9191            zmax = self.reset_zmax_ctl 
    92             if zmin == None: 
     92            if zmin is None: 
    9393                zmin = "" 
    94             if zmax == None: 
     94            if zmax is None: 
    9595                zmax = "" 
    9696            self.zmin_ctl.SetValue(str(zmin)) 
    … …  
    155155        self.qmax_ctl.SetLabel(str(format_number(qmax))) 
    156156        self.beam_ctl.SetLabel(str(format_number(beam))) 
    157         if zmin != None: 
     157        if zmin is not None: 
    158158            self.zmin_ctl.SetValue(str(format_number(zmin))) 
    159         if zmax != None: 
     159        if zmax is not None: 
    160160            self.zmax_ctl.SetValue(str(format_number(zmax))) 
    161161 

  • src/sas/sasgui/guiframe/local_perspectives/plotting/masking.py

    rd85c194 r45dffa69  
    2424import math 
    2525import copy 
    26 import numpy 
     26import numpy as np 
    2727from sas.sasgui.plottools.PlotPanel import PlotPanel 
    2828from sas.sasgui.plottools.plottables import Graph 
    … …  
    100100        wx.Dialog.__init__(self, parent, id=id, *args, **kwds) 
    101101 
    102         if data != None: 
     102        if data is not None: 
    103103            # Font size 
    104104            kwds = [] 
    … …  
    235235        event.Skip() 
    236236        # from boxMask import BoxMask 
    237         if event != None: 
     237        if event is not None: 
    238238            self._on_clear_slicer(event) 
    239239        self.slicer_z += 1 
    … …  
    249249        Add new mask to old mask 
    250250        """ 
    251         if not self.slicer == None: 
     251        if self.slicer is not None: 
    252252            data = Data2D() 
    253253            data = self.data 
    … …  
    269269        Erase new mask from old mask 
    270270        """ 
    271         if not self.slicer == None: 
     271        if self.slicer is not None: 
    272272            self.slicer_mask = self.slicer.update() 
    273273            mask = self.data.mask 
    … …  
    298298        self.subplot.set_ylim(self.data.ymin, self.data.ymax) 
    299299        self.subplot.set_xlim(self.data.xmin, self.data.xmax) 
    300         mask = numpy.ones(len(self.data.mask), dtype=bool) 
     300        mask = np.ones(len(self.data.mask), dtype=bool) 
    301301        self.data.mask = mask 
    302302        # update mask plot 
    … …  
    307307        Clear the slicer on the plot 
    308308        """ 
    309         if not self.slicer == None: 
     309        if self.slicer is not None: 
    310310            self.slicer.clear() 
    311311            self.subplot.figure.canvas.draw() 
    … …  
    336336        """ 
    337337        # the case of liitle numbers of True points 
    338         if len(mask[mask]) < 10 and self.data != None: 
     338        if len(mask[mask]) < 10 and self.data is not None: 
    339339            self.ShowMessage() 
    340340            mask = copy.deepcopy(self.mask) 
    … …  
    343343            self.mask = mask 
    344344        # make temperary data to plot 
    345         temp_mask = numpy.zeros(len(mask)) 
     345        temp_mask = np.zeros(len(mask)) 
    346346        temp_data = copy.deepcopy(self.data) 
    347347        # temp_data default is None 
    … …  
    355355        temp_data.data[mask == False] = temp_mask[mask == False] 
    356356        self.plotpanel.clear() 
    357         if self.slicer != None: 
     357        if self.slicer is not None: 
    358358            self.slicer.clear() 
    359359            self.slicer = None 
    … …  
    460460        wx.Dialog.__init__(self, parent, id=id, *args, **kwds) 
    461461 
    462         if data != None: 
     462        if data is not None: 
    463463            # Font size 
    464464            kwds = [] 
    … …  
    710710        Status msg 
    711711        """ 
    712         if self.parent.parent.parent != None: 
     712        if self.parent.parent.parent is not None: 
    713713            wx.PostEvent(self.parent.parent.parent, 
    714714                         StatusEvent(status=msg, type=type)) 

  • src/sas/sasgui/guiframe/local_perspectives/plotting/plotting.py

    r6ffa0dd r235f514  
    8888        On Qmin Qmax vertical line event 
    8989        """ 
    90         if event == None: 
     90        if event is None: 
    9191            return 
    9292        if event.id in self.plot_panels.keys(): 
    … …  
    9999 
    100100    def _on_plot_lim(self, event=None): 
    101         if event == None: 
     101        if event is None: 
    102102            return 
    103103        if event.id in self.plot_panels.keys(): 
    … …  
    134134        """ 
    135135        for group_id in self.plot_panels.keys(): 
    136             panel = self.plot_panels[group_id] 
    137             panel.graph.reset() 
    138             self.hide_panel(group_id) 
     136            self.clear_panel_by_id(group_id) 
    139137        self.plot_panels = {} 
    140138 

  • src/sas/sasgui/guiframe/local_perspectives/plotting/profile_dialog.py

    rd85c194 r7432acb  
    4444        wx.Dialog.__init__(self, parent, id=id, *args, **kwds) 
    4545 
    46         if data != None: 
     46        if data is not None: 
    4747            #Font size 
    4848            kwds = [] 
    … …  
    284284            default_name = default_name.split('.')[0] 
    285285        default_name += "_out" 
    286         if self.parent != None: 
     286        if self.parent is not None: 
    287287            # What an ancestor! 
    288288            fit_panel = self.parent.parent.parent 

  • src/sas/sasgui/guiframe/local_perspectives/plotting/sector_mask.py

    rd85c194 r7432acb  
    9696            self.left_line.update(phi=self.right_line.phi, delta=None, 
    9797                                  mline=self.main_line, side=True, left=False) 
    98         #if self.is_inside != None: 
     98        #if self.is_inside is not None: 
    9999        out = self._post_data() 
    100100        return out 
    … …  
    117117        data = self.base.data 
    118118        # If we have no data, just return 
    119         if data == None: 
     119        if data is None: 
    120120            return 
    121121        ## Averaging 

  • src/sas/sasgui/guiframe/local_perspectives/plotting/slicerpanel.py

    rd85c194 r7432acb  
    3737        self.bck = wx.GridBagSizer(5, 5) 
    3838        self.SetSizer(self.bck) 
    39         if type == None and params == None: 
     39        if type is None and params is None: 
    4040            label = "Right-click on 2D plot for slicer options" 
    4141            title = wx.StaticText(self, -1, label, style=wx.ALIGN_LEFT) 
    … …  
    5757        """ 
    5858        event.Skip() 
    59         if event.obj_class == None: 
     59        if event.obj_class is None: 
    6060            self.set_slicer(None, None) 
    6161        else: 
    … …  
    6868        self.bck.Clear(True) 
    6969        self.type = type 
    70         if type == None: 
     70        if type is None: 
    7171            label = "Right-click on 2D plot for slicer options" 
    7272            title = wx.StaticText(self, -1, label, style=wx.ALIGN_LEFT) 
    … …  
    114114        self.Layout() 
    115115        psizer = self.parent.GetSizer() 
    116         if psizer != None: 
     116        if psizer is not None: 
    117117            psizer.Layout() 
    118118 

  • src/sas/sasgui/guiframe/local_perspectives/plotting/AnnulusSlicer.py

    r7432acb r83eb5208  
    1 # TODO: the line slicer should listen to all 2DREFRESH events, get the data and slice it 
    2 #      before pushing a new 1D data update. 
    3  
    4 # 
    5 # TODO: NEED MAJOR REFACTOR 
    6 # 
    7  
    8 import math 
    9 import wx 
    10 # from copy import deepcopy 
    11 # Debug printout 
    12 from sas.sasgui.guiframe.events import NewPlotEvent 
    13 from sas.sasgui.guiframe.events import StatusEvent 
    14 from sas.sasgui.guiframe.events import SlicerParameterEvent 
    15 from sas.sasgui.guiframe.events import EVT_SLICER_PARS 
     1import numpy 
     2from PyQt4 import QtGui 
     3from PyQt4 import QtCore 
     4 
    165from BaseInteractor import _BaseInteractor 
    176from sas.sasgui.guiframe.dataFitting import Data1D 
    18  
    19 class AnnulusInteractor(_BaseInteractor): 
     7import sas.qtgui.Utilities.GuiUtils as GuiUtils 
     8from sas.qtgui.Utilities.GuiUtils import formatNumber 
     9from sas.qtgui.Plotting.SlicerModel import SlicerModel 
     10 
     11class AnnulusInteractor(_BaseInteractor, SlicerModel): 
    2012    """ 
    2113    Select an annulus through a 2D plot. 
    … …  
    2416    this class is defined by 2 Ringinterators. 
    2517    """ 
    26     def __init__(self, base, axes, color='black', zorder=3): 
     18    def __init__(self, base, axes, item=None, color='black', zorder=3): 
    2719 
    2820        _BaseInteractor.__init__(self, base, axes, color=color) 
     21        SlicerModel.__init__(self) 
     22 
    2923        self.markers = [] 
    3024        self.axes = axes 
    3125        self.base = base 
    32         self.qmax = min(math.fabs(self.base.data2D.xmax), 
    33                         math.fabs(self.base.data2D.xmin))  # must be positive 
     26        self._item = item 
     27        self.qmax = min(numpy.fabs(self.base.data.xmax), 
     28                        numpy.fabs(self.base.data.xmin))  # must be positive 
    3429        self.connect = self.base.connect 
    3530 
    36         # # Number of points on the plot 
     31        # Number of points on the plot 
    3732        self.nbins = 36 
    3833        # Cursor position of Rings (Left(-1) or Right(1)) 
    39         self.xmaxd = self.base.data2D.xmax 
    40         self.xmind = self.base.data2D.xmin 
     34        self.xmaxd = self.base.data.xmax 
     35        self.xmind = self.base.data.xmin 
    4136 
    4237        if (self.xmaxd + self.xmind) > 0: 
    … …  
    4540            self.sign = -1 
    4641        # Inner circle 
    47         self.inner_circle = RingInteractor(self, self.base.subplot, 
     42        self.inner_circle = RingInteractor(self, self.axes, 
    4843                                           zorder=zorder, 
    4944                                           r=self.qmax / 2.0, sign=self.sign) 
    5045        self.inner_circle.qmax = self.qmax 
    51         self.outer_circle = RingInteractor(self, self.base.subplot, 
     46        self.outer_circle = RingInteractor(self, self.axes, 
    5247                                           zorder=zorder + 1, r=self.qmax / 1.8, 
    5348                                           sign=self.sign) 
    … …  
    5651        self._post_data() 
    5752 
    58         # Bind to slice parameter events 
    59         self.base.Bind(EVT_SLICER_PARS, self._onEVT_SLICER_PARS) 
    60  
    61     def _onEVT_SLICER_PARS(self, event): 
    62         """ 
    63         receive an event containing parameters values to reset the slicer 
    64  
    65         :param event: event of type SlicerParameterEvent with params as 
    66             attribute 
    67  
    68         """ 
    69         wx.PostEvent(self.base, 
    70                      StatusEvent(status="AnnulusSlicer._onEVT_SLICER_PARS")) 
    71         event.Skip() 
    72         if event.type == self.__class__.__name__: 
    73             self.set_params(event.params) 
    74             self.base.update() 
     53        self.setModelFromParams() 
    7554 
    7655    def set_layer(self, n): 
    … …  
    9271        self.inner_circle.clear() 
    9372        self.base.connect.clearall() 
    94         self.base.Unbind(EVT_SLICER_PARS) 
    9573 
    9674    def update(self): 
    … …  
    10886        can restore on Esc. 
    10987        """ 
    110         self.base.freeze_axes() 
    11188        self.inner_circle.save(ev) 
    11289        self.outer_circle.save(ev) 
    … …  
    12097        """ 
    12198        # Data to average 
    122         data = self.base.data2D 
    123         # If we have no data, just return 
     99        data = self.base.data 
    124100        if data is None: 
    125101            return 
    126102 
    127103        from sas.sascalc.dataloader.manipulations import Ring 
    128         rmin = min(math.fabs(self.inner_circle.get_radius()), 
    129                    math.fabs(self.outer_circle.get_radius())) 
    130         rmax = max(math.fabs(self.inner_circle.get_radius()), 
    131                    math.fabs(self.outer_circle.get_radius())) 
    132         # if the user does not specify the numbers of points to plot 
     104        rmin = min(numpy.fabs(self.inner_circle.get_radius()), 
     105                   numpy.fabs(self.outer_circle.get_radius())) 
     106        rmax = max(numpy.fabs(self.inner_circle.get_radius()), 
     107                   numpy.fabs(self.outer_circle.get_radius())) 
     108        # If the user does not specify the numbers of points to plot 
    133109        # the default number will be nbins= 36 
    134110        if nbins is None: 
    … …  
    136112        else: 
    137113            self.nbins = nbins 
    138         # # create the data1D Q average of data2D 
     114        # Create the data1D Q average of data2D 
    139115        sect = Ring(r_min=rmin, r_max=rmax, nbins=self.nbins) 
    140         sector = sect(self.base.data2D) 
     116        sector = sect(self.base.data) 
    141117 
    142118        if hasattr(sector, "dxl"): 
    … …  
    148124        else: 
    149125            dxw = None 
    150         new_plot = Data1D(x=(sector.x - math.pi) * 180 / math.pi, 
     126        new_plot = Data1D(x=(sector.x - numpy.pi) * 180 / numpy.pi, 
    151127                          y=sector.y, dy=sector.dy) 
    152128        new_plot.dxl = dxl 
    153129        new_plot.dxw = dxw 
    154         new_plot.name = "AnnulusPhi" + "(" + self.base.data2D.name + ")" 
    155  
    156         new_plot.source = self.base.data2D.source 
    157         # new_plot.info=self.base.data2D.info 
     130        new_plot.name = "AnnulusPhi" + "(" + self.base.data.name + ")" 
     131        new_plot.title = "AnnulusPhi" + "(" + self.base.data.name + ")" 
     132 
     133        new_plot.source = self.base.data.source 
    158134        new_plot.interactive = True 
    159         new_plot.detector = self.base.data2D.detector 
     135        new_plot.detector = self.base.data.detector 
    160136        # If the data file does not tell us what the axes are, just assume... 
    161137        new_plot.xaxis("\\rm{\phi}", 'degrees') 
    162138        new_plot.yaxis("\\rm{Intensity} ", "cm^{-1}") 
    163139        if hasattr(data, "scale") and data.scale == 'linear' and \ 
    164                 self.base.data2D.name.count("Residuals") > 0: 
     140                self.base.data.name.count("Residuals") > 0: 
    165141            new_plot.ytransform = 'y' 
    166142            new_plot.yaxis("\\rm{Residuals} ", "/") 
    167143 
    168         new_plot.group_id = "AnnulusPhi" + self.base.data2D.name 
    169         new_plot.id = "AnnulusPhi" + self.base.data2D.name 
     144        new_plot.group_id = "AnnulusPhi" + self.base.data.name 
     145        new_plot.id = "AnnulusPhi" + self.base.data.name 
    170146        new_plot.is_data = True 
    171147        new_plot.xtransform = "x" 
    172148        new_plot.ytransform = "y" 
    173         self.base.parent.update_theory(data_id=data.id, theory=new_plot) 
    174         wx.PostEvent(self.base.parent, NewPlotEvent(plot=new_plot, title="AnnulusPhi")) 
     149        variant_plot = QtCore.QVariant(new_plot) 
     150        GuiUtils.updateModelItemWithPlot(self._item, variant_plot, new_plot.id) 
     151        self.base.manager.communicator.plotUpdateSignal.emit([new_plot]) 
     152 
     153        if self.update_model: 
     154            self.setModelFromParams() 
     155        self.draw() 
     156 
     157    def validate(self, param_name, param_value): 
     158        """ 
     159        Test the proposed new value "value" for row "row" of parameters 
     160        """ 
     161        MIN_DIFFERENCE = 0.01 
     162        isValid = True 
     163 
     164        if param_name == 'inner_radius': 
     165            # First, check the closeness 
     166            if numpy.fabs(param_value - self.getParams()['outer_radius']) < MIN_DIFFERENCE: 
     167                print("Inner and outer radii too close. Please adjust.") 
     168                isValid = False 
     169            elif param_value > self.qmax: 
     170                print("Inner radius exceeds maximum range. Please adjust.") 
     171                isValid = False 
     172        elif param_name == 'outer_radius': 
     173            # First, check the closeness 
     174            if numpy.fabs(param_value - self.getParams()['inner_radius']) < MIN_DIFFERENCE: 
     175                print("Inner and outer radii too close. Please adjust.") 
     176                isValid = False 
     177            elif param_value > self.qmax: 
     178                print("Outer radius exceeds maximum range. Please adjust.") 
     179                isValid = False 
     180        elif param_name == 'nbins': 
     181            # Can't be 0 
     182            if param_value < 1: 
     183                print("Number of bins cannot be less than or equal to 0. Please adjust.") 
     184                isValid = False 
     185 
     186        return isValid 
    175187 
    176188    def moveend(self, ev): 
    177189        """ 
    178190        Called when any dragging motion ends. 
    179         Post an event (type =SlicerParameterEvent) 
    180         to plotter 2D with a copy  slicer parameters 
    181         Call  _post_data method 
    182         """ 
    183         self.base.thaw_axes() 
    184         # Post parameters to plotter 2D 
    185         event = SlicerParameterEvent() 
    186         event.type = self.__class__.__name__ 
    187         event.params = self.get_params() 
    188         wx.PostEvent(self.base, event) 
     191        Redraw the plot with new parameters. 
     192        """ 
     193        self._post_data(self.nbins) 
    189194 
    190195    def restore(self): 
    … …  
    204209        pass 
    205210 
    206     def get_params(self): 
     211    def getParams(self): 
    207212        """ 
    208213        Store a copy of values of parameters of the slicer into a dictionary. 
    209  
    210214        :return params: the dictionary created 
    211  
    212215        """ 
    213216        params = {} 
    214         params["inner_radius"] = math.fabs(self.inner_circle._inner_mouse_x) 
    215         params["outer_radius"] = math.fabs(self.outer_circle._inner_mouse_x) 
     217        params["inner_radius"] = numpy.fabs(self.inner_circle._inner_mouse_x) 
     218        params["outer_radius"] = numpy.fabs(self.outer_circle._inner_mouse_x) 
    216219        params["nbins"] = self.nbins 
    217220        return params 
    218221 
    219     def set_params(self, params): 
     222    def setParams(self, params): 
    220223        """ 
    221224        Receive a dictionary and reset the slicer with values contained 
    … …  
    224227        :param params: a dictionary containing name of slicer parameters and 
    225228            values the user assigned to the slicer. 
    226  
    227         """ 
    228         inner = math.fabs(params["inner_radius"]) 
    229         outer = math.fabs(params["outer_radius"]) 
     229        """ 
     230        inner = numpy.fabs(params["inner_radius"]) 
     231        outer = numpy.fabs(params["outer_radius"]) 
    230232        self.nbins = int(params["nbins"]) 
    231         # # Update the picture 
     233        # Update the picture 
    232234        self.inner_circle.set_cursor(inner, self.inner_circle._inner_mouse_y) 
    233235        self.outer_circle.set_cursor(outer, self.outer_circle._inner_mouse_y) 
    234         # # Post the data given the nbins entered by the user 
     236        # Post the data given the nbins entered by the user 
    235237        self._post_data(self.nbins) 
    236  
    237     def freeze_axes(self): 
    238         """ 
    239         """ 
    240         self.base.freeze_axes() 
    241  
    242     def thaw_axes(self): 
    243         """ 
    244         """ 
    245         self.base.thaw_axes() 
    246238 
    247239    def draw(self): 
    … …  
    278270        self.sign = sign 
    279271        # # Create a marker 
    280         try: 
    281             # Inner circle marker 
    282             x_value = [self.sign * math.fabs(self._inner_mouse_x)] 
    283             self.inner_marker = self.axes.plot(x_value, [0], linestyle='', 
    284                                                marker='s', markersize=10, 
    285                                                color=self.color, alpha=0.6, 
    286                                                pickradius=5, label="pick", 
    287                                                zorder=zorder, 
    288                                                visible=True)[0] 
    289         except: 
    290             x_value = [self.sign * math.fabs(self._inner_mouse_x)] 
    291             self.inner_marker = self.axes.plot(x_value, [0], linestyle='', 
    292                                                marker='s', markersize=10, 
    293                                                color=self.color, alpha=0.6, 
    294                                                label="pick", 
    295                                                visible=True)[0] 
    296             message = "\nTHIS PROTOTYPE NEEDS THE LATEST" 
    297             message += " VERSION OF MATPLOTLIB\n" 
    298             message += "Get the SVN version that is at " 
    299             message += " least as recent as June 1, 2007" 
    300  
    301             owner = self.base.base.parent 
    302             wx.PostEvent(owner, StatusEvent(status="AnnulusSlicer: %s" % message)) 
    303  
     272        # Inner circle marker 
     273        x_value = [self.sign * numpy.fabs(self._inner_mouse_x)] 
     274        self.inner_marker = self.axes.plot(x_value, [0], linestyle='', 
     275                                           marker='s', markersize=10, 
     276                                           color=self.color, alpha=0.6, 
     277                                           pickradius=5, label="pick", 
     278                                           zorder=zorder, 
     279                                           visible=True)[0] 
    304280        # Draw a circle 
    305281        [self.inner_circle] = self.axes.plot([], [], linestyle='-', marker='', color=self.color) 
    306         # the number of points that make the ring line 
     282        # The number of points that make the ring line 
    307283        self.npts = 40 
    308284 
    … …  
    325301        """ 
    326302        self.clear_markers() 
    327         try: 
    328             self.inner_marker.remove() 
    329             self.inner_circle.remove() 
    330         except: 
    331             # Old version of matplotlib 
    332             for item in range(len(self.axes.lines)): 
    333                 del self.axes.lines[0] 
     303        self.inner_marker.remove() 
     304        self.inner_circle.remove() 
    334305 
    335306    def get_radius(self): 
    … …  
    347318        y = [] 
    348319        for i in range(self.npts): 
    349             phi = 2.0 * math.pi / (self.npts - 1) * i 
    350  
    351             xval = 1.0 * self._inner_mouse_x * math.cos(phi) 
    352             yval = 1.0 * self._inner_mouse_x * math.sin(phi) 
     320            phi = 2.0 * numpy.pi / (self.npts - 1) * i 
     321 
     322            xval = 1.0 * self._inner_mouse_x * numpy.cos(phi) 
     323            yval = 1.0 * self._inner_mouse_x * numpy.sin(phi) 
    353324 
    354325            x.append(xval) 
    355326            y.append(yval) 
    356327 
    357         self.inner_marker.set(xdata=[self.sign * math.fabs(self._inner_mouse_x)], 
     328        self.inner_marker.set(xdata=[self.sign * numpy.fabs(self._inner_mouse_x)], 
    358329                              ydata=[0]) 
    359330        self.inner_circle.set_data(x, y) 
    … …  
    366337        self._inner_save_x = self._inner_mouse_x 
    367338        self._inner_save_y = self._inner_mouse_y 
    368         self.base.freeze_axes() 
    369339 
    370340    def moveend(self, ev): 
    … …  
    396366        self.update() 
    397367 
    398  
    399     def get_params(self): 
     368    def getParams(self): 
    400369        """ 
    401370        Store a copy of values of parameters of the slicer into a dictionary. 
    402  
    403371        :return params: the dictionary created 
    404  
    405372        """ 
    406373        params = {} 
    407         params["radius"] = math.fabs(self._inner_mouse_x) 
     374        params["radius"] = numpy.fabs(self._inner_mouse_x) 
    408375        return params 
    409376 
    410     def set_params(self, params): 
     377    def setParams(self, params): 
    411378        """ 
    412379        Receive a dictionary and reset the slicer with values contained 
    … …  
    435402        self.base = base 
    436403        self.is_inside = side 
    437         self.qmax = min(math.fabs(self.base.data.xmax), 
    438                         math.fabs(self.base.data.xmin))  # must be positive 
     404        self.qmax = min(numpy.fabs(self.base.data.xmax), 
     405                        numpy.fabs(self.base.data.xmin))  # must be positive 
    439406        self.connect = self.base.connect 
    440407 
    … …  
    448415            self.sign = -1 
    449416        # Inner circle 
    450         self.outer_circle = RingInteractor(self, self.base.subplot, 'blue', 
     417        self.outer_circle = RingInteractor(self, self.axes, 'blue', 
    451418                                           zorder=zorder + 1, r=self.qmax / 1.8, 
    452419                                           sign=self.sign) 
    … …  
    455422        self._post_data() 
    456423 
    457         # Bind to slice parameter events 
    458         # self.base.Bind(EVT_SLICER_PARS, self._onEVT_SLICER_PARS) 
    459  
    460     def _onEVT_SLICER_PARS(self, event): 
    461         """ 
    462         receive an event containing parameters values to reset the slicer 
    463  
    464         :param event: event of type SlicerParameterEvent with params as 
    465             attribute 
    466         """ 
    467         wx.PostEvent(self.base, 
    468                      StatusEvent(status="AnnulusSlicer._onEVT_SLICER_PARS")) 
    469         event.Skip() 
    470         if event.type == self.__class__.__name__: 
    471             self.set_params(event.params) 
    472             self.base.update() 
    473  
    474424    def set_layer(self, n): 
    475425        """ 
    476426        Allow adding plot to the same panel 
    477  
    478427        :param n: the number of layer 
    479  
    480428        """ 
    481429        self.layernum = n 
    … …  
    489437        self.outer_circle.clear() 
    490438        self.base.connect.clearall() 
    491         # self.base.Unbind(EVT_SLICER_PARS) 
    492439 
    493440    def update(self): 
    … …  
    498445        # Update locations 
    499446        self.outer_circle.update() 
    500         # if self.is_inside is not None: 
     447        self._post_data() 
    501448        out = self._post_data() 
    502449        return out 
    … …  
    507454        can restore on Esc. 
    508455        """ 
    509         self.base.freeze_axes() 
    510456        self.outer_circle.save(ev) 
    511457 
    … …  
    527473 
    528474        rmin = 0 
    529         rmax = math.fabs(self.outer_circle.get_radius()) 
    530  
    531         # # create the data1D Q average of data2D 
     475        rmax = numpy.fabs(self.outer_circle.get_radius()) 
     476 
     477        # Create the data1D Q average of data2D 
    532478        mask = Ringcut(r_min=rmin, r_max=rmax) 
    533479 
    … …  
    536482        else: 
    537483            out = (mask(data)) 
    538         # self.base.data.mask=out 
    539484        return out 
    540485 
    … …  
    566511        pass 
    567512 
    568     def get_params(self): 
     513    def getParams(self): 
    569514        """ 
    570515        Store a copy of values of parameters of the slicer into a dictionary. 
    … …  
    574519        """ 
    575520        params = {} 
    576         params["outer_radius"] = math.fabs(self.outer_circle._inner_mouse_x) 
     521        params["outer_radius"] = numpy.fabs(self.outer_circle._inner_mouse_x) 
    577522        return params 
    578523 
    579     def set_params(self, params): 
     524    def setParams(self, params): 
    580525        """ 
    581526        Receive a dictionary and reset the slicer with values contained 
    … …  
    585530            values the user assigned to the slicer. 
    586531        """ 
    587         outer = math.fabs(params["outer_radius"]) 
    588         # # Update the picture 
     532        outer = numpy.fabs(params["outer_radius"]) 
     533        # Update the picture 
    589534        self.outer_circle.set_cursor(outer, self.outer_circle._inner_mouse_y) 
    590         # # Post the data given the nbins entered by the user 
     535        # Post the data given the nbins entered by the user 
    591536        self._post_data() 
    592  
    593     def freeze_axes(self): 
    594         self.base.freeze_axes() 
    595  
    596     def thaw_axes(self): 
    597         self.base.thaw_axes() 
    598537 
    599538    def draw(self): 

  • src/sas/sasgui/guiframe/local_perspectives/plotting/AzimutSlicer.py

    rd85c194 r161713c  
    182182                     NewPlotEvent(plot=new_plot, title=str(new_sector.__name__))) 
    183183 
     184 
     185    def validate(self, param_name, param_value): 
     186        """ 
     187        Test the proposed new value "value" for row "row" of parameters 
     188        """ 
     189        # Here, always return true 
     190        return True 
     191 
    184192    def moveend(self, ev): 
    185193        #TODO: why is this empty? 

  • src/sas/sasgui/guiframe/local_perspectives/plotting/boxSlicer.py

    r7432acb r83eb5208  
    1 import wx 
    2 import math 
    3 import numpy as np 
    4 from sas.sasgui.guiframe.events import NewPlotEvent 
    5 from sas.sasgui.guiframe.events import StatusEvent 
    6 from sas.sasgui.guiframe.events import SlicerParameterEvent 
    7 from sas.sasgui.guiframe.events import EVT_SLICER_PARS 
     1import numpy 
     2from PyQt4 import QtGui 
     3from PyQt4 import QtCore 
     4 
    85from BaseInteractor import _BaseInteractor 
    96from sas.sasgui.guiframe.dataFitting import Data1D 
    10  
    11  
    12 class BoxInteractor(_BaseInteractor): 
     7import sas.qtgui.Utilities.GuiUtils as GuiUtils 
     8from sas.qtgui.Plotting.SlicerModel import SlicerModel 
     9 
     10 
     11class BoxInteractor(_BaseInteractor, SlicerModel): 
    1312    """ 
    1413    BoxInteractor define a rectangle that return data1D average of Data2D 
    1514    in a rectangle area defined by -x, x ,y, -y 
    1615    """ 
    17     def __init__(self, base, axes, color='black', zorder=3): 
     16    def __init__(self, base, axes, item=None, color='black', zorder=3): 
    1817        _BaseInteractor.__init__(self, base, axes, color=color) 
    19         # # Class initialization 
     18        SlicerModel.__init__(self) 
     19        # Class initialization 
    2020        self.markers = [] 
    2121        self.axes = axes 
    22         # #connecting artist 
     22        self._item = item 
     23        #connecting artist 
    2324        self.connect = self.base.connect 
    24         # # which direction is the preferred interaction direction 
     25        # which direction is the preferred interaction direction 
    2526        self.direction = None 
    26         # # determine x y  values 
    27         self.x = 0.5 * min(math.fabs(self.base.data2D.xmax), 
    28                            math.fabs(self.base.data2D.xmin)) 
    29         self.y = 0.5 * min(math.fabs(self.base.data2D.xmax), 
    30                            math.fabs(self.base.data2D.xmin)) 
    31         # # when reach qmax reset the graph 
    32         self.qmax = max(self.base.data2D.xmax, self.base.data2D.xmin, 
    33                         self.base.data2D.ymax, self.base.data2D.ymin) 
    34         # # Number of points on the plot 
     27        # determine x y  values 
     28        self.x = 0.5 * min(numpy.fabs(self.base.data.xmax), 
     29                           numpy.fabs(self.base.data.xmin)) 
     30        self.y = 0.5 * min(numpy.fabs(self.base.data.xmax), 
     31                           numpy.fabs(self.base.data.xmin)) 
     32        # when reach qmax reset the graph 
     33        self.qmax = max(self.base.data.xmax, self.base.data.xmin, 
     34                        self.base.data.ymax, self.base.data.ymin) 
     35        # Number of points on the plot 
    3536        self.nbins = 30 
    36         # # If True, I(|Q|) will be return, otherwise, 
     37        # If True, I(|Q|) will be return, otherwise, 
    3738        # negative q-values are allowed 
    3839        self.fold = True 
    39         # # reference of the current  Slab averaging 
     40        # reference of the current  Slab averaging 
    4041        self.averager = None 
    41         # # Create vertical and horizaontal lines for the rectangle 
     42        # Create vertical and horizaontal lines for the rectangle 
    4243        self.vertical_lines = VerticalLines(self, 
    43                                             self.base.subplot, 
     44                                            self.axes, 
    4445                                            color='blue', 
    4546                                            zorder=zorder, 
    … …  
    4950 
    5051        self.horizontal_lines = HorizontalLines(self, 
    51                                                 self.base.subplot, 
     52                                                self.axes, 
    5253                                                color='green', 
    5354                                                zorder=zorder, 
    … …  
    5556                                                y=self.y) 
    5657        self.horizontal_lines.qmax = self.qmax 
    57         # # draw the rectangle and plost the data 1D resulting 
    58         # # of averaging data2D 
     58        # draw the rectangle and plost the data 1D resulting 
     59        # of averaging data2D 
    5960        self.update() 
    6061        self._post_data() 
    61         # # Bind to slice parameter events 
    62         self.base.Bind(EVT_SLICER_PARS, self._onEVT_SLICER_PARS) 
    63  
    64     def _onEVT_SLICER_PARS(self, event): 
    65         """ 
    66         receive an event containing parameters values to reset the slicer 
    67  
    68         :param event: event of type SlicerParameterEvent with params as 
    69             attribute 
    70         """ 
    71         wx.PostEvent(self.base.parent, 
    72                      StatusEvent(status="BoxSlicer._onEVT_SLICER_PARS")) 
    73         event.Skip() 
    74         if event.type == self.__class__.__name__: 
    75             self.set_params(event.params) 
    76             self.base.update() 
     62        self.setModelFromParams() 
    7763 
    7864    def update_and_post(self): 
    … …  
    10288        self.vertical_lines.clear() 
    10389        self.base.connect.clearall() 
    104         self.base.Unbind(EVT_SLICER_PARS) 
    10590 
    10691    def update(self): 
    … …  
    123108        can restore on Esc. 
    124109        """ 
    125         self.base.freeze_axes() 
    126110        self.vertical_lines.save(ev) 
    127111        self.horizontal_lines.save(ev) 
    … …  
    142126            self.direction = direction 
    143127 
    144         x_min = -1 * math.fabs(self.vertical_lines.x) 
    145         x_max = math.fabs(self.vertical_lines.x) 
    146         y_min = -1 * math.fabs(self.horizontal_lines.y) 
    147         y_max = math.fabs(self.horizontal_lines.y) 
     128        x_min = -1 * numpy.fabs(self.vertical_lines.x) 
     129        x_max = numpy.fabs(self.vertical_lines.x) 
     130        y_min = -1 * numpy.fabs(self.horizontal_lines.y) 
     131        y_max = numpy.fabs(self.horizontal_lines.y) 
    148132 
    149133        if nbins is not None: 
    … …  
    158142                x_low = 0 
    159143            else: 
    160                 x_low = math.fabs(x_min) 
     144                x_low = numpy.fabs(x_min) 
    161145            bin_width = (x_max + x_low) / self.nbins 
    162146        elif self.direction == "Y": 
    … …  
    164148                y_low = 0 
    165149            else: 
    166                 y_low = math.fabs(y_min) 
     150                y_low = numpy.fabs(y_min) 
    167151            bin_width = (y_max + y_low) / self.nbins 
    168152        else: 
    … …  
    173157                            bin_width=bin_width) 
    174158        box.fold = self.fold 
    175         boxavg = box(self.base.data2D) 
     159        boxavg = box(self.base.data) 
    176160        # 3 Create Data1D to plot 
    177161        if hasattr(boxavg, "dxl"): 
    … …  
    187171        new_plot.dxw = dxw 
    188172        new_plot.name = str(self.averager.__name__) + \ 
    189                         "(" + self.base.data2D.name + ")" 
    190         new_plot.source = self.base.data2D.source 
     173                        "(" + self.base.data.name + ")" 
     174        new_plot.title = str(self.averager.__name__) + \ 
     175                        "(" + self.base.data.name + ")" 
     176        new_plot.source = self.base.data.source 
    191177        new_plot.interactive = True 
    192         new_plot.detector = self.base.data2D.detector 
     178        new_plot.detector = self.base.data.detector 
    193179        # # If the data file does not tell us what the axes are, just assume... 
    194180        new_plot.xaxis("\\rm{Q}", "A^{-1}") 
    195181        new_plot.yaxis("\\rm{Intensity} ", "cm^{-1}") 
    196182 
    197         data = self.base.data2D 
     183        data = self.base.data 
    198184        if hasattr(data, "scale") and data.scale == 'linear' and \ 
    199                 self.base.data2D.name.count("Residuals") > 0: 
     185                self.base.data.name.count("Residuals") > 0: 
    200186            new_plot.ytransform = 'y' 
    201187            new_plot.yaxis("\\rm{Residuals} ", "/") 
    202188 
    203         new_plot.group_id = "2daverage" + self.base.data2D.name 
    204         new_plot.id = (self.averager.__name__) + self.base.data2D.name 
     189        new_plot.group_id = "2daverage" + self.base.data.name 
     190        new_plot.id = (self.averager.__name__) + self.base.data.name 
    205191        new_plot.is_data = True 
    206         self.base.parent.update_theory(data_id=self.base.data2D.id, \ 
    207                                        theory=new_plot) 
    208         wx.PostEvent(self.base.parent, 
    209                      NewPlotEvent(plot=new_plot, title=str(self.averager.__name__))) 
     192        variant_plot = QtCore.QVariant(new_plot) 
     193        GuiUtils.updateModelItemWithPlot(self._item, variant_plot, new_plot.id) 
     194 
     195        if self.update_model: 
     196            self.setModelFromParams() 
     197        self.draw() 
    210198 
    211199    def moveend(self, ev): 
    … …  
    215203        corresponding to the new average 
    216204        """ 
    217         self.base.thaw_axes() 
    218         # Post paramters 
    219         event = SlicerParameterEvent() 
    220         event.type = self.__class__.__name__ 
    221         event.params = self.get_params() 
    222         wx.PostEvent(self.base.parent, event) 
    223         # create the new data1D 
    224205        self._post_data() 
    225206 
    … …  
    240221        pass 
    241222 
    242     def get_params(self): 
     223    def getParams(self): 
    243224        """ 
    244225        Store a copy of values of parameters of the slicer into a dictionary. 
    … …  
    248229        """ 
    249230        params = {} 
    250         params["x_max"] = math.fabs(self.vertical_lines.x) 
    251         params["y_max"] = math.fabs(self.horizontal_lines.y) 
     231        params["x_max"] = numpy.fabs(self.vertical_lines.x) 
     232        params["y_max"] = numpy.fabs(self.horizontal_lines.y) 
    252233        params["nbins"] = self.nbins 
    253234        return params 
    254235 
    255     def set_params(self, params): 
     236    def setParams(self, params): 
    256237        """ 
    257238        Receive a dictionary and reset the slicer with values contained 
    … …  
    261242            values the user assigned to the slicer. 
    262243        """ 
    263         self.x = float(math.fabs(params["x_max"])) 
    264         self.y = float(math.fabs(params["y_max"])) 
     244        self.x = float(numpy.fabs(params["x_max"])) 
     245        self.y = float(numpy.fabs(params["y_max"])) 
    265246        self.nbins = params["nbins"] 
    266247 
    … …  
    269250        self.post_data(nbins=None) 
    270251 
    271     def freeze_axes(self): 
    272         """ 
    273         """ 
    274         self.base.freeze_axes() 
    275  
    276     def thaw_axes(self): 
    277         """ 
    278         """ 
    279         self.base.thaw_axes() 
    280  
    281252    def draw(self): 
    282253        """ 
    … …  
    294265        """ 
    295266        _BaseInteractor.__init__(self, base, axes, color=color) 
    296         # #Class initialization 
     267        # Class initialization 
    297268        self.markers = [] 
    298269        self.axes = axes 
    299         # # Saving the end points of two lines 
     270        # Saving the end points of two lines 
    300271        self.x = x 
    301272        self.save_x = x 
    … …  
    303274        self.y = y 
    304275        self.save_y = y 
    305         # # Creating a marker 
     276        # Creating a marker 
    306277        # Inner circle marker 
    307278        self.inner_marker = self.axes.plot([0], [self.y], linestyle='', 
    … …  
    311282                                           zorder=zorder, 
    312283                                           visible=True)[0] 
    313         # # Define 2 horizontal lines 
     284        # Define 2 horizontal lines 
    314285        self.top_line = self.axes.plot([self.x, -self.x], [self.y, self.y], 
    315286                                       linestyle='-', marker='', 
    … …  
    318289                                          linestyle='-', marker='', 
    319290                                          color=self.color, visible=True)[0] 
    320         # # Flag to check the motion of the lines 
     291        # Flag to check the motion of the lines 
    321292        self.has_move = False 
    322         # # Connecting markers to mouse events and draw 
     293        # Connecting markers to mouse events and draw 
    323294        self.connect_markers([self.top_line, self.inner_marker]) 
    324295        self.update() 
    … …  
    339310        """ 
    340311        self.clear_markers() 
    341         try: 
    342             self.inner_marker.remove() 
    343             self.top_line.remove() 
    344             self.bottom_line.remove() 
    345         except: 
    346             # Old version of matplotlib 
    347             for item in range(len(self.axes.lines)): 
    348                 del self.axes.lines[0] 
     312        self.inner_marker.remove() 
     313        self.top_line.remove() 
     314        self.bottom_line.remove() 
    349315 
    350316    def update(self, x=None, y=None): 
    … …  
    356322 
    357323        """ 
    358         # # Reset x, y- coordinates if send as parameters 
     324        # Reset x, y- coordinates if send as parameters 
    359325        if x is not None: 
    360             self.x = np.sign(self.x) * math.fabs(x) 
     326            self.x = numpy.sign(self.x) * numpy.fabs(x) 
    361327        if y is not None: 
    362             self.y = np.sign(self.y) * math.fabs(y) 
    363         # # Draw lines and markers 
     328            self.y = numpy.sign(self.y) * numpy.fabs(y) 
     329        # Draw lines and markers 
    364330        self.inner_marker.set(xdata=[0], ydata=[self.y]) 
    365331        self.top_line.set(xdata=[self.x, -self.x], ydata=[self.y, self.y]) 
    … …  
    373339        self.save_x = self.x 
    374340        self.save_y = self.y 
    375         self.base.freeze_axes() 
    376341 
    377342    def moveend(self, ev): 
    … …  
    409374        self.markers = [] 
    410375        self.axes = axes 
    411         self.x = math.fabs(x) 
     376        self.x = numpy.fabs(x) 
    412377        self.save_x = self.x 
    413         self.y = math.fabs(y) 
     378        self.y = numpy.fabs(y) 
    414379        self.save_y = y 
    415380        # Inner circle marker 
    … …  
    446411        """ 
    447412        self.clear_markers() 
    448         try: 
    449             self.inner_marker.remove() 
    450             self.left_line.remove() 
    451             self.right_line.remove() 
    452         except: 
    453             # Old version of matplotlib 
    454             for item in range(len(self.axes.lines)): 
    455                 del self.axes.lines[0] 
     413        self.inner_marker.remove() 
     414        self.left_line.remove() 
     415        self.right_line.remove() 
    456416 
    457417    def update(self, x=None, y=None): 
    … …  
    463423 
    464424        """ 
    465         # # reset x, y -coordinates if given as parameters 
     425        # Reset x, y -coordinates if given as parameters 
    466426        if x is not None: 
    467             self.x = np.sign(self.x) * math.fabs(x) 
     427            self.x = numpy.sign(self.x) * numpy.fabs(x) 
    468428        if y is not None: 
    469             self.y = np.sign(self.y) * math.fabs(y) 
    470         # # draw lines and markers 
     429            self.y = numpy.sign(self.y) * numpy.fabs(y) 
     430        # Draw lines and markers 
    471431        self.inner_marker.set(xdata=[self.x], ydata=[0]) 
    472432        self.left_line.set(xdata=[-self.x, -self.x], ydata=[self.y, -self.y]) 
    … …  
    480440        self.save_x = self.x 
    481441        self.save_y = self.y 
    482         self.base.freeze_axes() 
    483442 
    484443    def moveend(self, ev): 
    … …  
    510469    Average in Qx direction 
    511470    """ 
    512     def __init__(self, base, axes, color='black', zorder=3): 
    513         BoxInteractor.__init__(self, base, axes, color=color) 
     471    def __init__(self, base, axes, item=None, color='black', zorder=3): 
     472        BoxInteractor.__init__(self, base, axes, item=item, color=color) 
    514473        self.base = base 
    515474        self._post_data() 
    … …  
    527486    Average in Qy direction 
    528487    """ 
    529     def __init__(self, base, axes, color='black', zorder=3): 
    530         BoxInteractor.__init__(self, base, axes, color=color) 
     488    def __init__(self, base, axes, item=None, color='black', zorder=3): 
     489        BoxInteractor.__init__(self, base, axes, item=item, color=color) 
    531490        self.base = base 
    532491        self._post_data() 
Note: See TracChangeset for help on using the changeset viewer.