source: branches/plotter2/python/customgui_base.py@ 2841

Last change on this file since 2841 was 2799, checked in by Kana Sugimoto, 12 years ago

New Development: No (a bug fix)

JIRA Issue: Yes (CAS-4859)

Ready for Test: Yes

Interface Changes: No

What Interface Changed:

Test Programs:

Put in Release Notes: No

Module(s): asap.asapplotter and sdplot

Description:

Fixed a bug in the usage of weakref.


File size: 49.1 KB
Line 
1import os
2import weakref
3import matplotlib, numpy
4from asap.logging import asaplog, asaplog_post_dec
5from matplotlib.patches import Rectangle
6from asap.parameters import rcParams
7from asap import scantable
8from asap._asap import stmath
9from asap.utils import _n_bools, mask_not, mask_or
10
11######################################
12## Add CASA custom toolbar ##
13######################################
14class CustomToolbarCommon:
15 def __init__(self,parent):
16 self.plotter = weakref.ref(parent)
17 #self.figmgr=self.plotter._plotter.figmgr
18
19 def _get_plotter(self):
20 # check for the validity of the plotter and
21 # return the plotter class instance if its valid.
22 if self.plotter() is None:
23 raise RuntimeError, "Internal Error. The plotter has been destroyed."
24 else:
25 return self.plotter()
26
27 ### select the nearest spectrum in pick radius
28 ### and display spectral value on the toolbar.
29 def _select_spectrum(self,event):
30 # Do not fire event when in zooming/panning mode
31 mode = self.figmgr.toolbar.mode
32 if not mode == '':
33 return
34 # When selected point is out of panels
35 if event.inaxes == None:
36 return
37 # If not left button
38 if event.button != 1:
39 return
40
41 # check for the validity of plotter and get the plotter
42 theplotter = self._get_plotter()
43
44 xclick = event.xdata
45 yclick = event.ydata
46 dist2 = 1000.
47 pickline = None
48 # If the pannel has picable objects
49 pflag = False
50 for lin in event.inaxes.lines:
51 if not lin.pickable():
52 continue
53 pflag = True
54 flag,pind = lin.contains(event)
55 if not flag:
56 continue
57 # Get nearest point
58 inds = pind['ind']
59 xlin = lin.get_xdata()
60 ylin = lin.get_ydata()
61 for i in inds:
62 d2=(xlin[i]-xclick)**2+(ylin[i]-yclick)**2
63 if dist2 >= d2:
64 dist2 = d2
65 pickline = lin
66 # No pickcable line in the pannel
67 if not pflag:
68 return
69 # Pickable but too far from mouse position
70 elif pickline is None:
71 picked = 'No line selected.'
72 self.figmgr.toolbar.set_message(picked)
73 return
74 del pind, inds, xlin, ylin
75 # Spectra are Picked
76 theplot = theplotter._plotter
77 thetoolbar = self.figmgr.toolbar
78 thecanvas = self.figmgr.canvas
79 # Disconnect the default motion notify event
80 # Notice! the other buttons are also diabled!!!
81 thecanvas.mpl_disconnect(thetoolbar._idDrag)
82 # Get picked spectrum
83 xdata = pickline.get_xdata()
84 ydata = pickline.get_ydata()
85 titl = pickline.get_label()
86 titp = event.inaxes.title.get_text()
87 panel0 = event.inaxes
88 picked = "Selected: '"+titl+"' in panel '"+titp+"'."
89 thetoolbar.set_message(picked)
90 # Generate a navigation window
91 #naviwin=Navigationwindow(titp,titl)
92 #------------------------------------------------------#
93 # Show spectrum data at mouse position
94 def spec_data(event):
95 # Getting spectrum data of neiboring point
96 xclick = event.xdata
97 if event.inaxes != panel0:
98 return
99 ipoint = len(xdata)-1
100 for i in range(len(xdata)-1):
101 xl = xclick - xdata[i]
102 xr = xclick - xdata[i+1]
103 if xl*xr <= 0.:
104 ipoint = i
105 break
106 # Output spectral value on the navigation window
107 posi = '[ %s, %s ]: x = %.2f value = %.2f'\
108 %(titl,titp,xdata[ipoint],ydata[ipoint])
109 #naviwin.posi.set(posi)
110 thetoolbar.set_message(posi)
111 #------------------------------------------------------#
112 # Disconnect from mouse events
113 def discon(event):
114 #naviwin.window.destroy()
115 theplot.register('motion_notify',None)
116 # Re-activate the default motion_notify_event
117 thetoolbar._idDrag = thecanvas.mpl_connect('motion_notify_event',
118 thetoolbar.mouse_move)
119 theplot.register('button_release',None)
120 return
121 #------------------------------------------------------#
122 # Show data value along with mouse movement
123 theplot.register('motion_notify',spec_data)
124 # Finish events when mouse button is released
125 theplot.register('button_release',discon)
126
127
128 ### Notation
129 def _mod_note(self,event):
130 # Do not fire event when in zooming/panning mode
131 if not self.figmgr.toolbar.mode == '':
132 return
133 if event.button == 1:
134 self.notewin.load_textwindow(event)
135 elif event.button == 3 and self._note_picked(event):
136 self.notewin.load_modmenu(event)
137 return
138
139 def _note_picked(self,event):
140 # just briefly check if any texts are picked
141 for textobj in self.canvas.figure.texts:
142 if textobj.contains(event)[0]:
143 return True
144 for ax in self.canvas.figure.axes:
145 for textobj in ax.texts:
146 if textobj.contains(event)[0]:
147 return True
148 #print "No text picked"
149 return False
150
151
152 ### Purely plotter based statistics calculation of a selected area.
153 ### No access to scantable
154 def _single_mask(self,event):
155 # Do not fire event when in zooming/panning mode
156 if not self.figmgr.toolbar.mode == '':
157 return
158 # When selected point is out of panels
159 if event.inaxes == None:
160 return
161 if event.button == 1:
162 exclude=False
163 elif event.button == 3:
164 exclude=True
165 else:
166 return
167
168 # check for the validity of plotter and get the plotter
169 theplotter = self._get_plotter()
170
171 self._thisregion = {'axes': event.inaxes,'xs': event.x,
172 'worldx': [event.xdata,event.xdata],
173 'invert': exclude}
174 self.xold = event.x
175 self.xdataold = event.xdata
176
177 theplotter._plotter.register('button_press',None)
178 theplotter._plotter.register('motion_notify', self._xspan_draw)
179 theplotter._plotter.register('button_press', self._xspan_end)
180
181 def _xspan_draw(self,event):
182 if event.inaxes == self._thisregion['axes']:
183 xnow = event.x
184 self.xold = xnow
185 self.xdataold = event.xdata
186 else:
187 xnow = self.xold
188 try: self.lastspan
189 except AttributeError: pass
190 else:
191 if self.lastspan: self._remove_span(self.lastspan)
192
193 self.lastspan = self._draw_span(self._thisregion['axes'],
194 self._thisregion['xs'], xnow, fill="")
195 del xnow
196
197 def _draw_span(self,axes,x0,x1,**kwargs):
198 pass
199
200 def _remove_span(self,span):
201 pass
202
203 @asaplog_post_dec
204 def _xspan_end(self,event):
205 if not self.figmgr.toolbar.mode == '':
206 return
207 #if event.button != 1:
208 # return
209
210 try: self.lastspan
211 except AttributeError: pass
212 else:
213 self._remove_span(self.lastspan)
214 del self.lastspan
215 if event.inaxes == self._thisregion['axes']:
216 xdataend = event.xdata
217 else:
218 xdataend = self.xdataold
219
220 # check for the validity of plotter and get the plotter
221 theplotter = self._get_plotter()
222
223 self._thisregion['worldx'][1] = xdataend
224 # print statistics of spectra in subplot
225 self._subplot_stats(self._thisregion)
226
227 # release event
228 theplotter._plotter.register('button_press',None)
229 theplotter._plotter.register('motion_notify',None)
230 # Clear up region selection
231 self._thisregion = None
232 self.xdataold = None
233 self.xold = None
234 # finally recover region selection event
235 theplotter._plotter.register('button_press',self._single_mask)
236
237 def _subplot_stats(self,selection):
238 statstr = ['max', 'min', 'median', 'mean', 'sum', 'std'] #'rms']
239 panelstr = selection['axes'].title.get_text()
240 ssep = "-"*70
241 asaplog.push(ssep)
242 asaplog.post()
243 for line in selection['axes'].lines:
244 # Don't include annotations
245 if line.get_label().startswith("_"):
246 continue
247 label = panelstr + ", "+line.get_label()
248 x = line.get_xdata()
249 newmsk = None
250 selmsk = self._create_flag_from_array(x,
251 selection['worldx'],
252 selection['invert'])
253 ydat = None
254 y = line.get_ydata()
255 if numpy.ma.isMaskedArray(y):
256 ydat = y.data
257 basemsk = y.mask
258 else:
259 ydat = y
260 basemsk = False
261 if not isinstance(basemsk, bool):
262 # should be ndarray
263 newmsk = mask_or(selmsk, basemsk)
264 elif basemsk:
265 # the whole original spectrum is flagged
266 newmsk = basemsk
267 else:
268 # no channel was flagged originally
269 newmsk = selmsk
270 mdata = numpy.ma.masked_array(ydat, mask=newmsk)
271 statval = {}
272 for stat in statstr:
273 # need to get the stat functions from the ma module!!!
274 statval[stat] = getattr(numpy.ma,stat)(mdata)
275 self._print_stats(statval, statstr=statstr, label=label,\
276 mask=selection['worldx'],\
277 unmask=selection['invert'])
278 asaplog.push(ssep)
279 asaplog.post()
280
281 def _create_flag_from_array(self,x,masklist,invert):
282 # Return True for channels which should be EXCLUDED (flag)
283 if len(masklist) <= 1:
284 asaplog.push()
285 asaplog.post("masklist should be a list of 2 elements")
286 asaplog.push("ERROR")
287 n = len(x)
288 # Base mask: flag out all channels
289 mask = _n_bools(n, True)
290 minval = min(masklist[0:2])
291 maxval = max(masklist[0:2])
292 for i in range(n):
293 if minval <= x[i] <= maxval:
294 mask[i] = False
295 if invert:
296 mask = mask_not(mask)
297 return mask
298
299 @asaplog_post_dec
300 def _print_stats(self,stats,statstr=None,label="",mask=None,unmask=False):
301 if not isinstance(stats,dict) or len(stats) == 0:
302 asaplog.post()
303 asaplog.push("Invalid statistic value")
304 asaplog.post("ERROR")
305 maskstr = "Not available"
306 if mask:
307 masktype = "mask"
308 maskstr = str(mask)
309 if unmask: masktype = "unmask"
310
311 sout = label + ", " + masktype + " = " + maskstr + "\n"
312 statvals = []
313 if not len(statstr):
314 statstr = stats.keys()
315 for key in statstr:
316 sout += key.ljust(10)
317 statvals.append(stats.pop(key))
318 sout += "\n"
319 sout += ("%f "*len(statstr) % tuple(statvals))
320 asaplog.push(sout)
321 #del sout, maskstr, masktype, statvals, key, stats, statstr, mask, label
322
323
324 ### Page chages
325 ### go to the previous page
326 def prev_page(self):
327 self.figmgr.toolbar.set_message('plotting the previous page')
328 #self._pause_buttons(operation="start",msg='plotting the previous page')
329 self._new_page(goback=True)
330 #self._pause_buttons(operation="end")
331
332 ### go to the next page
333 def next_page(self):
334 self.figmgr.toolbar.set_message('plotting the next page')
335 #self._pause_buttons(operation="start",msg='plotting the next page')
336 self._new_page(goback=False)
337 #self._pause_buttons(operation="end")
338
339 ### actual plotting of the new page
340 def _new_page(self,goback=False):
341 # check for the validity of plotter and get the plotter
342 theplotter = self._get_plotter()
343
344 top = None
345 header = theplotter._headtext
346 reset = False
347 doheader = (isinstance(header['textobj'],list) and \
348 len(header['textobj']) > 0)
349 if doheader:
350 top = theplotter._plotter.figure.subplotpars.top
351 fontsize = header['textobj'][0].get_fontproperties().get_size()
352 if theplotter._startrow <= 0:
353 msg = "The page counter is reset due to chages of plot settings. "
354 msg += "Plotting from the first page."
355 asaplog.push(msg)
356 asaplog.post('WARN')
357 reset = True
358 goback = False
359 if doheader:
360 extrastr = selstr = ''
361 if header.has_key('extrastr'):
362 extrastr = header['extrastr']
363 if header.has_key('selstr'):
364 selstr = header['selstr']
365 theplotter._reset_header()
366
367 theplotter._plotter.hold()
368 if goback:
369 self._set_prevpage_counter()
370 #theplotter._plotter.clear()
371 theplotter._plot(theplotter._data)
372 pagenum = self._get_pagenum()
373 self.set_pagecounter(pagenum)
374 # Plot header information
375 #if header['textobj']:
376 if doheader and pagenum == 1:
377 if top and top != theplotter._margins[3]:
378 # work around for sdplot in CASA. complete checking in future?
379 theplotter._plotter.figure.subplots_adjust(top=top)
380 if reset:
381 theplotter.print_header(plot=True,fontsize=fontsize,selstr=selstr, extrastr=extrastr)
382 else:
383 theplotter._header_plot(header['string'],fontsize=fontsize)
384 theplotter._plotter.release()
385 theplotter._plotter.tidy()
386 theplotter._plotter.show(hardrefresh=False)
387 del top
388
389 ### calculate the panel ID and start row to plot the previous page
390 def _set_prevpage_counter(self):
391 # check for the validity of plotter and get the plotter
392 theplotter = self._get_plotter()
393
394 # set row and panel counters to those of the 1st panel of previous page
395 maxpanel = 16
396 # the ID of the last panel in current plot
397 lastpanel = theplotter._ipanel
398 # the number of current subplots
399 currpnum = len(theplotter._plotter.subplots)
400 # the nuber of previous subplots
401 prevpnum = None
402 if theplotter._rows and theplotter._cols:
403 # when user set layout
404 prevpnum = theplotter._rows*theplotter._cols
405 else:
406 # no user specification
407 prevpnum = maxpanel
408
409 start_ipanel = max(lastpanel-currpnum-prevpnum+1, 0)
410 # set the pannel ID of the last panel of prev-prev page
411 theplotter._ipanel = start_ipanel-1
412 if theplotter._panelling == 'r':
413 theplotter._startrow = start_ipanel
414 else:
415 # the start row number of the next panel
416 theplotter._startrow = theplotter._panelrows[start_ipanel]
417 del lastpanel,currpnum,prevpnum,start_ipanel
418
419 ### refresh the page counter
420 def set_pagecounter(self,page):
421 nwidth = int(numpy.ceil(numpy.log10(max(page,1))))+1
422 nwidth = max(nwidth,4)
423 formatstr = '%'+str(nwidth)+'d'
424 self.show_pagenum(page,formatstr)
425
426 def show_pagenum(self,pagenum,formatstr):
427 # passed to backend dependent class
428 pass
429
430 def _get_pagenum(self):
431 # check for the validity of plotter and get the plotter
432 theplotter = self._get_plotter()
433
434 # get the ID of last panel in the current page
435 idlastpanel = theplotter._ipanel
436 # max panels in a page
437 ppp = theplotter._plotter.rows*theplotter._plotter.cols
438 return int(idlastpanel/ppp)+1
439
440 # pause buttons for slow operations. implemented at a backend dependent class
441 def _pause_buttons(self,operation="end",msg=""):
442 pass
443
444
445
446
447######################################
448## Notation box window ##
449######################################
450class NotationWindowCommon:
451 """
452 A base class to define the functions that the backend-based
453 GUI notation class must implement to print/modify/delete notes on a canvas.
454
455 The following methods *must* be implemented in the backend-based
456 parent class:
457 _get_note : get text in text box
458 _get_anchval : get anchor value selected
459 """
460 def __init__(self,master=None):
461 #self.parent = master
462 self.canvas = master
463 self.event = None
464 self.note = None
465 self.anchors = ["figure","axes","data"]
466 self.seltext = {}
467 self.numnote = 0
468
469 @asaplog_post_dec
470 def print_text(self):
471 """
472 Print a note on a canvas specified with the Notation window.
473 Called when 'print' button selected on the window.
474 """
475 anchor = self.anchors[self._get_anchval()]
476 notestr = self._get_note().rstrip("\n")
477 if len(notestr.strip()) == 0:
478 #self._clear_textbox()
479 #print "Empty string!"
480 return
481
482 myaxes = None
483 calcpos = True
484 xpos = None
485 ypos = None
486 if self.seltext:
487 # You are modifying a text
488 mycanvas = self.canvas
489 oldanch = self.seltext['anchor']
490 if oldanch != 'figure':
491 myaxes = self.seltext['parent']
492 calcpos = (anchor != oldanch)
493 if not calcpos:
494 # printing text in the same coord.
495 # you don't have to recalc position
496 parent = self.seltext['parent']
497 transform = self.seltext['textobj'].get_transform()
498 (xpos, ypos) = self.seltext['textobj'].get_position()
499 elif anchor == "figure":
500 # converting from "axes"/"data" -> "figure"
501 (x, y) = self.seltext['textobj']._get_xy_display()
502 elif oldanch == "data":
503 # converting from "data" -> "axes".
504 # need xdata & ydata in the axes
505 (x, y) = self.seltext['textobj'].get_position()
506 else:
507 # converting "figure"/"axes" -> "data"
508 # need to calculate xdata & ydata in the axes
509 pixpos = self.seltext['textobj']._get_xy_display()
510 (w,h) = mycanvas.get_width_height()
511 relpos = (pixpos[0]/float(w), pixpos[1]/float(h))
512 if not myaxes:
513 myaxes = self._get_axes_from_pos(relpos,mycanvas)
514 if not myaxes:
515 raise RuntimeError, "Axes resolution failed!"
516 (x, y) = self._convert_pix2dat(relpos,myaxes)
517 self._remove_seltext()
518 elif self.event:
519 mycanvas = self.event.canvas
520 myaxes = self.event.inaxes
521 if myaxes and (anchor != "figure"):
522 x = self.event.xdata
523 y = self.event.ydata
524 else:
525 x = self.event.x
526 y = self.event.y
527 else:
528 raise RuntimeError, "No valid position to print data"
529 return
530
531 # now you know
532 picker = True
533 # alignment of the text: ha (horizontal), va (vertical)
534 ha = 'left'
535 #va = 'center'
536 va = 'top'
537 if not calcpos:
538 # you aready know parent, tansform, xpos and ypos
539 pass
540 elif anchor == "figure":
541 # text instance will be appended to mycanvas.figure.texts
542 parent = mycanvas.figure
543 transform = parent.transFigure
544 (w,h) = mycanvas.get_width_height()
545 xpos = x/float(w)
546 ypos = y/float(h)
547 elif myaxes:
548 ## text instance will be appended to myaxes.texts
549 parent = myaxes
550 if anchor == "axes":
551 transform = myaxes.transAxes
552 lims = myaxes.get_xlim()
553 xpos = (x-lims[0])/(lims[1]-lims[0])
554 lims = myaxes.get_ylim()
555 ypos = (y-lims[0])/(lims[1]-lims[0])
556 else:
557 # anchored on "data"
558 transform = myaxes.transData
559 xpos = x
560 ypos = y
561 parent.text(xpos,ypos,notestr,transform=transform,
562 ha=ha,va=va,picker=picker)
563 mycanvas.draw()
564
565 self.numnote += 1
566
567 #self._clear_textbox()
568 msg = "Added note: '"+notestr+"'"
569 msg += " @["+str(xpos)+", "+str(ypos)+"] ("+anchor+"-coord)"
570 msg += "\ntotal number of notes are "+str(self.numnote)
571 asaplog.push( msg )
572
573 def _get_axes_from_pos(self,pos,canvas):
574 """helper function to get axes of a position in a plot (fig-coord)"""
575 if len(pos) != 2:
576 raise ValueError, "pixel position should have 2 elements"
577 for axes in canvas.figure.axes:
578 ##check if pos is in the axes
579 #if axes.contains_point(pos): ### seems not working
580 # return axes
581 try:
582 axbox = axes.get_position().get_points()
583 except AttributeError: ### WORKAROUND for old matplotlib
584 axbox = self._oldpos2new(axes.get_position())
585 if (axbox[0][0] <= pos[0] <= axbox[1][0]) and \
586 (axbox[0][1] <= pos[1] <= axbox[1][1]):
587 return axes
588 return None
589
590 ### WORKAROUND for old matplotlib
591 def _oldpos2new(self,oldpos=None):
592 return [[oldpos[0],oldpos[1]],[oldpos[0]+oldpos[2],oldpos[1]+oldpos[3]]]
593
594 def _convert_pix2dat(self,pos,axes):
595 """
596 helper function to convert a position in figure-coord (0-1) to
597 data-coordinate of the axes
598 """
599 # convert a relative position from lower-left of the canvas
600 # to a data in axes
601 if len(pos) != 2:
602 raise ValueError, "pixel position should have 2 elements"
603 # left-/bottom-pixel, and pixel width & height of the axes
604 bbox = axes.get_position()
605 try:
606 axpos = bbox.get_points()
607 except AttributeError: ### WORKAROUND for old matplotlib
608 axpos = self._oldpos2new(bbox)
609 # check pos value
610 if (pos[0] < axpos[0][0]) or (pos[1] < axpos[0][1]) \
611 or (pos[0] > axpos[1][0]) or (pos[1] > axpos[1][1]):
612 raise ValueError, "The position is out of the axes"
613 xlims = axes.get_xlim()
614 ylims = axes.get_ylim()
615 wdat = xlims[1] - xlims[0]
616 hdat = ylims[1] - ylims[0]
617 xdat = xlims[0] + wdat*(pos[0] - axpos[0][0])/(axpos[1][0] - axpos[0][0])
618 ydat = ylims[0] + hdat*(pos[1] - axpos[0][1])/(axpos[1][1] - axpos[0][1])
619 return (xdat, ydat)
620
621 @asaplog_post_dec
622 def _get_selected_text(self,event):
623 """helper function to return a dictionary of the nearest note to the event."""
624 (w,h) = event.canvas.get_width_height()
625 dist2 = w*w+h*h
626 selected = {}
627 for textobj in self.canvas.figure.texts:
628 if textobj.contains(event)[0]:
629 d2 = self._get_text_dist2(event,textobj)
630 if dist2 >= d2:
631 dist2 = d2
632 selected = {'anchor': 'figure', \
633 'parent': event.canvas.figure, 'textobj': textobj}
634 msg = "Fig loop: a text, '"+textobj.get_text()+"', at "
635 msg += str(textobj.get_position())+" detected"
636 #print msg
637 for ax in self.canvas.figure.axes:
638 for textobj in ax.texts:
639 if textobj.contains(event)[0]:
640 d2 = self._get_text_dist2(event,textobj)
641 if dist2 >= d2:
642 anchor='axes'
643 if ax.transData == textobj.get_transform():
644 anchor = 'data'
645 selected = {'anchor': anchor, \
646 'parent': ax, 'textobj': textobj}
647 msg = "Ax loop: a text, '"+textobj.get_text()+"', at "
648 msg += str(textobj.get_position())+" detected"
649 #print msg
650
651 if selected:
652 msg = "Selected (modify/delete): '"+selected['textobj'].get_text()
653 msg += "' @"+str(selected['textobj'].get_position())
654 msg += " ("+selected['anchor']+"-coord)"
655 asaplog.push(msg)
656
657 return selected
658
659 def _get_text_dist2(self,event,textobj):
660 """
661 helper function to calculate square of distance between
662 a event position and a text object.
663 """
664 (x,y) = textobj._get_xy_display()
665 return (x-event.x)**2+(y-event.y)**2
666
667 def delete_note(self):
668 """
669 Remove selected note.
670 """
671 #print "You selected 'OK'"
672 self._remove_seltext()
673 self.canvas.draw()
674
675 @asaplog_post_dec
676 def _remove_seltext(self):
677 """helper function to remove the selected note"""
678 if len(self.seltext) < 3:
679 raise ValueError, "Don't under stand selected text obj."
680 return
681 try:
682 self.seltext['textobj'].remove()
683 except NotImplementedError:
684 self.seltext['parent'].texts.pop(self.seltext['parent'].texts.index(self.seltext['textobj']))
685 self.numnote -= 1
686
687 textobj = self.seltext['textobj']
688 msg = "Deleted note: '"+textobj.get_text()+"'"
689 msg += "@"+str(textobj.get_position())\
690 +" ("+self.seltext['anchor']+"-coord)"
691 msg += "\ntotal number of notes are "+str(self.numnote)
692 asaplog.push( msg )
693
694 self.seltext = {}
695
696 @asaplog_post_dec
697 def cancel_delete(self):
698 """
699 Cancel deleting the selected note.
700 Called when 'cancel' button selected on confirmation dialog.
701 """
702 asaplog.push( "Cancel deleting: '"+self.seltext['textobj'].get_text()+"'" )
703 self.seltext = {}
704
705
706
707###########################################
708## Add CASA custom Flag toolbar ##
709###########################################
710class CustomFlagToolbarCommon:
711 def __init__(self,parent):
712 self.plotter=weakref.ref(parent)
713 #self.figmgr=self.plotter._plotter.figmgr
714 self._selregions = {}
715 self._selpanels = []
716 self._polygons = []
717 self._thisregion = None
718 self.xdataold=None
719
720 def _get_plotter(self):
721 # check for the validity of the plotter and
722 # return the plotter class instance if its valid.
723 if self.plotter() is None:
724 raise RuntimeError, "Internal Error. The plotter has been destroyed."
725 else:
726 return self.plotter()
727
728 ### select the nearest spectrum in pick radius
729 ### and display spectral value on the toolbar.
730 def _select_spectrum(self,event):
731 # Do not fire event when in zooming/panning mode
732 mode = self.figmgr.toolbar.mode
733 if not mode == '':
734 return
735 # When selected point is out of panels
736 if event.inaxes == None:
737 return
738 # If not left button
739 if event.button != 1:
740 return
741
742 # check for the validity of plotter and get the plotter
743 theplotter = self._get_plotter()
744
745 xclick = event.xdata
746 yclick = event.ydata
747 dist2 = 1000.
748 pickline = None
749 # If the pannel has picable objects
750 pflag = False
751 for lin in event.inaxes.lines:
752 if not lin.pickable():
753 continue
754 pflag = True
755 flag,pind = lin.contains(event)
756 if not flag:
757 continue
758 # Get nearest point
759 inds = pind['ind']
760 xlin = lin.get_xdata()
761 ylin = lin.get_ydata()
762 for i in inds:
763 d2=(xlin[i]-xclick)**2+(ylin[i]-yclick)**2
764 if dist2 >= d2:
765 dist2 = d2
766 pickline = lin
767 # No pickcable line in the pannel
768 if not pflag:
769 return
770 # Pickable but too far from mouse position
771 elif pickline is None:
772 picked = 'No line selected.'
773 self.figmgr.toolbar.set_message(picked)
774 return
775 del pind, inds, xlin, ylin
776 # Spectra are Picked
777 theplot = theplotter._plotter
778 thetoolbar = self.figmgr.toolbar
779 thecanvas = self.figmgr.canvas
780 # Disconnect the default motion notify event
781 # Notice! the other buttons are also diabled!!!
782 thecanvas.mpl_disconnect(thetoolbar._idDrag)
783 # Get picked spectrum
784 xdata = pickline.get_xdata()
785 ydata = pickline.get_ydata()
786 titl = pickline.get_label()
787 titp = event.inaxes.title.get_text()
788 panel0 = event.inaxes
789 picked = "Selected: '"+titl+"' in panel '"+titp+"'."
790 thetoolbar.set_message(picked)
791 # Generate a navigation window
792 #naviwin=Navigationwindow(titp,titl)
793 #------------------------------------------------------#
794 # Show spectrum data at mouse position
795 def spec_data(event):
796 # Getting spectrum data of neiboring point
797 xclick = event.xdata
798 if event.inaxes != panel0:
799 return
800 ipoint = len(xdata)-1
801 for i in range(len(xdata)-1):
802 xl = xclick-xdata[i]
803 xr = xclick-xdata[i+1]
804 if xl*xr <= 0.:
805 ipoint = i
806 break
807 # Output spectral value on the navigation window
808 posi = '[ %s, %s ]: x = %.2f value = %.2f'\
809 %(titl,titp,xdata[ipoint],ydata[ipoint])
810 #naviwin.posi.set(posi)
811 thetoolbar.set_message(posi)
812 #------------------------------------------------------#
813 # Disconnect from mouse events
814 def discon(event):
815 #naviwin.window.destroy()
816 theplot.register('motion_notify',None)
817 # Re-activate the default motion_notify_event
818 thetoolbar._idDrag=thecanvas.mpl_connect('motion_notify_event',
819 thetoolbar.mouse_move)
820 theplot.register('button_release',None)
821 return
822 #------------------------------------------------------#
823 # Show data value along with mouse movement
824 theplot.register('motion_notify',spec_data)
825 # Finish events when mouse button is released
826 theplot.register('button_release',discon)
827
828
829 ### Notation
830 def _mod_note(self,event):
831 # Do not fire event when in zooming/panning mode
832 if not self.figmgr.toolbar.mode == '':
833 return
834 if event.button == 1:
835 self.notewin.load_textwindow(event)
836 elif event.button == 3 and self._note_picked(event):
837 self.notewin.load_modmenu(event)
838 return
839
840 def _note_picked(self,event):
841 # just briefly check if any texts are picked
842 for textobj in self.canvas.figure.texts:
843 if textobj.contains(event)[0]:
844 return True
845 for ax in self.canvas.figure.axes:
846 for textobj in ax.texts:
847 if textobj.contains(event)[0]:
848 return True
849 return False
850
851 ### Region/Panel selection & oparations
852 ### add regions to selections
853 @asaplog_post_dec
854 def _add_region(self,event):
855 if not self.figmgr.toolbar.mode == '':
856 return
857 if event.button != 1 or event.inaxes == None:
858 return
859 # check for the validity of plotter and get the plotter
860 theplotter = self._get_plotter()
861 # this row resolution assumes row panelling
862 irow = int(self._getrownum(event.inaxes))
863 if irow in self._selpanels:
864 msg = "The whole spectrum is already selected"
865 asaplog.post()
866 asaplog.push(msg)
867 asaplog.post('WARN')
868 return
869 self._thisregion = {'axes': event.inaxes,'xs': event.x,
870 'worldx': [event.xdata,event.xdata]}
871 theplotter._plotter.register('button_press',None)
872 self.xold = event.x
873 self.xdataold = event.xdata
874 theplotter._plotter.register('motion_notify', self._xspan_draw)
875 theplotter._plotter.register('button_press', self._xspan_end)
876
877 def _xspan_draw(self,event):
878 if event.inaxes == self._thisregion['axes']:
879 xnow = event.x
880 self.xold = xnow
881 self.xdataold = event.xdata
882 else:
883 xnow = self.xold
884 try: self.lastspan
885 except AttributeError: pass
886 else:
887 if self.lastspan: self._remove_span(self.lastspan)
888
889 #self.lastspan = self._draw_span(self._thisregion['axes'],self._thisregion['xs'],xnow,fill="#555555",stipple="gray50")
890 self.lastspan = self._draw_span(self._thisregion['axes'],self._thisregion['xs'],xnow,fill="")
891 del xnow
892
893 def _draw_span(self,axes,x0,x1,**kwargs):
894 pass
895
896 def _remove_span(self,span):
897 pass
898
899 @asaplog_post_dec
900 def _xspan_end(self,event):
901 if not self.figmgr.toolbar.mode == '':
902 return
903 if event.button != 1:
904 return
905
906 try: self.lastspan
907 except AttributeError: pass
908 else:
909 self._remove_span(self.lastspan)
910 del self.lastspan
911 if event.inaxes == self._thisregion['axes']:
912 xdataend = event.xdata
913 else:
914 xdataend = self.xdataold
915
916 self._thisregion['worldx'][1] = xdataend
917 lregion = self._thisregion['worldx']
918 # WORKAROUND for the issue axvspan started to reset xlim.
919 axlimx = self._thisregion['axes'].get_xlim()
920 pregion = self._thisregion['axes'].axvspan(lregion[0],lregion[1],
921 facecolor='0.7')
922 self._thisregion['axes'].set_xlim(axlimx)
923
924 # check for the validity of plotter and get the plotter
925 theplotter = self._get_plotter()
926
927 theplotter._plotter.canvas.draw()
928 self._polygons.append(pregion)
929 srow = self._getrownum(self._thisregion['axes'])
930 irow = int(srow)
931 if not self._selregions.has_key(srow):
932 self._selregions[srow] = []
933 self._selregions[srow].append(lregion)
934 del lregion, pregion, xdataend
935 sout = "selected region: "+str(self._thisregion['worldx'])+\
936 "(@row "+str(self._getrownum(self._thisregion['axes']))+")"
937 asaplog.push(sout)
938
939 # release event
940 theplotter._plotter.register('button_press',None)
941 theplotter._plotter.register('motion_notify',None)
942 # Clear up region selection
943 self._thisregion = None
944 self.xdataold = None
945 self.xold = None
946 # finally recover region selection event
947 theplotter._plotter.register('button_press',self._add_region)
948
949 ### add panels to selections
950 @asaplog_post_dec
951 def _add_panel(self,event):
952 if not self.figmgr.toolbar.mode == '':
953 return
954 if event.button != 1 or event.inaxes == None:
955 return
956 # check for the validity of plotter and get the plotter
957 theplotter = self._get_plotter()
958
959 selax = event.inaxes
960 # this row resolution assumes row panelling
961 srow = self._getrownum(selax)
962 irow = int(srow)
963 if srow:
964 self._selpanels.append(irow)
965 shadow = Rectangle((0,0),1,1,facecolor='0.7',transform=selax.transAxes,visible=True)
966 self._polygons.append(selax.add_patch(shadow))
967 #theplotter._plotter.show(False)
968 theplotter._plotter.canvas.draw()
969 asaplog.push("row "+str(irow)+" is selected")
970 ## check for region selection of the spectra and overwrite it.
971 ##!!!! currently disabled for consistency with flag tools !!!!
972 #if self._selregions.has_key(srow):
973 # self._selregions.pop(srow)
974 # msg = "The whole spectrum is selected for row="+srow+". Region selection will be overwritten."
975 # asaplog.push(msg)
976
977 def _getrownum(self,axis):
978 ### returns the row number of selected spectrum as a string ###
979 plabel = axis.get_title()
980 if plabel.startswith("row "):
981 return plabel.strip("row ")
982 return None
983
984 def _any_selection(self):
985 ### returns if users have selected any spectrum or region ###
986 if len(self._selpanels) or len(self._selregions):
987 return True
988 return False
989
990 def _plot_selections(self,regions=None,panels=None):
991 ### mark panels/spectra selections in the page
992 if not self._any_selection() and not (regions or panels):
993 return
994 regions = regions or self._selregions.copy() or {}
995 panels = panels or self._selpanels or []
996 if not isinstance(regions,dict):
997 asaplog.post()
998 asaplog.push("Invalid region specification")
999 asaplog.post('ERROR')
1000 if not isinstance(panels,list):
1001 asaplog.post()
1002 asaplog.push("Invalid panel specification")
1003 asaplog.post('ERROR')
1004
1005 # check for the validity of plotter and get the plotter
1006 theplotter = self._get_plotter()
1007
1008 strow = self._getrownum(theplotter._plotter.subplots[0]['axes'])
1009 enrow = self._getrownum(theplotter._plotter.subplots[-1]['axes'])
1010 for irow in range(int(strow),int(enrow)+1):
1011 if regions.has_key(str(irow)):
1012 ax = theplotter._plotter.subplots[irow - int(strow)]['axes']
1013 mlist = regions.pop(str(irow))
1014 # WORKAROUND for the issue axvspan started to reset xlim.
1015 axlimx = ax.get_xlim()
1016 for i in range(len(mlist)):
1017 self._polygons.append(ax.axvspan(mlist[i][0],mlist[i][1],
1018 facecolor='0.7'))
1019 ax.set_xlim(axlimx)
1020 del ax,mlist,axlimx
1021 if irow in panels:
1022 ax = theplotter._plotter.subplots[irow - int(strow)]['axes']
1023 shadow = Rectangle((0,0),1,1,facecolor='0.7',
1024 transform=ax.transAxes,visible=True)
1025 self._polygons.append(ax.add_patch(shadow))
1026 del ax,shadow
1027 theplotter._plotter.canvas.draw()
1028 del regions,panels,strow,enrow
1029
1030 def _clear_selection_plot(self, refresh=True):
1031 ### clear up polygons which mark selected spectra and regions ###
1032 if len(self._polygons) > 0:
1033 for shadow in self._polygons:
1034 shadow.remove()
1035 if refresh:
1036 # check for the validity of plotter and get the plotter
1037 theplotter = self._get_plotter()
1038 theplotter._plotter.canvas.draw()
1039 self._polygons = []
1040
1041 def _clearup_selections(self, refresh=True):
1042 # clear-up selection and polygons
1043 self._selpanels = []
1044 self._selregions = {}
1045 self._clear_selection_plot(refresh=refresh)
1046
1047 ### clear up selections
1048 def cancel_select(self):
1049 self.figmgr.toolbar.set_message('selections canceled')
1050 # clear-up selection and polygons
1051 self._clearup_selections(refresh=True)
1052
1053 ### flag selected spectra/regions
1054 @asaplog_post_dec
1055 def flag(self):
1056 if not self._any_selection():
1057 msg = "No selection to be Flagged"
1058 asaplog.post()
1059 asaplog.push(msg)
1060 asaplog.post('WARN')
1061 return
1062
1063 self._pause_buttons(operation="start",msg="Flagging data...")
1064 self._flag_operation(rows=self._selpanels,
1065 regions=self._selregions,unflag=False)
1066 sout = "Flagged:\n"
1067 sout += " rows = "+str(self._selpanels)+"\n"
1068 sout += " regions: "+str(self._selregions)
1069 asaplog.push(sout)
1070 del sout
1071 # check for the validity of plotter and get the plotter
1072 theplotter = self._get_plotter()
1073
1074 theplotter._ismodified = True
1075 self._clearup_selections(refresh=False)
1076 self._plot_page(pagemode="current")
1077 self._pause_buttons(operation="end")
1078
1079 ### unflag selected spectra/regions
1080 @asaplog_post_dec
1081 def unflag(self):
1082 if not self._any_selection():
1083 msg = "No selection to be Flagged"
1084 asaplog.push(msg)
1085 asaplog.post('WARN')
1086 return
1087 self._pause_buttons(operation="start",msg="Unflagging data...")
1088 self._flag_operation(rows=self._selpanels,
1089 regions=self._selregions,unflag=True)
1090 sout = "Unflagged:\n"
1091 sout += " rows = "+str(self._selpanels)+"\n"
1092 sout += " regions: "+str(self._selregions)
1093 asaplog.push(sout)
1094 del sout
1095
1096 # check for the validity of plotter and get the plotter
1097 theplotter = self._get_plotter()
1098 theplotter._ismodified = True
1099 self._clearup_selections(refresh=False)
1100 self._plot_page(pagemode="current")
1101 self._pause_buttons(operation="end")
1102
1103 ### actual flag operation
1104 @asaplog_post_dec
1105 def _flag_operation(self,rows=None,regions=None,unflag=False):
1106 # check for the validity of plotter and get the plotter
1107 theplotter = self._get_plotter()
1108
1109 scan = theplotter._data
1110 if not scan:
1111 asaplog.post()
1112 asaplog.push("Invalid scantable")
1113 asaplog.post("ERROR")
1114 if isinstance(rows,list) and len(rows) > 0:
1115 scan.flag_row(rows=rows,unflag=unflag)
1116 if isinstance(regions,dict) and len(regions) > 0:
1117 for srow, masklist in regions.iteritems():
1118 if not isinstance(masklist,list) or len(masklist) ==0:
1119 msg = "Ignoring invalid region selection for row = "+srow
1120 asaplog.post()
1121 asaplog.push(msg)
1122 asaplog.post("WARN")
1123 continue
1124 irow = int(srow)
1125 mask = scan.create_mask(masklist,invert=False,row=irow)
1126 scan.flag(row=irow,mask=mask,unflag=unflag)
1127 del irow, mask
1128 del srow, masklist
1129 del scan
1130
1131 ### show statistics of selected spectra/regions
1132 @asaplog_post_dec
1133 def stat_cal(self):
1134 if not self._any_selection():
1135 msg = "No selection to be calculated"
1136 asaplog.push(msg)
1137 asaplog.post('WARN')
1138 return
1139 self._selected_stats(rows=self._selpanels,regions=self._selregions)
1140 self._clearup_selections(refresh=True)
1141
1142 @asaplog_post_dec
1143 def _selected_stats(self,rows=None,regions=None):
1144 # check for the validity of plotter and get the plotter
1145 theplotter = self._get_plotter()
1146
1147 scan = theplotter._data
1148 if not scan:
1149 asaplog.post()
1150 asaplog.push("Invalid scantable")
1151 asaplog.post("ERROR")
1152 mathobj = stmath( rcParams['insitu'] )
1153 statval = {}
1154 statstr = ['max', 'min', 'mean', 'median', 'sum', 'stddev', 'rms']
1155 if isinstance(rows, list) and len(rows) > 0:
1156 for irow in rows:
1157 for stat in statstr:
1158 statval[stat] = mathobj._statsrow(scan,[],stat,irow)[0]
1159 self._print_stats(scan,irow,statval,statstr=statstr)
1160 del irow
1161 if isinstance(regions,dict) and len(regions) > 0:
1162 for srow, masklist in regions.iteritems():
1163 if not isinstance(masklist,list) or len(masklist) ==0:
1164 msg = "Ignoring invalid region selection for row = "+srow
1165 asaplog.post()
1166 asaplog.push(msg)
1167 asaplog.post("WARN")
1168 continue
1169 irow = int(srow)
1170 mask = scan.create_mask(masklist,invert=False,row=irow)
1171 for stat in statstr:
1172 statval[stat] = mathobj._statsrow(scan,mask,stat,irow)[0]
1173 self._print_stats(scan,irow,statval,statstr=statstr,
1174 mask=masklist)
1175 del irow, mask
1176 del srow, masklist
1177 del scan, statval, mathobj
1178
1179 @asaplog_post_dec
1180 def _print_stats(self,scan,row,stats,statstr=None,mask=None):
1181 if not isinstance(scan, scantable):
1182 asaplog.post()
1183 asaplog.push("Invalid scantable")
1184 asaplog.post("ERROR")
1185 if row < 0 or row > scan.nrow():
1186 asaplog.post()
1187 asaplog.push("Invalid row number")
1188 asaplog.post("ERROR")
1189 if not isinstance(stats,dict) or len(stats) == 0:
1190 asaplog.post()
1191 asaplog.push("Invalid statistic value")
1192 asaplog.post("ERROR")
1193 maskstr = "All"
1194 if mask:
1195 maskstr = str(mask)
1196 ssep = "-"*70+"\n"
1197 sout = ssep
1198 sout += ("Row=%d Scan=%d IF=%d Pol=%d Time=%s mask=%s" % \
1199 (row, scan.getscan(row), scan.getif(row), scan.getpol(row), scan.get_time(row),maskstr))
1200 sout += "\n"
1201 statvals = []
1202 if not len(statstr):
1203 statstr = stats.keys()
1204 for key in statstr:
1205 sout += key.ljust(10)
1206 statvals.append(stats.pop(key))
1207 sout += "\n"
1208 sout += ("%f "*len(statstr) % tuple(statvals))
1209 sout += "\n"+ssep
1210 asaplog.push(sout)
1211 del sout, ssep, maskstr, statvals, key, scan, row, stats, statstr, mask
1212
1213 ### Page chages
1214 ### go to the previous page
1215 def prev_page(self):
1216 self._pause_buttons(operation="start",msg='plotting the previous page')
1217 self._clear_selection_plot(refresh=False)
1218 self._plot_page(pagemode="prev")
1219 self._plot_selections()
1220 self._pause_buttons(operation="end")
1221
1222 ### go to the next page
1223 def next_page(self):
1224 self._pause_buttons(operation="start",msg='plotting the next page')
1225 self._clear_selection_plot(refresh=False)
1226 self._plot_page(pagemode="next")
1227 self._plot_selections()
1228 self._pause_buttons(operation="end")
1229
1230 ### actual plotting of the new page
1231 def _plot_page(self,pagemode="next"):
1232 # check for the validity of plotter and get the plotter
1233 theplotter = self._get_plotter()
1234 if theplotter._startrow <= 0:
1235 msg = "The page counter is reset due to chages of plot settings. "
1236 msg += "Plotting from the first page."
1237 asaplog.post()
1238 asaplog.push(msg)
1239 asaplog.post('WARN')
1240 goback = False
1241
1242 theplotter._plotter.hold()
1243 #theplotter._plotter.legend(1)
1244 self._set_plot_counter(pagemode)
1245 theplotter._plot(theplotter._data)
1246 self.set_pagecounter(self._get_pagenum())
1247 theplotter._plotter.release()
1248 theplotter._plotter.tidy()
1249 theplotter._plotter.show(hardrefresh=False)
1250
1251 ### calculate the panel ID and start row to plot a page
1252 #def _set_prevpage_counter(self):
1253 def _set_plot_counter(self, pagemode):
1254 ## page operation should be either "previous", "current", or "next"
1255 availpage = ["p","c","n"]
1256 pageop = pagemode[0].lower()
1257 if not (pageop in availpage):
1258 asaplog.post()
1259 asaplog.push("Invalid page operation")
1260 asaplog.post("ERROR")
1261 if pageop == "n":
1262 # nothing necessary to plot the next page
1263 return
1264
1265 # check for the validity of plotter and get the plotter
1266 theplotter = self._get_plotter()
1267
1268 # set row and panel counters to those of the 1st panel of previous page
1269 maxpanel = 25
1270 # the ID of the last panel in current plot
1271 lastpanel = theplotter._ipanel
1272 # the number of current subplots
1273 currpnum = len(theplotter._plotter.subplots)
1274
1275 # the nuber of previous subplots
1276 start_ipanel = None
1277 if pageop == "c":
1278 start_ipanel = max(lastpanel-currpnum+1, 0)
1279 else:
1280 ## previous page
1281 prevpnum = None
1282 if theplotter._rows and theplotter._cols:
1283 # when user set layout
1284 prevpnum = theplotter._rows*theplotter._cols
1285 else:
1286 # no user specification
1287 prevpnum = maxpanel
1288 start_ipanel = max(lastpanel-currpnum-prevpnum+1, 0)
1289 del prevpnum
1290
1291 # set the pannel ID of the last panel of the prev(-prev) page
1292 theplotter._ipanel = start_ipanel-1
1293 if theplotter._panelling == 'r':
1294 theplotter._startrow = start_ipanel
1295 else:
1296 # the start row number of the next panel
1297 theplotter._startrow = theplotter._panelrows[start_ipanel]
1298 del lastpanel,currpnum,start_ipanel
1299
1300 ### refresh the page counter
1301 def set_pagecounter(self,page):
1302 nwidth = int(numpy.ceil(numpy.log10(max(page,1))))+1
1303 nwidth = max(nwidth,4)
1304 formatstr = '%'+str(nwidth)+'d'
1305 self.show_pagenum(page,formatstr)
1306
1307 def show_pagenum(self,pagenum,formatstr):
1308 # passed to backend dependent class
1309 pass
1310
1311 def _get_pagenum(self):
1312 # check for the validity of plotter and get the plotter
1313 theplotter = self._get_plotter()
1314 # get the ID of last panel in the current page
1315 idlastpanel = theplotter._ipanel
1316 # max panels in a page
1317 ppp = theplotter._plotter.rows*theplotter._plotter.cols
1318 return int(idlastpanel/ppp)+1
1319
1320 # pause buttons for slow operations. implemented at a backend dependent class
1321 def _pause_buttons(self,operation="end",msg=""):
1322 pass
Note: See TracBrowser for help on using the repository browser.