source: sasview/src/sas/sasgui/guiframe/local_perspectives/plotting/AnnulusSlicer.py @ d85c194

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since d85c194 was d85c194, checked in by Piotr Rozyczko <piotr.rozyczko@…>, 7 years ago

Remaining modules refactored

  • Property mode set to 100644
File size: 18.5 KB
Line 
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
8import math
9import wx
10# from copy import deepcopy
11# Debug printout
12from sas.sasgui.guiframe.events import NewPlotEvent
13from sas.sasgui.guiframe.events import StatusEvent
14from sas.sasgui.guiframe.events import SlicerParameterEvent
15from sas.sasgui.guiframe.events import EVT_SLICER_PARS
16from BaseInteractor import _BaseInteractor
17from sas.sasgui.guiframe.dataFitting import Data1D
18
19class AnnulusInteractor(_BaseInteractor):
20    """
21    Select an annulus through a 2D plot.
22    This interactor is used to average 2D data  with the region
23    defined by 2 radius.
24    this class is defined by 2 Ringinterators.
25    """
26    def __init__(self, base, axes, color='black', zorder=3):
27
28        _BaseInteractor.__init__(self, base, axes, color=color)
29        self.markers = []
30        self.axes = axes
31        self.base = base
32        self.qmax = min(math.fabs(self.base.data2D.xmax),
33                        math.fabs(self.base.data2D.xmin))  # must be positive
34        self.connect = self.base.connect
35
36        # # Number of points on the plot
37        self.nbins = 36
38        # Cursor position of Rings (Left(-1) or Right(1))
39        self.xmaxd = self.base.data2D.xmax
40        self.xmind = self.base.data2D.xmin
41
42        if (self.xmaxd + self.xmind) > 0:
43            self.sign = 1
44        else:
45            self.sign = -1
46        # Inner circle
47        self.inner_circle = RingInteractor(self, self.base.subplot,
48                                           zorder=zorder,
49                                           r=self.qmax / 2.0, sign=self.sign)
50        self.inner_circle.qmax = self.qmax
51        self.outer_circle = RingInteractor(self, self.base.subplot,
52                                           zorder=zorder + 1, r=self.qmax / 1.8,
53                                           sign=self.sign)
54        self.outer_circle.qmax = self.qmax * 1.2
55        self.update()
56        self._post_data()
57
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()
75
76    def set_layer(self, n):
77        """
78        Allow adding plot to the same panel
79
80        :param n: the number of layer
81
82        """
83        self.layernum = n
84        self.update()
85
86    def clear(self):
87        """
88        Clear the slicer and all connected events related to this slicer
89        """
90        self.clear_markers()
91        self.outer_circle.clear()
92        self.inner_circle.clear()
93        self.base.connect.clearall()
94        self.base.Unbind(EVT_SLICER_PARS)
95
96    def update(self):
97        """
98        Respond to changes in the model by recalculating the profiles and
99        resetting the widgets.
100        """
101        # Update locations
102        self.inner_circle.update()
103        self.outer_circle.update()
104
105    def save(self, ev):
106        """
107        Remember the roughness for this layer and the next so that we
108        can restore on Esc.
109        """
110        self.base.freeze_axes()
111        self.inner_circle.save(ev)
112        self.outer_circle.save(ev)
113
114    def _post_data(self, nbins=None):
115        """
116        Uses annulus parameters to plot averaged data into 1D data.
117
118        :param nbins: the number of points to plot
119
120        """
121        # Data to average
122        data = self.base.data2D
123        # If we have no data, just return
124        if data == None:
125            return
126
127        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
133        # the default number will be nbins= 36
134        if nbins == None:
135            self.nbins = 36
136        else:
137            self.nbins = nbins
138        # # create the data1D Q average of data2D
139        sect = Ring(r_min=rmin, r_max=rmax, nbins=self.nbins)
140        sector = sect(self.base.data2D)
141
142        if hasattr(sector, "dxl"):
143            dxl = sector.dxl
144        else:
145            dxl = None
146        if hasattr(sector, "dxw"):
147            dxw = sector.dxw
148        else:
149            dxw = None
150        new_plot = Data1D(x=(sector.x - math.pi) * 180 / math.pi,
151                          y=sector.y, dy=sector.dy)
152        new_plot.dxl = dxl
153        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
158        new_plot.interactive = True
159        new_plot.detector = self.base.data2D.detector
160        # If the data file does not tell us what the axes are, just assume...
161        new_plot.xaxis("\\rm{\phi}", 'degrees')
162        new_plot.yaxis("\\rm{Intensity} ", "cm^{-1}")
163        if hasattr(data, "scale") and data.scale == 'linear' and \
164                self.base.data2D.name.count("Residuals") > 0:
165            new_plot.ytransform = 'y'
166            new_plot.yaxis("\\rm{Residuals} ", "/")
167
168        new_plot.group_id = "AnnulusPhi" + self.base.data2D.name
169        new_plot.id = "AnnulusPhi" + self.base.data2D.name
170        new_plot.is_data = True
171        new_plot.xtransform = "x"
172        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"))
175
176    def moveend(self, ev):
177        """
178        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)
189
190    def restore(self):
191        """
192        Restore the roughness for this layer.
193        """
194        self.inner_circle.restore()
195        self.outer_circle.restore()
196
197    def move(self, x, y, ev):
198        """
199        Process move to a new position, making sure that the move is allowed.
200        """
201        pass
202
203    def set_cursor(self, x, y):
204        pass
205
206    def get_params(self):
207        """
208        Store a copy of values of parameters of the slicer into a dictionary.
209
210        :return params: the dictionary created
211
212        """
213        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)
216        params["nbins"] = self.nbins
217        return params
218
219    def set_params(self, params):
220        """
221        Receive a dictionary and reset the slicer with values contained
222        in the values of the dictionary.
223
224        :param params: a dictionary containing name of slicer parameters and
225            values the user assigned to the slicer.
226
227        """
228        inner = math.fabs(params["inner_radius"])
229        outer = math.fabs(params["outer_radius"])
230        self.nbins = int(params["nbins"])
231        # # Update the picture
232        self.inner_circle.set_cursor(inner, self.inner_circle._inner_mouse_y)
233        self.outer_circle.set_cursor(outer, self.outer_circle._inner_mouse_y)
234        # # Post the data given the nbins entered by the user
235        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()
246
247    def draw(self):
248        """
249        """
250        self.base.draw()
251
252
253class RingInteractor(_BaseInteractor):
254    """
255     Draw a ring Given a radius
256    """
257    def __init__(self, base, axes, color='black', zorder=5, r=1.0, sign=1):
258        """
259        :param: the color of the line that defined the ring
260        :param r: the radius of the ring
261        :param sign: the direction of motion the the marker
262
263        """
264        _BaseInteractor.__init__(self, base, axes, color=color)
265        self.markers = []
266        self.axes = axes
267        # Current radius of the ring
268        self._inner_mouse_x = r
269        # Value of the center of the ring
270        self._inner_mouse_y = 0
271        # previous value of that radius
272        self._inner_save_x = r
273        # Save value of the center of the ring
274        self._inner_save_y = 0
275        # Class instantiating RingIterator class
276        self.base = base
277        # the direction of the motion of the marker
278        self.sign = sign
279        # # 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
304        # Draw a circle
305        [self.inner_circle] = self.axes.plot([], [], linestyle='-', marker='', color=self.color)
306        # the number of points that make the ring line
307        self.npts = 40
308
309        self.connect_markers([self.inner_marker])
310        self.update()
311
312    def set_layer(self, n):
313        """
314        Allow adding plot to the same panel
315
316        :param n: the number of layer
317
318        """
319        self.layernum = n
320        self.update()
321
322    def clear(self):
323        """
324        Clear the slicer and all connected events related to this slicer
325        """
326        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]
334
335    def get_radius(self):
336        """
337        :return self._inner_mouse_x: the current radius of the ring
338        """
339        return self._inner_mouse_x
340
341    def update(self):
342        """
343        Draw the new roughness on the graph.
344        """
345        # Plot inner circle
346        x = []
347        y = []
348        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)
353
354            x.append(xval)
355            y.append(yval)
356
357        self.inner_marker.set(xdata=[self.sign * math.fabs(self._inner_mouse_x)],
358                              ydata=[0])
359        self.inner_circle.set_data(x, y)
360
361    def save(self, ev):
362        """
363        Remember the roughness for this layer and the next so that we
364        can restore on Esc.
365        """
366        self._inner_save_x = self._inner_mouse_x
367        self._inner_save_y = self._inner_mouse_y
368        self.base.freeze_axes()
369
370    def moveend(self, ev):
371        """
372        Called after a dragging motion
373        """
374        self.base.moveend(ev)
375
376    def restore(self):
377        """
378        Restore the roughness for this layer.
379        """
380        self._inner_mouse_x = self._inner_save_x
381        self._inner_mouse_y = self._inner_save_y
382
383    def move(self, x, y, ev):
384        """
385        Process move to a new position, making sure that the move is allowed.
386        """
387        self._inner_mouse_x = x
388        self._inner_mouse_y = y
389        self.base.base.update()
390
391    def set_cursor(self, x, y):
392        """
393        draw the ring given x, y value
394        """
395        self.move(x, y, None)
396        self.update()
397
398
399    def get_params(self):
400        """
401        Store a copy of values of parameters of the slicer into a dictionary.
402
403        :return params: the dictionary created
404
405        """
406        params = {}
407        params["radius"] = math.fabs(self._inner_mouse_x)
408        return params
409
410    def set_params(self, params):
411        """
412        Receive a dictionary and reset the slicer with values contained
413        in the values of the dictionary.
414
415        :param params: a dictionary containing name of slicer parameters and
416            values the user assigned to the slicer.
417
418        """
419        x = params["radius"]
420        self.set_cursor(x, self._inner_mouse_y)
421
422class CircularMask(_BaseInteractor):
423    """
424     Draw a ring Given a radius
425    """
426    def __init__(self, base, axes, color='grey', zorder=3, side=None):
427        """
428        :param: the color of the line that defined the ring
429        :param r: the radius of the ring
430        :param sign: the direction of motion the the marker
431        """
432        _BaseInteractor.__init__(self, base, axes, color=color)
433        self.markers = []
434        self.axes = axes
435        self.base = base
436        self.is_inside = side
437        self.qmax = min(math.fabs(self.base.data.xmax),
438                        math.fabs(self.base.data.xmin))  # must be positive
439        self.connect = self.base.connect
440
441        # Cursor position of Rings (Left(-1) or Right(1))
442        self.xmaxd = self.base.data.xmax
443        self.xmind = self.base.data.xmin
444
445        if (self.xmaxd + self.xmind) > 0:
446            self.sign = 1
447        else:
448            self.sign = -1
449        # Inner circle
450        self.outer_circle = RingInteractor(self, self.base.subplot, 'blue',
451                                           zorder=zorder + 1, r=self.qmax / 1.8,
452                                           sign=self.sign)
453        self.outer_circle.qmax = self.qmax * 1.2
454        self.update()
455        self._post_data()
456
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
474    def set_layer(self, n):
475        """
476        Allow adding plot to the same panel
477
478        :param n: the number of layer
479
480        """
481        self.layernum = n
482        self.update()
483
484    def clear(self):
485        """
486        Clear the slicer and all connected events related to this slicer
487        """
488        self.clear_markers()
489        self.outer_circle.clear()
490        self.base.connect.clearall()
491        # self.base.Unbind(EVT_SLICER_PARS)
492
493    def update(self):
494        """
495        Respond to changes in the model by recalculating the profiles and
496        resetting the widgets.
497        """
498        # Update locations
499        self.outer_circle.update()
500        # if self.is_inside != None:
501        out = self._post_data()
502        return out
503
504    def save(self, ev):
505        """
506        Remember the roughness for this layer and the next so that we
507        can restore on Esc.
508        """
509        self.base.freeze_axes()
510        self.outer_circle.save(ev)
511
512    def _post_data(self):
513        """
514        Uses annulus parameters to plot averaged data into 1D data.
515
516        :param nbins: the number of points to plot
517
518        """
519        # Data to average
520        data = self.base.data
521
522        # If we have no data, just return
523        if data == None:
524            return
525        mask = data.mask
526        from sas.sascalc.dataloader.manipulations import Ringcut
527
528        rmin = 0
529        rmax = math.fabs(self.outer_circle.get_radius())
530
531        # # create the data1D Q average of data2D
532        mask = Ringcut(r_min=rmin, r_max=rmax)
533
534        if self.is_inside:
535            out = (mask(data) == False)
536        else:
537            out = (mask(data))
538        # self.base.data.mask=out
539        return out
540
541
542    def moveend(self, ev):
543        """
544        Called when any dragging motion ends.
545        Post an event (type =SlicerParameterEvent)
546        to plotter 2D with a copy  slicer parameters
547        Call  _post_data method
548        """
549        self.base.thaw_axes()
550        # create a 1D data plot
551        self._post_data()
552
553    def restore(self):
554        """
555        Restore the roughness for this layer.
556        """
557        self.outer_circle.restore()
558
559    def move(self, x, y, ev):
560        """
561        Process move to a new position, making sure that the move is allowed.
562        """
563        pass
564
565    def set_cursor(self, x, y):
566        pass
567
568    def get_params(self):
569        """
570        Store a copy of values of parameters of the slicer into a dictionary.
571
572        :return params: the dictionary created
573
574        """
575        params = {}
576        params["outer_radius"] = math.fabs(self.outer_circle._inner_mouse_x)
577        return params
578
579    def set_params(self, params):
580        """
581        Receive a dictionary and reset the slicer with values contained
582        in the values of the dictionary.
583
584        :param params: a dictionary containing name of slicer parameters and
585            values the user assigned to the slicer.
586        """
587        outer = math.fabs(params["outer_radius"])
588        # # Update the picture
589        self.outer_circle.set_cursor(outer, self.outer_circle._inner_mouse_y)
590        # # Post the data given the nbins entered by the user
591        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()
598
599    def draw(self):
600        self.base.update()
601
Note: See TracBrowser for help on using the repository browser.