Changeset 83f4445 in sasview for guiframe


Ignore:
Timestamp:
Jun 2, 2010 9:58:41 PM (15 years ago)
Author:
Gervaise Alina <gervyh@…>
Branches:
master, 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, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, release_4.0.1, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
d955bf19
Parents:
6c79243
Message:

working on documentation

Location:
guiframe/local_perspectives/plotting
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • guiframe/local_perspectives/plotting/AnnulusSlicer.py

    raef2cf2 r83f4445  
    1616class AnnulusInteractor(_BaseInteractor): 
    1717    """ 
    18          Select an annulus through a 2D plot. 
    19          This interactor is used to average 2D data  with the region  
    20          defined by 2 radius. 
    21          this class is defined by 2 Ringinterators. 
     18    Select an annulus through a 2D plot. 
     19    This interactor is used to average 2D data  with the region  
     20    defined by 2 radius. 
     21    this class is defined by 2 Ringinterators. 
    2222    """ 
    2323    def __init__(self,base,axes,color='black', zorder=3): 
     
    5454        self.base.Bind(EVT_SLICER_PARS, self._onEVT_SLICER_PARS) 
    5555         
    56          
    57  
    5856    def _onEVT_SLICER_PARS(self, event): 
    5957        """ 
    60             receive an event containing parameters values to reset the slicer 
    61             @param event: event of type SlicerParameterEvent with params as  
     58        receive an event containing parameters values to reset the slicer 
     59         
     60        :param event: event of type SlicerParameterEvent with params as  
    6261            attribute 
     62             
    6363        """ 
    6464        wx.PostEvent(self.base, StatusEvent(status="AnnulusSlicer._onEVT_SLICER_PARS")) 
     
    7070    def set_layer(self, n): 
    7171        """ 
    72              Allow adding plot to the same panel 
    73              @param n: the number of layer 
     72        Allow adding plot to the same panel 
     73         
     74        :param n: the number of layer 
     75         
    7476        """ 
    7577        self.layernum = n 
     
    7880    def clear(self): 
    7981        """ 
    80             Clear the slicer and all connected events related to this slicer 
     82        Clear the slicer and all connected events related to this slicer 
    8183        """ 
    8284        self.clear_markers() 
     
    8688        self.base.Unbind(EVT_SLICER_PARS) 
    8789         
    88          
    8990    def update(self): 
    9091        """ 
    91             Respond to changes in the model by recalculating the profiles and 
    92             resetting the widgets. 
     92        Respond to changes in the model by recalculating the profiles and 
     93        resetting the widgets. 
    9394        """ 
    9495        # Update locations         
     
    9697        self.outer_circle.update() 
    9798         
    98  
    9999    def save(self, ev): 
    100100        """ 
    101             Remember the roughness for this layer and the next so that we 
    102             can restore on Esc. 
     101        Remember the roughness for this layer and the next so that we 
     102        can restore on Esc. 
    103103        """ 
    104104        self.base.freeze_axes() 
     
    108108    def _post_data(self,nbins=None): 
    109109        """ 
    110             Uses annulus parameters to plot averaged data into 1D data. 
    111             @param nbins: the number of points to plot  
     110        Uses annulus parameters to plot averaged data into 1D data. 
     111         
     112        :param nbins: the number of points to plot  
     113         
    112114        """ 
    113115        #Data to average 
     
    165167                                                 title="AnnulusPhi" )) 
    166168         
    167           
    168169    def moveend(self, ev): 
    169170        """ 
    170             Called when any dragging motion ends. 
    171             Post an event (type =SlicerParameterEvent) 
    172             to plotter 2D with a copy  slicer parameters 
    173             Call  _post_data method 
     171        Called when any dragging motion ends. 
     172        Post an event (type =SlicerParameterEvent) 
     173        to plotter 2D with a copy  slicer parameters 
     174        Call  _post_data method 
    174175        """ 
    175176        self.base.thaw_axes() 
     
    200201    def get_params(self): 
    201202        """ 
    202             Store a copy of values of parameters of the slicer into a dictionary. 
    203             @return params: the dictionary created 
     203        Store a copy of values of parameters of the slicer into a dictionary. 
     204         
     205        :return params: the dictionary created 
     206         
    204207        """ 
    205208        params = {} 
     
    211214    def set_params(self, params): 
    212215        """ 
    213             Receive a dictionary and reset the slicer with values contained  
    214             in the values of the dictionary. 
    215             @param params: a dictionary containing name of slicer parameters and  
     216        Receive a dictionary and reset the slicer with values contained  
     217        in the values of the dictionary. 
     218         
     219        :param params: a dictionary containing name of slicer parameters and  
    216220            values the user assigned to the slicer. 
     221             
    217222        """ 
    218223        inner = math.fabs(params["inner_radius"] ) 
     
    226231         
    227232    def freeze_axes(self): 
     233        """ 
     234        """ 
    228235        self.base.freeze_axes() 
    229236         
    230237    def thaw_axes(self): 
     238        """ 
     239        """ 
    231240        self.base.thaw_axes() 
    232241 
    233242    def draw(self): 
     243        """ 
     244        """ 
    234245        self.base.draw() 
    235246 
     
    237248class RingInteractor(_BaseInteractor): 
    238249    """ 
    239          Draw a ring Given a radius  
    240          @param: the color of the line that defined the ring 
    241          @param r: the radius of the ring 
    242          @param sign: the direction of motion the the marker  
     250     Draw a ring Given a radius  
    243251    """ 
    244252    def __init__(self,base,axes,color='black', zorder=5, r=1.0,sign=1): 
    245          
     253        """ 
     254        :param: the color of the line that defined the ring 
     255        :param r: the radius of the ring 
     256        :param sign: the direction of motion the the marker  
     257         
     258        """ 
    246259        _BaseInteractor.__init__(self, base, axes, color=color) 
    247260        self.markers = [] 
     
    292305    def set_layer(self, n): 
    293306        """ 
    294              Allow adding plot to the same panel 
    295              @param n: the number of layer 
     307        Allow adding plot to the same panel 
     308          
     309        :param n: the number of layer 
     310         
    296311        """ 
    297312        self.layernum = n 
     
    300315    def clear(self): 
    301316        """ 
    302             Clear the slicer and all connected events related to this slicer 
     317        Clear the slicer and all connected events related to this slicer 
    303318        """ 
    304319        self.clear_markers() 
     
    311326                del self.axes.lines[0] 
    312327         
    313          
    314          
    315328    def get_radius(self): 
    316329        """ 
    317             @return self._inner_mouse_x: the current radius of the ring 
     330        :return self._inner_mouse_x: the current radius of the ring 
    318331        """ 
    319332        return self._inner_mouse_x 
     
    321334    def update(self): 
    322335        """ 
    323             Draw the new roughness on the graph. 
     336        Draw the new roughness on the graph. 
    324337        """ 
    325338        # Plot inner circle 
     
    349362    def moveend(self, ev): 
    350363        """ 
    351             Called after a dragging motion 
     364        Called after a dragging motion 
    352365        """ 
    353366        self.base.moveend(ev) 
     
    370383    def set_cursor(self, x, y): 
    371384        """ 
    372             draw the ring given x, y value  
     385        draw the ring given x, y value  
    373386        """ 
    374387        self.move(x, y, None) 
     
    378391    def get_params(self): 
    379392        """ 
    380             Store a copy of values of parameters of the slicer into a dictionary. 
    381             @return params: the dictionary created 
     393        Store a copy of values of parameters of the slicer into a dictionary. 
     394         
     395        :return params: the dictionary created 
     396         
    382397        """ 
    383398        params = {} 
     
    387402    def set_params(self, params): 
    388403        """ 
    389             Receive a dictionary and reset the slicer with values contained  
    390             in the values of the dictionary. 
    391             @param params: a dictionary containing name of slicer parameters and  
     404        Receive a dictionary and reset the slicer with values contained  
     405        in the values of the dictionary. 
     406         
     407        :param params: a dictionary containing name of slicer parameters and  
    392408            values the user assigned to the slicer. 
     409             
    393410        """ 
    394411        x = params["radius"]  
     
    397414class CircularMask(_BaseInteractor): 
    398415    """ 
    399          Draw a ring Given a radius  
    400          @param: the color of the line that defined the ring 
    401          @param r: the radius of the ring 
    402          @param sign: the direction of motion the the marker  
     416     Draw a ring Given a radius  
    403417    """ 
    404418    def __init__(self,base,axes,color='grey', zorder=3, side=None): 
    405          
     419        """ 
     420         
     421        :param: the color of the line that defined the ring 
     422        :param r: the radius of the ring 
     423        :param sign: the direction of motion the the marker  
     424         
     425        """ 
    406426        _BaseInteractor.__init__(self, base, axes, color=color) 
    407427        self.markers = [] 
     
    431451        #self.base.Bind(EVT_SLICER_PARS, self._onEVT_SLICER_PARS) 
    432452         
    433          
    434  
    435453    def _onEVT_SLICER_PARS(self, event): 
    436454        """ 
    437             receive an event containing parameters values to reset the slicer 
    438             @param event: event of type SlicerParameterEvent with params as  
     455        receive an event containing parameters values to reset the slicer 
     456         
     457        :param event: event of type SlicerParameterEvent with params as  
    439458            attribute 
    440459        """ 
     
    447466    def set_layer(self, n): 
    448467        """ 
    449              Allow adding plot to the same panel 
    450              @param n: the number of layer 
     468        Allow adding plot to the same panel 
     469          
     470        :param n: the number of layer 
     471         
    451472        """ 
    452473        self.layernum = n 
     
    455476    def clear(self): 
    456477        """ 
    457             Clear the slicer and all connected events related to this slicer 
     478        Clear the slicer and all connected events related to this slicer 
    458479        """ 
    459480        self.clear_markers() 
     
    462483        #self.base.Unbind(EVT_SLICER_PARS) 
    463484         
    464          
    465485    def update(self): 
    466486        """ 
    467             Respond to changes in the model by recalculating the profiles and 
    468             resetting the widgets. 
     487        Respond to changes in the model by recalculating the profiles and 
     488        resetting the widgets. 
    469489        """ 
    470490        # Update locations         
     
    476496    def save(self, ev): 
    477497        """ 
    478             Remember the roughness for this layer and the next so that we 
    479             can restore on Esc. 
     498        Remember the roughness for this layer and the next so that we 
     499        can restore on Esc. 
    480500        """ 
    481501        self.base.freeze_axes() 
     
    484504    def _post_data(self): 
    485505        """ 
    486             Uses annulus parameters to plot averaged data into 1D data. 
    487             @param nbins: the number of points to plot  
     506        Uses annulus parameters to plot averaged data into 1D data. 
     507         
     508        :param nbins: the number of points to plot  
     509         
    488510        """ 
    489511        #Data to average 
     
    512534    def moveend(self, ev): 
    513535        """ 
    514             Called when any dragging motion ends. 
    515             Post an event (type =SlicerParameterEvent) 
    516             to plotter 2D with a copy  slicer parameters 
    517             Call  _post_data method 
     536        Called when any dragging motion ends. 
     537        Post an event (type =SlicerParameterEvent) 
     538        to plotter 2D with a copy  slicer parameters 
     539        Call  _post_data method 
    518540        """ 
    519541        self.base.thaw_axes() 
     
    538560    def get_params(self): 
    539561        """ 
    540             Store a copy of values of parameters of the slicer into a dictionary. 
    541             @return params: the dictionary created 
     562        Store a copy of values of parameters of the slicer into a dictionary. 
     563         
     564        :return params: the dictionary created 
     565         
    542566        """ 
    543567        params = {} 
     
    547571    def set_params(self, params): 
    548572        """ 
    549             Receive a dictionary and reset the slicer with values contained  
    550             in the values of the dictionary. 
    551             @param params: a dictionary containing name of slicer parameters and  
     573        Receive a dictionary and reset the slicer with values contained  
     574        in the values of the dictionary. 
     575         
     576        :param params: a dictionary containing name of slicer parameters and  
    552577            values the user assigned to the slicer. 
    553578        """ 
  • guiframe/local_perspectives/plotting/Arc.py

    r0d9dae8 r83f4445  
    1010class ArcInteractor(_BaseInteractor): 
    1111    """ 
    12          Select an annulus through a 2D plot 
     12    Select an annulus through a 2D plot 
    1313    """ 
    1414    def __init__(self,base,axes,color='black', zorder=5, r=1.0,theta1=math.pi/8, 
     
    3838 
    3939    def set_layer(self, n): 
     40        """ 
     41        """ 
    4042        self.layernum = n 
    4143        self.update() 
    4244         
    4345    def clear(self): 
     46        """ 
     47        """ 
    4448        self.clear_markers() 
    4549        try: 
     
    5155                del self.axes.lines[0] 
    5256         
    53          
    54          
    5557    def get_radius(self): 
     58        """ 
     59        """ 
    5660        radius =math.sqrt(math.pow(self._mouse_x, 2)+math.pow(self._mouse_y, 2)) 
    5761        return radius 
     
    7276        while self.theta2 >= self.theta1+2*math.pi: self.theta2 -= 2*math.pi 
    7377 
    74         """ 
    75         if nbins!=None: 
    76             self.npts =nbins 
    77         else: 
    78         """ 
    7978        npts = int((self.theta2 - self.theta1)/(math.pi/120))   
    8079              
     
    111110 
    112111    def moveend(self, ev): 
     112        """ 
     113        """ 
    113114        self.has_move= False 
    114115         
     
    139140         
    140141    def set_cursor(self,radius, phi_min, phi_max,nbins): 
    141          
     142        """ 
     143        """ 
    142144        self.theta1= phi_min 
    143145        self.theta2= phi_max 
     
    146148         
    147149    def get_params(self): 
     150        """ 
     151        """ 
    148152        params = {} 
    149153        params["radius"] = self.radius 
     
    153157     
    154158    def set_params(self, params): 
    155  
     159        """ 
     160        """ 
    156161        x = params["radius"]  
    157162        self.set_cursor(x, self._mouse_y) 
  • guiframe/local_perspectives/plotting/AzimutSlicer.py

    r78cae5a r83f4445  
    1919class SectorInteractor(_BaseInteractor): 
    2020    """ 
    21          Select an annulus through a 2D plot 
     21    Select an annulus through a 2D plot 
    2222    """ 
    2323    def __init__(self,base,axes,color='black', zorder=3): 
    24          
     24        """ 
     25        """ 
    2526        _BaseInteractor.__init__(self, base, axes, color=color) 
    2627        self.markers = [] 
     
    6162        self.base.parent.Bind(EVT_SLICER_PARS, self._onEVT_SLICER_PARS) 
    6263 
    63  
    6464    def _onEVT_SLICER_PARS(self, event): 
     65        """ 
     66        """ 
    6567        #printEVT("AnnulusSlicer._onEVT_SLICER_PARS") 
    6668        event.Skip() 
     
    6971            self.base.update() 
    7072 
    71     """ 
    72     def update_and_post(self): 
    73         self.update() 
    74         self._post_data() 
    75  
    76     """ 
    7773    def save_data(self, path, image, x, y): 
     74        """ 
     75        """ 
    7876        output = open(path, 'w') 
    7977         
     
    8684 
    8785    def set_layer(self, n): 
     86        """ 
     87        """ 
    8888        self.layernum = n 
    8989        self.update() 
    9090         
    9191    def clear(self): 
     92        """ 
     93        """ 
    9294        self.clear_markers() 
    9395        self.outer_circle.clear() 
     
    105107        # Update locations    
    106108        if self.inner_circle.has_move:     
    107             print "inner circle has moved"  
     109            #print "inner circle has moved"  
    108110            self.inner_circle.update() 
    109111            r1=self.inner_circle.get_radius() 
     
    112114            self.left_edge.update(r1,r2) 
    113115        if self.outer_circle.has_move:     
    114             print "outer circle has moved"  
     116            #print "outer circle has moved"  
    115117            self.outer_circle.update() 
    116118            r1=self.inner_circle.get_radius() 
     
    119121            self.right_edge.update(r1,r2) 
    120122        if self.right_edge.has_move: 
    121             print "right edge has moved" 
     123            #print "right edge has moved" 
    122124            self.right_edge.update() 
    123125            self.inner_circle.update(theta1=self.right_edge.get_angle(), theta2=None) 
    124126            self.outer_circle.update(theta1=self.right_edge.get_angle(), theta2=None) 
    125127        if  self.left_edge.has_move: 
    126             print "left Edge has moved" 
     128            #print "left Edge has moved" 
    127129            self.left_edge.update() 
    128130            self.inner_circle.update(theta1=None, theta2=self.left_edge.get_angle()) 
     
    220222         
    221223    def set_cursor(self, x, y): 
     224        """ 
     225        """ 
    222226        pass 
    223227         
    224228    def get_params(self): 
     229        """ 
     230        """ 
    225231        params = {} 
    226232        params["r_min"] = self.inner_circle.get_radius() 
     
    232238     
    233239    def set_params(self, params): 
    234         print "setparams on main slicer ",params 
     240        """ 
     241        """ 
     242        #print "setparams on main slicer ",params 
    235243        inner = params["r_min"]  
    236244        outer = params["r_max"]  
     
    239247        self.nbins = int(params["nbins"]) 
    240248         
    241          
    242249        self.inner_circle.set_cursor(inner, phi_min, phi_max,self.nbins) 
    243250        self.outer_circle.set_cursor(outer,  phi_min, phi_max, self.nbins) 
     
    247254         
    248255    def freeze_axes(self): 
     256        """ 
     257        """ 
    249258        self.base.freeze_axes() 
    250259         
    251260    def thaw_axes(self): 
     261        """ 
     262        """ 
    252263        self.base.thaw_axes() 
    253264 
    254265    def draw(self): 
     266        """ 
     267        """ 
    255268        self.base.draw() 
    256269 
    257270class SectorInteractorQ(SectorInteractor): 
     271    """ 
     272    """ 
    258273    def __init__(self,base,axes,color='black', zorder=3): 
     274        """ 
     275        """ 
    259276        SectorInteractor.__init__(self, base, axes, color=color) 
    260277        self.base=base 
    261278        self._post_data() 
     279         
    262280    def _post_data(self): 
     281        """ 
     282        """ 
    263283        from DataLoader.manipulations import SectorQ 
    264284        self.post_data(SectorQ )    
     
    266286 
    267287class SectorInteractorPhi(SectorInteractor): 
     288    """ 
     289    """ 
    268290    def __init__(self,base,axes,color='black', zorder=3): 
     291        """ 
     292        """ 
    269293        SectorInteractor.__init__(self, base, axes, color=color) 
    270294        self.base=base 
    271295        self._post_data() 
     296         
    272297    def _post_data(self): 
     298        """ 
     299        """ 
    273300        from DataLoader.manipulations import SectorPhi 
    274301        self.post_data(SectorPhi )    
  • guiframe/local_perspectives/plotting/BaseInteractor.py

    rb06ef8c r83f4445  
    3838        color - color of the interactor in non-active state 
    3939        markers - list of handles for the interactor 
     40         
    4041    """ 
    4142    def __init__(self,base,axes,color='black'): 
     43        """ 
     44        """ 
    4245        self.base = base 
    4346        self.axes = axes 
     
    4548         
    4649    def clear_markers(self): 
    47         ''' 
     50        """ 
    4851        Clear old markers and interfaces. 
    49         ''' 
     52        """ 
    5053        for h in self.markers: h.remove() 
    5154        if self.markers: self.base.connect.clear(*self.markers) 
     
    5356 
    5457    def save(self, ev): 
     58        """ 
     59        """ 
    5560        pass 
     61     
    5662    def restore(self, ev): 
     63        """ 
     64        """ 
    5765        pass 
     66     
    5867    def move(self, x, y, ev): 
     68        """ 
     69        """ 
    5970        pass 
     71     
    6072    def moveend(self, ev): 
     73        """ 
     74        """ 
    6175        pass 
    6276 
     
    102116 
    103117    def onRelease(self, ev): 
     118        """ 
     119        """ 
    104120        self.moveend(ev) 
    105121        return True 
     
    120136     
    121137    def onKey(self, ev): 
    122         ''' 
     138        """ 
    123139        Respond to keyboard events.  Arrow keys move the widget.  Escape 
    124140        restores it to the position before the last click. 
    125141         
    126142        Calls move() to update the state.  Calls restore() on escape. 
    127         ''' 
     143        """ 
    128144        if ev.key == 'escape': 
    129145            self.restore() 
     
    141157 
    142158    def dpixel(self,x,y,nudge=False): 
    143         ''' 
     159        """ 
    144160        Return the step size in data coordinates for a small 
    145161        step in screen coordinates.  If nudge is False (default) 
    146162        the step size is one pixel.  If nudge is True, the step 
    147163        size is 0.2 pixels. 
    148         ''' 
     164        """ 
    149165        ax = self.axes 
    150166        px,py = ax.transData.inverse_xy_tup((x,y)) 
  • guiframe/local_perspectives/plotting/binder.py

    r45c1a35 r83f4445  
    8080             
    8181        Use clearall() to reset all connections. 
     82         
    8283        """ 
    8384 
     
    162163            if event.button == 1 and event.shift: process Shift-click 
    163164 
    164         TODO: Only receive events with the correct modifiers (e.g., S-click, 
    165         TODO:   or *-click for any modifiers). 
    166         TODO: Only receive button events for the correct button (e.g., click1 
    167         TODO:   release3, or dclick* for any button) 
    168         TODO: Support virtual artist, so that and artist can be flagged as 
    169         TODO:   having a tag list and receive the correct events 
    170         TODO: Support virtual events for binding to button-3 vs shift button-1 
    171         TODO:   without changing callback code 
    172         TODO: Attach multiple callbacks to the same event? 
    173         TODO: Clean up interaction with toolbar modes 
    174         TODO: push/pushclear/pop context so that binding changes for the duration 
    175         TODO:   e.g., to support ? context sensitive help 
     165        :TODO: Only receive events with the correct modifiers (e.g., S-click, 
     166        :TODO:   or *-click for any modifiers). 
     167        :TODO: Only receive button events for the correct button (e.g., click1 
     168        :TODO:   release3, or dclick* for any button) 
     169        :TODO: Support virtual artist, so that and artist can be flagged as 
     170        :TODO:   having a tag list and receive the correct events 
     171        :TODO: Support virtual events for binding to button-3 vs shift button-1 
     172        :TODO:   without changing callback code 
     173        :TODO: Attach multiple callbacks to the same event? 
     174        :TODO: Clean up interaction with toolbar modes 
     175        :TODO: push/pushclear/pop context so that binding changes for the duration 
     176        :TODO:   e.g., to support ? context sensitive help 
     177         
    176178        """ 
    177179        # Check that the trigger is valid 
  • guiframe/local_perspectives/plotting/boxMask.py

    raef2cf2 r83f4445  
    1212class BoxMask(_BaseInteractor): 
    1313    """ 
    14         BoxMask Class: determine 2 rectangular area to find the pixel of 
    15         a Data inside of box.  
    16         Uses PointerInteractor , VerticalDoubleLine,HorizontalDoubleLine. 
    17         @param zorder:  Artists with lower zorder values are drawn first. 
    18         @param x_min: the minimum value of the x coordinate 
    19         @param x_max: the maximum value of the x coordinate 
    20         @param y_min: the minimum value of the y coordinate 
    21         @param y_max: the maximum value of the y coordinate 
     14    BoxMask Class: determine 2 rectangular area to find the pixel of 
     15    a Data inside of box.  
     16     
     17    Uses PointerInteractor , VerticalDoubleLine,HorizontalDoubleLine. 
     18     
     19    :param zorder:  Artists with lower zorder values are drawn first. 
     20    :param x_min: the minimum value of the x coordinate 
     21    :param x_max: the maximum value of the x coordinate 
     22    :param y_min: the minimum value of the y coordinate 
     23    :param y_max: the maximum value of the y coordinate 
    2224 
    2325    """ 
     
    8385    def clear(self): 
    8486        """ 
    85             Clear the slicer and all connected events related to this slicer 
     87        Clear the slicer and all connected events related to this slicer 
    8688        """ 
    8789        self.clear_markers() 
     
    9193        self.base.connect.clearall() 
    9294        #self.base.Unbind(EVT_SLICER_PARS) 
    93          
    94  
     95     
    9596    def update(self): 
    9697        """ 
    97             Respond to changes in the model by recalculating the profiles and 
    98             resetting the widgets. 
    99         """ 
    100  
     98        Respond to changes in the model by recalculating the profiles and 
     99        resetting the widgets. 
     100        """ 
    101101        ## check if the center point has moved and update the figure accordingly  
    102102        if self.center.has_move: 
     
    132132    def _post_data(self): 
    133133        """ 
    134             Get the limits of the boxsum and compute the sum of the pixel 
    135             contained in that region and the error on that sum 
     134        Get the limits of the boxsum and compute the sum of the pixel 
     135        contained in that region and the error on that sum 
    136136        """ 
    137137        from DataLoader.manipulations import Boxcut 
     
    151151            out = (mask(data)) 
    152152        #self.base.data.mask=out 
    153         return out             
     153        return out   
     154               
    154155    def moveend(self, ev): 
    155156        """ 
    156             After a dragging motion this function is called to compute 
    157             the error and the sum of pixel of a given data 2D  
     157        After a dragging motion this function is called to compute 
     158        the error and the sum of pixel of a given data 2D  
    158159        """ 
    159160        self.base.thaw_axes() 
     
    169170        self.center.restore() 
    170171         
    171          
    172172    def move(self, x, y, ev): 
    173173        """ 
     
    175175        """ 
    176176        pass 
    177      
    178177     
    179178    def set_cursor(self, x, y): 
    180179        pass 
    181180         
    182          
    183181    def get_params(self): 
    184182        """ 
    185             Store a copy of values of parameters of the slicer into a dictionary. 
    186             @return params: the dictionary created 
     183        Store a copy of values of parameters of the slicer into a dictionary. 
     184         
     185        :return params: the dictionary created 
     186         
    187187        """ 
    188188        params = {} 
     
    191191        params["center_x"] = self.center.x 
    192192        params["center_y"] =self.center.y 
    193  
    194193        return params 
    195194     
    196    
    197195    def get_mask(self): 
    198196        """ 
    199             return mask as a result of boxcut 
     197        return mask as a result of boxcut 
    200198        """ 
    201199        mask = self.mask 
    202200        return mask 
    203201     
    204          
    205202    def set_params(self, params): 
    206203        """ 
    207             Receive a dictionary and reset the slicer with values contained  
    208             in the values of the dictionary. 
    209             @param params: a dictionary containing name of slicer parameters and  
    210             values the user assigned to the slicer. 
     204        Receive a dictionary and reset the slicer with values contained  
     205        in the values of the dictionary. 
     206         
     207        :param params: a dictionary containing name of slicer parameters and  
     208           values the user assigned to the slicer. 
    211209        """ 
    212210        x_max = math.fabs(params["Width"] )/2 
     
    226224        self._post_data() 
    227225                
    228          
    229226    def freeze_axes(self): 
    230227        self.base.freeze_axes() 
    231          
    232228         
    233229    def thaw_axes(self): 
  • guiframe/local_perspectives/plotting/boxSlicer.py

    rddf6df3 r83f4445  
    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  
    9 # Debug printout 
    10 #from config import printEVT 
     1 
     2 
    113import wx 
    124import copy 
     
    2416class BoxInteractor(_BaseInteractor): 
    2517    """ 
    26          BoxInteractor define a rectangle that return data1D average of Data2D 
    27          in a rectangle area defined by -x, x ,y, -y 
     18    BoxInteractor define a rectangle that return data1D average of Data2D 
     19    in a rectangle area defined by -x, x ,y, -y 
    2820    """ 
    2921    def __init__(self,base,axes,color='black', zorder=3): 
     
    6860    def _onEVT_SLICER_PARS(self, event): 
    6961        """ 
    70             receive an event containing parameters values to reset the slicer 
    71             @param event: event of type SlicerParameterEvent with params as  
     62        receive an event containing parameters values to reset the slicer 
     63         
     64        :param event: event of type SlicerParameterEvent with params as  
    7265            attribute 
    7366        """ 
     
    8174    def update_and_post(self): 
    8275        """ 
    83             Update the slicer and plot the resulting data 
     76        Update the slicer and plot the resulting data 
    8477        """ 
    8578        self.update() 
    8679        self._post_data() 
    87  
    88  
     80         
    8981    def set_layer(self, n): 
    9082        """ 
    91              Allow adding plot to the same panel 
    92              @param n: the number of layer 
     83        Allow adding plot to the same panel 
     84         
     85        :param n: the number of layer 
     86         
    9387        """ 
    9488        self.layernum = n 
    9589        self.update() 
    9690         
    97          
    9891    def clear(self): 
    9992        """ 
    100             Clear the slicer and all connected events related to this slicer 
     93        Clear the slicer and all connected events related to this slicer 
    10194        """ 
    10295        self.averager=None 
     
    122115            self.vertical_lines.update() 
    123116            self.horizontal_lines.update(x=self.vertical_lines.x) 
    124                 
    125              
     117                  
    126118    def save(self, ev): 
    127119        """ 
     
    136128        pass 
    137129         
    138      
    139130    def post_data(self,new_slab=None , nbins=None, direction =None): 
    140131        """ 
    141              post data averaging in Qx or Qy given new_slab type 
    142              @param new_slab: slicer that determine with direction to average 
    143              @param nbins: the number of points plotted when averaging 
    144              @param direction: the direction of averaging 
     132        post data averaging in Qx or Qy given new_slab type 
     133         
     134        :param new_slab: slicer that determine with direction to average 
     135        :param nbins: the number of points plotted when averaging 
     136        :param direction: the direction of averaging 
     137         
    145138        """ 
    146139        x_min= -1*math.fabs(self.vertical_lines.x) 
     
    197190        wx.PostEvent(self.base.parent, NewPlotEvent(plot=new_plot, 
    198191                                                 title=str(self.averager.__name__) )) 
    199      
    200                
    201                                         
     192           
    202193    def moveend(self, ev): 
    203194        """ 
    204             Called after a dragging event. 
    205             Post the slicer new parameters and creates a new Data1D  
    206             corresponding to the new average 
     195        Called after a dragging event. 
     196        Post the slicer new parameters and creates a new Data1D  
     197        corresponding to the new average 
    207198        """ 
    208199        self.base.thaw_axes() 
     
    215206        self._post_data() 
    216207             
    217              
    218208    def restore(self): 
    219209        """ 
     
    223213        self.vertical_lines.restore() 
    224214        
    225  
    226215    def move(self, x, y, ev): 
    227216        """ 
     
    229218        """ 
    230219        pass 
    231          
    232220         
    233221    def set_cursor(self, x, y): 
    234222        pass 
    235223         
    236          
    237224    def get_params(self): 
    238225        """ 
    239             Store a copy of values of parameters of the slicer into a dictionary. 
    240             @return params: the dictionary created 
     226        Store a copy of values of parameters of the slicer into a dictionary. 
     227         
     228        :return params: the dictionary created 
     229         
    241230        """ 
    242231        params = {} 
     
    248237    def set_params(self, params): 
    249238        """ 
    250             Receive a dictionary and reset the slicer with values contained  
    251             in the values of the dictionary. 
    252             @param params: a dictionary containing name of slicer parameters and  
     239        Receive a dictionary and reset the slicer with values contained  
     240        in the values of the dictionary. 
     241         
     242        :param params: a dictionary containing name of slicer parameters and  
    253243            values the user assigned to the slicer. 
    254244        """ 
     
    261251        self.post_data( nbins=None) 
    262252         
    263          
    264253    def freeze_axes(self): 
     254        """ 
     255        """ 
    265256        self.base.freeze_axes() 
    266257         
    267          
    268258    def thaw_axes(self): 
     259        """ 
     260        """ 
    269261        self.base.thaw_axes() 
    270262 
    271  
    272263    def draw(self): 
     264        """ 
     265        """ 
    273266        self.base.draw() 
    274267 
     
    276269class HorizontalLines(_BaseInteractor): 
    277270    """ 
    278          Draw 2 Horizontal lines centered on (0,0) that can move  
    279          on the x- direction and in opposite direction 
     271     Draw 2 Horizontal lines centered on (0,0) that can move  
     272     on the x- direction and in opposite direction 
    280273    """ 
    281274    def __init__(self,base,axes,color='black', zorder=5,x=0.5, y=0.5): 
     
    331324    def set_layer(self, n): 
    332325        """ 
    333             Allow adding plot to the same panel 
    334             @param n: the number of layer 
     326        Allow adding plot to the same panel 
     327         
     328        :param n: the number of layer 
     329         
    335330        """ 
    336331        self.layernum = n 
     
    340335    def clear(self): 
    341336        """ 
    342             Clear this slicer  and its markers 
     337        Clear this slicer  and its markers 
    343338        """ 
    344339        self.clear_markers() 
     
    355350    def update(self,x=None,y=None): 
    356351        """ 
    357             Draw the new roughness on the graph. 
    358             @param x: x-coordinates to reset current class x 
    359             @param y: y-coordinates to reset current class y 
     352        Draw the new roughness on the graph. 
     353         
     354        :param x: x-coordinates to reset current class x 
     355        :param y: y-coordinates to reset current class y 
     356         
    360357        """ 
    361358        ## Reset x, y- coordinates if send as parameters 
     
    371368                       ydata=[-self.y, -self.y]) 
    372369         
    373          
    374370    def save(self, ev): 
    375371        """ 
     
    381377        self.base.freeze_axes() 
    382378 
    383  
    384379    def moveend(self, ev): 
    385380        """ 
    386             Called after a dragging this edge and set self.has_move to False 
    387             to specify the end of dragging motion 
     381        Called after a dragging this edge and set self.has_move to False 
     382        to specify the end of dragging motion 
    388383        """ 
    389384        self.has_move=False 
    390385        self.base.moveend(ev) 
    391             
    392              
     386              
    393387    def restore(self): 
    394388        """ 
     
    398392        self.y = self.save_y 
    399393         
    400  
    401394    def move(self, x, y, ev): 
    402395        """ 
     
    410403class VerticalLines(_BaseInteractor): 
    411404    """ 
    412          Select an annulus through a 2D plot 
     405    Select an annulus through a 2D plot 
    413406    """ 
    414407    def __init__(self,base,axes,color='black',zorder=5,x=0.5, y=0.5): 
     
    456449    def set_layer(self, n): 
    457450        """ 
    458             Allow adding plot to the same panel 
    459             @param n: the number of layer 
     451        Allow adding plot to the same panel 
     452         
     453        :param n: the number of layer 
     454         
    460455        """ 
    461456        self.layernum = n 
    462457        self.update() 
    463458         
    464          
    465459    def clear(self): 
    466460        """ 
    467             Clear this slicer  and its markers 
     461        Clear this slicer  and its markers 
    468462        """ 
    469463        self.clear_markers() 
     
    477471                del self.axes.lines[0] 
    478472 
    479  
    480473    def update(self,x=None,y=None): 
    481474        """ 
    482             Draw the new roughness on the graph. 
    483             @param x: x-coordinates to reset current class x 
    484             @param y: y-coordinates to reset current class y 
     475        Draw the new roughness on the graph. 
     476         
     477        :param x: x-coordinates to reset current class x 
     478        :param y: y-coordinates to reset current class y 
     479         
    485480        """ 
    486481        ## reset x, y -coordinates if given as parameters 
     
    496491                       ydata=[self.y,-self.y])  
    497492     
    498          
    499493    def save(self, ev): 
    500494        """ 
     
    502496        can restore on Esc. 
    503497        """ 
    504         self.save_x= self.x 
    505         self.save_y= self.y 
    506          
     498        self.save_x = self.x 
     499        self.save_y = self.y 
    507500        self.base.freeze_axes() 
    508  
    509  
     501         
    510502    def moveend(self, ev): 
    511503        """ 
    512             Called after a dragging this edge and set self.has_move to False 
    513             to specify the end of dragging motion 
     504        Called after a dragging this edge and set self.has_move to False 
     505        to specify the end of dragging motion 
    514506        """ 
    515507        self.has_move=False 
    516508        self.base.moveend(ev) 
    517              
    518              
     509                
    519510    def restore(self): 
    520511        """ 
     
    524515        self.y = self.save_y 
    525516       
    526          
    527517    def move(self, x, y, ev): 
    528518        """ 
     
    534524         
    535525    
    536          
    537  
    538526class BoxInteractorX(BoxInteractor): 
    539527    """ 
    540         Average in Qx direction 
     528    Average in Qx direction 
    541529    """ 
    542530    def __init__(self,base,axes,color='black', zorder=3): 
     
    548536    def _post_data(self): 
    549537        """ 
    550              Post data creating by averaging in Qx direction 
     538        Post data creating by averaging in Qx direction 
    551539        """ 
    552540        from DataLoader.manipulations import SlabX 
     
    556544class BoxInteractorY(BoxInteractor): 
    557545    """ 
    558          Average in Qy direction 
     546    Average in Qy direction 
    559547    """ 
    560548    def __init__(self,base,axes,color='black', zorder=3): 
     
    563551        self._post_data() 
    564552         
    565          
    566553    def _post_data(self): 
    567554        """ 
    568              Post data creating by averaging in Qy direction 
     555        Post data creating by averaging in Qy direction 
    569556        """ 
    570557        from DataLoader.manipulations import SlabY 
Note: See TracChangeset for help on using the changeset viewer.