Ignore:
Timestamp:
Feb 2, 2017 8:29:07 AM (6 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:
965fbd8
Parents:
5d89f43
git-author:
Piotr Rozyczko <rozyczko@…> (01/23/17 09:21:03)
git-committer:
Piotr Rozyczko <rozyczko@…> (02/02/17 08:29:07)
Message:

Reimplementation of the slicer functionality

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/sas/sasgui/guiframe/local_perspectives/plotting/SectorSlicer.py

    rd85c194 r3bdbfcc  
    33""" 
    44import math 
    5 import wx 
     5from PyQt4 import QtGui 
     6from PyQt4 import QtCore 
     7 
    68from BaseInteractor import _BaseInteractor 
    7 from sas.sasgui.guiframe.events import NewPlotEvent 
    8 from sas.sasgui.guiframe.events import StatusEvent 
    9 from sas.sasgui.guiframe.events import SlicerParameterEvent 
    10 from sas.sasgui.guiframe.events import EVT_SLICER_PARS 
    119from sas.sasgui.guiframe.dataFitting import Data1D 
    12  
    13  
    14 class SectorInteractor(_BaseInteractor): 
     10import sas.qtgui.GuiUtils as GuiUtils 
     11from sas.qtgui.SlicerModel import SlicerModel 
     12 
     13 
     14class SectorInteractor(_BaseInteractor, SlicerModel): 
    1515    """ 
    1616    Draw a sector slicer.Allow to performQ averaging on data 2D 
    1717    """ 
    18     def __init__(self, base, axes, color='black', zorder=3): 
     18    def __init__(self, base, axes, item=None, color='black', zorder=3): 
    1919 
    2020        _BaseInteractor.__init__(self, base, axes, color=color) 
    21         ## Class initialization 
     21        SlicerModel.__init__(self) 
     22        # Class initialization 
    2223        self.markers = [] 
    2324        self.axes = axes 
    24         ## connect the plot to event 
     25        self._item = item 
     26        # Connect the plot to event 
    2527        self.connect = self.base.connect 
    2628 
    27         ## compute qmax limit to reset the graph 
    28         x = math.pow(max(self.base.data2D.xmax, 
    29                          math.fabs(self.base.data2D.xmin)), 2) 
    30         y = math.pow(max(self.base.data2D.ymax, 
    31                          math.fabs(self.base.data2D.ymin)), 2) 
     29        # Compute qmax limit to reset the graph 
     30        x = math.pow(max(self.base.data.xmax, 
     31                         math.fabs(self.base.data.xmin)), 2) 
     32        y = math.pow(max(self.base.data.ymax, 
     33                         math.fabs(self.base.data.ymin)), 2) 
    3234        self.qmax = math.sqrt(x + y) 
    33         ## Number of points on the plot 
     35        # Number of points on the plot 
    3436        self.nbins = 20 
    35         ## Angle of the middle line 
     37        # Angle of the middle line 
    3638        self.theta2 = math.pi / 3 
    37         ## Absolute value of the Angle between the middle line and any side line 
     39        # Absolute value of the Angle between the middle line and any side line 
    3840        self.phi = math.pi / 12 
    39         ## Middle line 
    40         self.main_line = LineInteractor(self, self.base.subplot, color='blue', 
     41        # Middle line 
     42        self.main_line = LineInteractor(self, self.axes, color='blue', 
    4143                                        zorder=zorder, r=self.qmax, 
    4244                                        theta=self.theta2) 
    4345        self.main_line.qmax = self.qmax 
    44         ## Right Side line 
    45         self.right_line = SideInteractor(self, self.base.subplot, color='black', 
     46        # Right Side line 
     47        self.right_line = SideInteractor(self, self.axes, color='black', 
    4648                                         zorder=zorder, r=self.qmax, 
    4749                                         phi=-1 * self.phi, theta2=self.theta2) 
    4850        self.right_line.qmax = self.qmax 
    49         ## Left Side line 
    50         self.left_line = SideInteractor(self, self.base.subplot, color='black', 
     51        # Left Side line 
     52        self.left_line = SideInteractor(self, self.axes, color='black', 
    5153                                        zorder=zorder, r=self.qmax, 
    5254                                        phi=self.phi, theta2=self.theta2) 
    5355        self.left_line.qmax = self.qmax 
    54         ## draw the sector 
     56        # draw the sector 
    5557        self.update() 
    5658        self._post_data() 
    57         ## Bind to slice parameter events 
    58         self.base.Bind(EVT_SLICER_PARS, self._onEVT_SLICER_PARS) 
    59  
    60     def _onEVT_SLICER_PARS(self, event): 
    61         """ 
    62         receive an event containing parameters values to reset the slicer 
    63  
    64         :param event: event of type SlicerParameterEvent with params as 
    65         attribute 
    66  
    67         """ 
    68         wx.PostEvent(self.base.parent, 
    69                      StatusEvent(status="SectorSlicer._onEVT_SLICER_PARS")) 
    70         event.Skip() 
    71         if event.type == self.__class__.__name__: 
    72             self.set_params(event.params) 
    73             self.base.update() 
     59        self.setModelFromParams() 
    7460 
    7561    def set_layer(self, n): 
    7662        """ 
    7763         Allow adding plot to the same panel 
    78  
    7964        :param n: the number of layer 
    80  
    8165        """ 
    8266        self.layernum = n 
     
    9276        self.right_line.clear() 
    9377        self.base.connect.clearall() 
    94         self.base.Unbind(EVT_SLICER_PARS) 
    9578 
    9679    def update(self): 
     
    10083        """ 
    10184        # Update locations 
    102         ## Check if the middle line was dragged and 
    103         #update the picture accordingly 
     85        # Check if the middle line was dragged and 
     86        # update the picture accordingly 
    10487        if self.main_line.has_move: 
    10588            self.main_line.update() 
     
    10891            self.left_line.update(delta=self.left_line.phi / 2, 
    10992                                  mline=self.main_line.theta) 
    110         ## Check if the left side has moved and update the slicer accordingly 
     93        # Check if the left side has moved and update the slicer accordingly 
    11194        if self.left_line.has_move: 
    11295            self.main_line.update() 
     
    11699                                   mline=self.main_line, side=True, 
    117100                                   left=False, right=True) 
    118         ## Check if the right side line has moved and 
    119         #update the slicer accordingly 
     101        # Check if the right side line has moved and update the slicer accordingly 
    120102        if self.right_line.has_move: 
    121103            self.main_line.update() 
     
    130112        can restore on Esc. 
    131113        """ 
    132         self.base.freeze_axes() 
    133114        self.main_line.save(ev) 
    134115        self.right_line.save(ev) 
     
    141122        :param nbins: the number of point to plot for the average 1D data 
    142123        """ 
    143         ## get the data2D to average 
    144         data = self.base.data2D 
     124        # Get the data2D to average 
     125        data = self.base.data 
    145126        # If we have no data, just return 
    146127        if data == None: 
    147128            return 
    148         ## Averaging 
     129        # Averaging 
    149130        from sas.sascalc.dataloader.manipulations import SectorQ 
    150131        radius = self.qmax 
     
    157138                       phi_max=phimax + math.pi, nbins=nbins) 
    158139 
    159         sector = sect(self.base.data2D) 
    160         ##Create 1D data resulting from average 
     140        sector = sect(self.base.data) 
     141        # Create 1D data resulting from average 
    161142 
    162143        if hasattr(sector, "dxl"): 
     
    171152        new_plot.dxl = dxl 
    172153        new_plot.dxw = dxw 
    173         new_plot.name = "SectorQ" + "(" + self.base.data2D.name + ")" 
    174         new_plot.source = self.base.data2D.source 
    175         #new_plot.info=self.base.data2D.info 
     154        new_plot.name = "SectorQ" + "(" + self.base.data.name + ")" 
     155        new_plot.title = "SectorQ" + "(" + self.base.data.name + ")" 
     156        new_plot.source = self.base.data.source 
    176157        new_plot.interactive = True 
    177         new_plot.detector = self.base.data2D.detector 
    178         ## If the data file does not tell us what the axes are, just assume... 
     158        new_plot.detector = self.base.data.detector 
     159        # If the data file does not tell us what the axes are, just assume them. 
    179160        new_plot.xaxis("\\rm{Q}", "A^{-1}") 
    180161        new_plot.yaxis("\\rm{Intensity}", "cm^{-1}") 
    181162        if hasattr(data, "scale") and data.scale == 'linear' and \ 
    182                 self.base.data2D.name.count("Residuals") > 0: 
     163                self.base.data.name.count("Residuals") > 0: 
    183164            new_plot.ytransform = 'y' 
    184165            new_plot.yaxis("\\rm{Residuals} ", "/") 
    185166 
    186         new_plot.group_id = "2daverage" + self.base.data2D.name 
    187         new_plot.id = "SectorQ" + self.base.data2D.name 
     167        new_plot.group_id = "2daverage" + self.base.data.name 
     168        new_plot.id = "SectorQ" + self.base.data.name 
    188169        new_plot.is_data = True 
    189         self.base.parent.update_theory(data_id=data.id, theory=new_plot) 
    190         wx.PostEvent(self.base.parent, 
    191                      NewPlotEvent(plot=new_plot, title="SectorQ" + self.base.data2D.name)) 
     170        variant_plot = QtCore.QVariant(new_plot) 
     171        GuiUtils.updateModelItemWithPlot(self._item, variant_plot, new_plot.id) 
     172 
     173        if self.update_model: 
     174            self.setModelFromParams() 
     175        self.draw() 
    192176 
    193177    def moveend(self, ev): 
     
    195179        Called a dragging motion ends.Get slicer event 
    196180        """ 
    197         self.base.thaw_axes() 
    198         ## Post parameters 
    199         event = SlicerParameterEvent() 
    200         event.type = self.__class__.__name__ 
    201         event.params = self.get_params() 
    202         ## Send slicer paramers to plotter2D 
    203         wx.PostEvent(self.base, event) 
     181        # Post parameters 
     182        self._post_data(self.nbins) 
    204183 
    205184    def restore(self): 
     
    222201        pass 
    223202 
    224     def get_params(self): 
     203    def getParams(self): 
    225204        """ 
    226205        Store a copy of values of parameters of the slicer into a dictionary. 
    227  
    228206        :return params: the dictionary created 
    229  
    230207        """ 
    231208        params = {} 
    232         ## Always make sure that the left and the right line are at phi 
    233         ## angle of the middle line 
     209        # Always make sure that the left and the right line are at phi 
     210        # angle of the middle line 
    234211        if math.fabs(self.left_line.phi) != math.fabs(self.right_line.phi): 
    235212            msg = "Phi left and phi right are different" 
     
    241218        return params 
    242219 
    243     def set_params(self, params): 
     220    def setParams(self, params): 
    244221        """ 
    245222        Receive a dictionary and reset the slicer with values contained 
     
    253230        self.nbins = int(params["nbins"]) 
    254231        self.main_line.theta = main 
    255         ## Reset the slicer parameters 
     232        # Reset the slicer parameters 
    256233        self.main_line.update() 
    257234        self.right_line.update(phi=phi, delta=None, mline=self.main_line, 
     
    259236        self.left_line.update(phi=phi, delta=None, 
    260237                              mline=self.main_line, side=True) 
    261         ## post the new corresponding data 
     238        # Post the new corresponding data 
    262239        self._post_data(nbins=self.nbins) 
    263  
    264     def freeze_axes(self): 
    265         """ 
    266         """ 
    267         self.base.freeze_axes() 
    268  
    269     def thaw_axes(self): 
    270         """ 
    271         """ 
    272         self.base.thaw_axes() 
    273240 
    274241    def draw(self): 
     
    291258        """ 
    292259        _BaseInteractor.__init__(self, base, axes, color=color) 
    293         ## Initialize the class 
     260        # Initialize the class 
    294261        self.markers = [] 
    295262        self.axes = axes 
    296         ## compute the value of the angle between the current line and 
    297         ## the x-axis 
     263        # compute the value of the angle between the current line and 
     264        # the x-axis 
    298265        self.save_theta = theta2 + phi 
    299266        self.theta = theta2 + phi 
    300         ## the value of the middle line angle with respect to the x-axis 
     267        # the value of the middle line angle with respect to the x-axis 
    301268        self.theta2 = theta2 
    302         ## Radius to find polar coordinates this line's endpoints 
     269        # Radius to find polar coordinates this line's endpoints 
    303270        self.radius = r 
    304         ## phi is the phase between the current line and the middle line 
     271        # phi is the phase between the current line and the middle line 
    305272        self.phi = phi 
    306         ## End points polar coordinates 
     273        # End points polar coordinates 
    307274        x1 = self.radius * math.cos(self.theta) 
    308275        y1 = self.radius * math.sin(self.theta) 
    309276        x2 = -1 * self.radius * math.cos(self.theta) 
    310277        y2 = -1 * self.radius * math.sin(self.theta) 
    311         ## defining a new marker 
     278        # Defining a new marker 
    312279        self.inner_marker = self.axes.plot([x1 / 2.5], [y1 / 2.5], linestyle='', 
    313280                                           marker='s', markersize=10, 
     
    316283                                           zorder=zorder, visible=True)[0] 
    317284 
    318         ## Defining the current line 
     285        # Defining the current line 
    319286        self.line = self.axes.plot([x1, x2], [y1, y2], 
    320287                                   linestyle='-', marker='', 
    321288                                   color=self.color, visible=True)[0] 
    322         ## Flag to differentiate the left line from the right line motion 
     289        # Flag to differentiate the left line from the right line motion 
    323290        self.left_moving = False 
    324         ## Flag to define a motion 
     291        # Flag to define a motion 
    325292        self.has_move = False 
    326         ## connecting markers and draw the picture 
     293        # connecting markers and draw the picture 
    327294        self.connect_markers([self.inner_marker, self.line]) 
    328295 
     
    330297        """ 
    331298        Allow adding plot to the same panel 
    332  
    333299        :param n: the number of layer 
    334  
    335300        """ 
    336301        self.layernum = n 
     
    359324 
    360325        """ 
    361         #print "update left or right ", self.has_move 
    362326        self.left_moving = left 
    363327        theta3 = 0 
     
    396360        """ 
    397361        self.save_theta = self.theta 
    398         self.base.freeze_axes() 
    399362 
    400363    def moveend(self, ev): 
     
    416379        self.theta = math.atan2(y, x) 
    417380        self.has_move = True 
    418         #ToDo: Simplify below 
    419381        if not self.left_moving: 
    420382            if  self.theta2 - self.theta <= 0 and self.theta2 > 0: 
     
    464426        self.update() 
    465427 
    466     def get_params(self): 
     428    def getParams(self): 
    467429        """ 
    468430        """ 
     
    472434        return params 
    473435 
    474     def set_params(self, params): 
     436    def setParams(self, params): 
    475437        """ 
    476438        """ 
     
    554516        """ 
    555517        self.save_theta = self.theta 
    556         self.base.freeze_axes() 
    557518 
    558519    def moveend(self, ev): 
     
    582543        self.update() 
    583544 
    584     def get_params(self): 
     545    def getParams(self): 
    585546        """ 
    586547        """ 
     
    590551        return params 
    591552 
    592     def set_params(self, params): 
     553    def setParams(self, params): 
    593554        """ 
    594555        """ 
Note: See TracChangeset for help on using the changeset viewer.