##// END OF EJS Templates
schain-jc
RSS
Change steps for xticks in plots
Juan C. Espinoza -
r1196:06c60272fd61
parent child
Show More
Side by Side Unified
Context file:
r1196:06c60272fd61 Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,800 +1,799
1 1
2 2 import os
3 3 import sys
4 4 import zmq
5 5 import time
6 6 import datetime
7 7 from functools import wraps
8 8 import numpy
9 9 import matplotlib
10 10
11 11 if 'BACKEND' in os.environ:
12 12 matplotlib.use(os.environ['BACKEND'])
13 13 elif 'linux' in sys.platform:
14 14 matplotlib.use("TkAgg")
15 15 elif 'darwin' in sys.platform:
16 16 matplotlib.use('TkAgg')
17 17 else:
18 18 from schainpy.utils import log
19 19 log.warning('Using default Backend="Agg"', 'INFO')
20 20 matplotlib.use('Agg')
21 21
22 22 import matplotlib.pyplot as plt
23 23 from matplotlib.patches import Polygon
24 24 from mpl_toolkits.axes_grid1 import make_axes_locatable
25 25 from matplotlib.ticker import FuncFormatter, LinearLocator, MultipleLocator
26 26
27 27 from schainpy.model.data.jrodata import PlotterData
28 28 from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
29 29 from schainpy.utils import log
30 30
31 31 jet_values = matplotlib.pyplot.get_cmap('jet', 100)(numpy.arange(100))[10:90]
32 32 blu_values = matplotlib.pyplot.get_cmap(
33 33 'seismic_r', 20)(numpy.arange(20))[10:15]
34 34 ncmap = matplotlib.colors.LinearSegmentedColormap.from_list(
35 35 'jro', numpy.vstack((blu_values, jet_values)))
36 36 matplotlib.pyplot.register_cmap(cmap=ncmap)
37 37
38 38 CMAPS = [plt.get_cmap(s) for s in ('jro', 'jet', 'viridis',
39 39 'plasma', 'inferno', 'Greys', 'seismic', 'bwr', 'coolwarm')]
40 40
41 41 EARTH_RADIUS = 6.3710e3
42 42
43 43
44 44 def ll2xy(lat1, lon1, lat2, lon2):
45 45
46 46 p = 0.017453292519943295
47 47 a = 0.5 - numpy.cos((lat2 - lat1) * p)/2 + numpy.cos(lat1 * p) * \
48 48 numpy.cos(lat2 * p) * (1 - numpy.cos((lon2 - lon1) * p)) / 2
49 49 r = 12742 * numpy.arcsin(numpy.sqrt(a))
50 50 theta = numpy.arctan2(numpy.sin((lon2-lon1)*p)*numpy.cos(lat2*p), numpy.cos(lat1*p)
51 51 * numpy.sin(lat2*p)-numpy.sin(lat1*p)*numpy.cos(lat2*p)*numpy.cos((lon2-lon1)*p))
52 52 theta = -theta + numpy.pi/2
53 53 return r*numpy.cos(theta), r*numpy.sin(theta)
54 54
55 55
56 56 def km2deg(km):
57 57 '''
58 58 Convert distance in km to degrees
59 59 '''
60 60
61 61 return numpy.rad2deg(km/EARTH_RADIUS)
62 62
63 63
64 64 def figpause(interval):
65 65 backend = plt.rcParams['backend']
66 66 if backend in matplotlib.rcsetup.interactive_bk:
67 67 figManager = matplotlib._pylab_helpers.Gcf.get_active()
68 68 if figManager is not None:
69 69 canvas = figManager.canvas
70 70 if canvas.figure.stale:
71 71 canvas.draw()
72 72 try:
73 73 canvas.start_event_loop(interval)
74 74 except:
75 75 pass
76 76 return
77 77
78 78
79 79 def popup(message):
80 80 '''
81 81 '''
82 82
83 83 fig = plt.figure(figsize=(12, 8), facecolor='r')
84 84 text = '\n'.join([s.strip() for s in message.split(':')])
85 85 fig.text(0.01, 0.5, text, ha='left', va='center',
86 86 size='20', weight='heavy', color='w')
87 87 fig.show()
88 88 figpause(1000)
89 89
90 90
91 91 class Throttle(object):
92 92 '''
93 93 Decorator that prevents a function from being called more than once every
94 94 time period.
95 95 To create a function that cannot be called more than once a minute, but
96 96 will sleep until it can be called:
97 97 @Throttle(minutes=1)
98 98 def foo():
99 99 pass
100 100
101 101 for i in range(10):
102 102 foo()
103 103 print "This function has run %s times." % i
104 104 '''
105 105
106 106 def __init__(self, seconds=0, minutes=0, hours=0):
107 107 self.throttle_period = datetime.timedelta(
108 108 seconds=seconds, minutes=minutes, hours=hours
109 109 )
110 110
111 111 self.time_of_last_call = datetime.datetime.min
112 112
113 113 def __call__(self, fn):
114 114 @wraps(fn)
115 115 def wrapper(*args, **kwargs):
116 116 coerce = kwargs.pop('coerce', None)
117 117 if coerce:
118 118 self.time_of_last_call = datetime.datetime.now()
119 119 return fn(*args, **kwargs)
120 120 else:
121 121 now = datetime.datetime.now()
122 122 time_since_last_call = now - self.time_of_last_call
123 123 time_left = self.throttle_period - time_since_last_call
124 124
125 125 if time_left > datetime.timedelta(seconds=0):
126 126 return
127 127
128 128 self.time_of_last_call = datetime.datetime.now()
129 129 return fn(*args, **kwargs)
130 130
131 131 return wrapper
132 132
133 133 def apply_throttle(value):
134 134
135 135 @Throttle(seconds=value)
136 136 def fnThrottled(fn):
137 137 fn()
138 138
139 139 return fnThrottled
140 140
141 141 @MPDecorator
142 142 class Plotter(ProcessingUnit):
143 143 '''
144 144 Proccessing unit to handle plot operations
145 145 '''
146 146
147 147 def __init__(self):
148 148
149 149 ProcessingUnit.__init__(self)
150 150
151 151 def setup(self, **kwargs):
152 152
153 153 self.connections = 0
154 154 self.web_address = kwargs.get('web_server', False)
155 155 self.realtime = kwargs.get('realtime', False)
156 156 self.localtime = kwargs.get('localtime', True)
157 157 self.buffering = kwargs.get('buffering', True)
158 158 self.throttle = kwargs.get('throttle', 2)
159 159 self.exp_code = kwargs.get('exp_code', None)
160 160 self.set_ready = apply_throttle(self.throttle)
161 161 self.dates = []
162 162 self.data = PlotterData(
163 163 self.plots, self.throttle, self.exp_code, self.buffering)
164 164 self.isConfig = True
165 165
166 166 def ready(self):
167 167 '''
168 168 Set dataOut ready
169 169 '''
170 170
171 171 self.data.ready = True
172 172 self.dataOut.data_plt = self.data
173 173
174 174 def run(self, realtime=True, localtime=True, buffering=True,
175 175 throttle=2, exp_code=None, web_server=None):
176 176
177 177 if not self.isConfig:
178 178 self.setup(realtime=realtime, localtime=localtime,
179 179 buffering=buffering, throttle=throttle, exp_code=exp_code,
180 180 web_server=web_server)
181 181
182 182 if self.web_address:
183 183 log.success(
184 184 'Sending to web: {}'.format(self.web_address),
185 185 self.name
186 186 )
187 187 self.context = zmq.Context()
188 188 self.sender_web = self.context.socket(zmq.REQ)
189 189 self.sender_web.connect(self.web_address)
190 190 self.poll = zmq.Poller()
191 191 self.poll.register(self.sender_web, zmq.POLLIN)
192 192 time.sleep(1)
193 193
194 194 # t = Thread(target=self.event_monitor, args=(monitor,))
195 195 # t.start()
196 196
197 197 self.dataOut = self.dataIn
198 198 self.data.ready = False
199 199
200 200 if self.dataOut.flagNoData:
201 201 coerce = True
202 202 else:
203 203 coerce = False
204 204
205 205 if self.dataOut.type == 'Parameters':
206 206 tm = self.dataOut.utctimeInit
207 207 else:
208 208 tm = self.dataOut.utctime
209 209 if self.dataOut.useLocalTime:
210 210 if not self.localtime:
211 211 tm += time.timezone
212 212 dt = datetime.datetime.fromtimestamp(tm).date()
213 213 else:
214 214 if self.localtime:
215 215 tm -= time.timezone
216 216 dt = datetime.datetime.utcfromtimestamp(tm).date()
217 217 if dt not in self.dates:
218 218 if self.data:
219 219 self.ready()
220 220 self.data.setup()
221 221 self.dates.append(dt)
222 222
223 223 self.data.update(self.dataOut, tm)
224 224
225 225 if False: # TODO check when publishers ends
226 226 self.connections -= 1
227 227 if self.connections == 0 and dt in self.dates:
228 228 self.data.ended = True
229 229 self.ready()
230 230 time.sleep(1)
231 231 else:
232 232 if self.realtime:
233 233 self.ready()
234 234 if self.web_address:
235 235 retries = 5
236 236 while True:
237 237 self.sender_web.send(self.data.jsonify())
238 238 socks = dict(self.poll.poll(5000))
239 239 if socks.get(self.sender_web) == zmq.POLLIN:
240 240 reply = self.sender_web.recv_string()
241 241 if reply == 'ok':
242 242 log.log("Response from server ok", self.name)
243 243 break
244 244 else:
245 245 log.warning(
246 246 "Malformed reply from server: {}".format(reply), self.name)
247 247
248 248 else:
249 249 log.warning(
250 250 "No response from server, retrying...", self.name)
251 251 self.sender_web.setsockopt(zmq.LINGER, 0)
252 252 self.sender_web.close()
253 253 self.poll.unregister(self.sender_web)
254 254 retries -= 1
255 255 if retries == 0:
256 256 log.error(
257 257 "Server seems to be offline, abandoning", self.name)
258 258 self.sender_web = self.context.socket(zmq.REQ)
259 259 self.sender_web.connect(self.web_address)
260 260 self.poll.register(self.sender_web, zmq.POLLIN)
261 261 time.sleep(1)
262 262 break
263 263 self.sender_web = self.context.socket(zmq.REQ)
264 264 self.sender_web.connect(self.web_address)
265 265 self.poll.register(self.sender_web, zmq.POLLIN)
266 266 time.sleep(1)
267 267 else:
268 268 self.set_ready(self.ready, coerce=coerce)
269 269
270 270 return
271 271
272 272 def close(self):
273 273 pass
274 274
275 275
276 276 @MPDecorator
277 277 class Plot(Operation):
278 278 '''
279 279 Base class for Schain plotting operations
280 280 '''
281 281
282 282 CODE = 'Figure'
283 283 colormap = 'jro'
284 284 bgcolor = 'white'
285 285 __missing = 1E30
286 286
287 287 __attrs__ = ['show', 'save', 'xmin', 'xmax', 'ymin', 'ymax', 'zmin', 'zmax',
288 288 'zlimits', 'xlabel', 'ylabel', 'xaxis', 'cb_label', 'title',
289 289 'colorbar', 'bgcolor', 'width', 'height', 'localtime', 'oneFigure',
290 290 'showprofile', 'decimation', 'pause']
291 291
292 292 def __init__(self):
293 293
294 294 Operation.__init__(self)
295 295 self.isConfig = False
296 296 self.isPlotConfig = False
297 297
298 298 def __fmtTime(self, x, pos):
299 299 '''
300 300 '''
301 301
302 302 return '{}'.format(self.getDateTime(x).strftime('%H:%M'))
303 303
304 304 def __setup(self, **kwargs):
305 305 '''
306 306 Initialize variables
307 307 '''
308 308
309 309 self.figures = []
310 310 self.axes = []
311 311 self.cb_axes = []
312 312 self.localtime = kwargs.pop('localtime', True)
313 313 self.show = kwargs.get('show', True)
314 314 self.save = kwargs.get('save', False)
315 315 self.ftp = kwargs.get('ftp', False)
316 316 self.colormap = kwargs.get('colormap', self.colormap)
317 317 self.colormap_coh = kwargs.get('colormap_coh', 'jet')
318 318 self.colormap_phase = kwargs.get('colormap_phase', 'RdBu_r')
319 319 self.colormaps = kwargs.get('colormaps', None)
320 320 self.bgcolor = kwargs.get('bgcolor', self.bgcolor)
321 321 self.showprofile = kwargs.get('showprofile', False)
322 322 self.title = kwargs.get('wintitle', self.CODE.upper())
323 323 self.cb_label = kwargs.get('cb_label', None)
324 324 self.cb_labels = kwargs.get('cb_labels', None)
325 325 self.labels = kwargs.get('labels', None)
326 326 self.xaxis = kwargs.get('xaxis', 'frequency')
327 327 self.zmin = kwargs.get('zmin', None)
328 328 self.zmax = kwargs.get('zmax', None)
329 329 self.zlimits = kwargs.get('zlimits', None)
330 330 self.xmin = kwargs.get('xmin', None)
331 331 self.xmax = kwargs.get('xmax', None)
332 332 self.xrange = kwargs.get('xrange', 12)
333 333 self.xscale = kwargs.get('xscale', None)
334 334 self.ymin = kwargs.get('ymin', None)
335 335 self.ymax = kwargs.get('ymax', None)
336 336 self.yscale = kwargs.get('yscale', None)
337 337 self.xlabel = kwargs.get('xlabel', None)
338 338 self.decimation = kwargs.get('decimation', None)
339 339 self.showSNR = kwargs.get('showSNR', False)
340 340 self.oneFigure = kwargs.get('oneFigure', True)
341 341 self.width = kwargs.get('width', None)
342 342 self.height = kwargs.get('height', None)
343 343 self.colorbar = kwargs.get('colorbar', True)
344 344 self.factors = kwargs.get('factors', [1, 1, 1, 1, 1, 1, 1, 1])
345 345 self.channels = kwargs.get('channels', None)
346 346 self.titles = kwargs.get('titles', [])
347 347 self.polar = False
348 348 self.grid = kwargs.get('grid', False)
349 349 self.pause = kwargs.get('pause', False)
350 350 self.save_labels = kwargs.get('save_labels', None)
351 351 self.realtime = kwargs.get('realtime', True)
352 352 self.buffering = kwargs.get('buffering', True)
353 353 self.throttle = kwargs.get('throttle', 2)
354 354 self.exp_code = kwargs.get('exp_code', None)
355 355 self.__throttle_plot = apply_throttle(self.throttle)
356 356 self.data = PlotterData(
357 357 self.CODE, self.throttle, self.exp_code, self.buffering)
358 358
359 359 def __setup_plot(self):
360 360 '''
361 361 Common setup for all figures, here figures and axes are created
362 362 '''
363 363
364 364 self.setup()
365 365
366 366 self.time_label = 'LT' if self.localtime else 'UTC'
367 367 if self.data.localtime:
368 368 self.getDateTime = datetime.datetime.fromtimestamp
369 369 else:
370 370 self.getDateTime = datetime.datetime.utcfromtimestamp
371 371
372 372 if self.width is None:
373 373 self.width = 8
374 374
375 375 self.figures = []
376 376 self.axes = []
377 377 self.cb_axes = []
378 378 self.pf_axes = []
379 379 self.cmaps = []
380 380
381 381 size = '15%' if self.ncols == 1 else '30%'
382 382 pad = '4%' if self.ncols == 1 else '8%'
383 383
384 384 if self.oneFigure:
385 385 if self.height is None:
386 386 self.height = 1.4 * self.nrows + 1
387 387 fig = plt.figure(figsize=(self.width, self.height),
388 388 edgecolor='k',
389 389 facecolor='w')
390 390 self.figures.append(fig)
391 391 for n in range(self.nplots):
392 392 ax = fig.add_subplot(self.nrows, self.ncols,
393 393 n + 1, polar=self.polar)
394 394 ax.tick_params(labelsize=8)
395 395 ax.firsttime = True
396 396 ax.index = 0
397 397 ax.press = None
398 398 self.axes.append(ax)
399 399 if self.showprofile:
400 400 cax = self.__add_axes(ax, size=size, pad=pad)
401 401 cax.tick_params(labelsize=8)
402 402 self.pf_axes.append(cax)
403 403 else:
404 404 if self.height is None:
405 405 self.height = 3
406 406 for n in range(self.nplots):
407 407 fig = plt.figure(figsize=(self.width, self.height),
408 408 edgecolor='k',
409 409 facecolor='w')
410 410 ax = fig.add_subplot(1, 1, 1, polar=self.polar)
411 411 ax.tick_params(labelsize=8)
412 412 ax.firsttime = True
413 413 ax.index = 0
414 414 ax.press = None
415 415 self.figures.append(fig)
416 416 self.axes.append(ax)
417 417 if self.showprofile:
418 418 cax = self.__add_axes(ax, size=size, pad=pad)
419 419 cax.tick_params(labelsize=8)
420 420 self.pf_axes.append(cax)
421 421
422 422 for n in range(self.nrows):
423 423 if self.colormaps is not None:
424 424 cmap = plt.get_cmap(self.colormaps[n])
425 425 else:
426 426 cmap = plt.get_cmap(self.colormap)
427 427 cmap.set_bad(self.bgcolor, 1.)
428 428 self.cmaps.append(cmap)
429 429
430 430 for fig in self.figures:
431 431 fig.canvas.mpl_connect('key_press_event', self.OnKeyPress)
432 432 fig.canvas.mpl_connect('scroll_event', self.OnBtnScroll)
433 433 fig.canvas.mpl_connect('button_press_event', self.onBtnPress)
434 434 fig.canvas.mpl_connect('motion_notify_event', self.onMotion)
435 435 fig.canvas.mpl_connect('button_release_event', self.onBtnRelease)
436 436 if self.show:
437 437 fig.show()
438 438
439 439 def OnKeyPress(self, event):
440 440 '''
441 441 Event for pressing keys (up, down) change colormap
442 442 '''
443 443 ax = event.inaxes
444 444 if ax in self.axes:
445 445 if event.key == 'down':
446 446 ax.index += 1
447 447 elif event.key == 'up':
448 448 ax.index -= 1
449 449 if ax.index < 0:
450 450 ax.index = len(CMAPS) - 1
451 451 elif ax.index == len(CMAPS):
452 452 ax.index = 0
453 453 cmap = CMAPS[ax.index]
454 454 ax.cbar.set_cmap(cmap)
455 455 ax.cbar.draw_all()
456 456 ax.plt.set_cmap(cmap)
457 457 ax.cbar.patch.figure.canvas.draw()
458 458 self.colormap = cmap.name
459 459
460 460 def OnBtnScroll(self, event):
461 461 '''
462 462 Event for scrolling, scale figure
463 463 '''
464 464 cb_ax = event.inaxes
465 465 if cb_ax in [ax.cbar.ax for ax in self.axes if ax.cbar]:
466 466 ax = [ax for ax in self.axes if cb_ax == ax.cbar.ax][0]
467 467 pt = ax.cbar.ax.bbox.get_points()[:, 1]
468 468 nrm = ax.cbar.norm
469 469 vmin, vmax, p0, p1, pS = (
470 470 nrm.vmin, nrm.vmax, pt[0], pt[1], event.y)
471 471 scale = 2 if event.step == 1 else 0.5
472 472 point = vmin + (vmax - vmin) / (p1 - p0) * (pS - p0)
473 473 ax.cbar.norm.vmin = point - scale * (point - vmin)
474 474 ax.cbar.norm.vmax = point - scale * (point - vmax)
475 475 ax.plt.set_norm(ax.cbar.norm)
476 476 ax.cbar.draw_all()
477 477 ax.cbar.patch.figure.canvas.draw()
478 478
479 479 def onBtnPress(self, event):
480 480 '''
481 481 Event for mouse button press
482 482 '''
483 483 cb_ax = event.inaxes
484 484 if cb_ax is None:
485 485 return
486 486
487 487 if cb_ax in [ax.cbar.ax for ax in self.axes if ax.cbar]:
488 488 cb_ax.press = event.x, event.y
489 489 else:
490 490 cb_ax.press = None
491 491
492 492 def onMotion(self, event):
493 493 '''
494 494 Event for move inside colorbar
495 495 '''
496 496 cb_ax = event.inaxes
497 497 if cb_ax is None:
498 498 return
499 499 if cb_ax not in [ax.cbar.ax for ax in self.axes if ax.cbar]:
500 500 return
501 501 if cb_ax.press is None:
502 502 return
503 503
504 504 ax = [ax for ax in self.axes if cb_ax == ax.cbar.ax][0]
505 505 xprev, yprev = cb_ax.press
506 506 dx = event.x - xprev
507 507 dy = event.y - yprev
508 508 cb_ax.press = event.x, event.y
509 509 scale = ax.cbar.norm.vmax - ax.cbar.norm.vmin
510 510 perc = 0.03
511 511
512 512 if event.button == 1:
513 513 ax.cbar.norm.vmin -= (perc * scale) * numpy.sign(dy)
514 514 ax.cbar.norm.vmax -= (perc * scale) * numpy.sign(dy)
515 515 elif event.button == 3:
516 516 ax.cbar.norm.vmin -= (perc * scale) * numpy.sign(dy)
517 517 ax.cbar.norm.vmax += (perc * scale) * numpy.sign(dy)
518 518
519 519 ax.cbar.draw_all()
520 520 ax.plt.set_norm(ax.cbar.norm)
521 521 ax.cbar.patch.figure.canvas.draw()
522 522
523 523 def onBtnRelease(self, event):
524 524 '''
525 525 Event for mouse button release
526 526 '''
527 527 cb_ax = event.inaxes
528 528 if cb_ax is not None:
529 529 cb_ax.press = None
530 530
531 531 def __add_axes(self, ax, size='30%', pad='8%'):
532 532 '''
533 533 Add new axes to the given figure
534 534 '''
535 535 divider = make_axes_locatable(ax)
536 536 nax = divider.new_horizontal(size=size, pad=pad)
537 537 ax.figure.add_axes(nax)
538 538 return nax
539 539
540 540 def setup(self):
541 541 '''
542 542 This method should be implemented in the child class, the following
543 543 attributes should be set:
544 544
545 545 self.nrows: number of rows
546 546 self.ncols: number of cols
547 547 self.nplots: number of plots (channels or pairs)
548 548 self.ylabel: label for Y axes
549 549 self.titles: list of axes title
550 550
551 551 '''
552 552 raise NotImplementedError
553 553
554 554 def fill_gaps(self, x_buffer, y_buffer, z_buffer):
555 555 '''
556 556 Create a masked array for missing data
557 557 '''
558 558 if x_buffer.shape[0] < 2:
559 559 return x_buffer, y_buffer, z_buffer
560 560
561 561 deltas = x_buffer[1:] - x_buffer[0:-1]
562 562 x_median = numpy.median(deltas)
563 563
564 564 index = numpy.where(deltas > 5 * x_median)
565 565
566 566 if len(index[0]) != 0:
567 567 z_buffer[::, index[0], ::] = self.__missing
568 568 z_buffer = numpy.ma.masked_inside(z_buffer,
569 569 0.99 * self.__missing,
570 570 1.01 * self.__missing)
571 571
572 572 return x_buffer, y_buffer, z_buffer
573 573
574 574 def decimate(self):
575 575
576 576 # dx = int(len(self.x)/self.__MAXNUMX) + 1
577 577 dy = int(len(self.y) / self.decimation) + 1
578 578
579 579 # x = self.x[::dx]
580 580 x = self.x
581 581 y = self.y[::dy]
582 582 z = self.z[::, ::, ::dy]
583 583
584 584 return x, y, z
585 585
586 586 def format(self):
587 587 '''
588 588 Set min and max values, labels, ticks and titles
589 589 '''
590 590
591 591 if self.xmin is None:
592 592 xmin = self.data.min_time
593 593 else:
594 594 if self.xaxis is 'time':
595 595 dt = self.getDateTime(self.data.min_time)
596 596 xmin = (dt.replace(hour=int(self.xmin), minute=0, second=0) -
597 597 datetime.datetime(1970, 1, 1)).total_seconds()
598 598 if self.data.localtime:
599 599 xmin += time.timezone
600 600 else:
601 601 xmin = self.xmin
602 602
603 603 if self.xmax is None:
604 604 xmax = xmin + self.xrange * 60 * 60
605 605 else:
606 606 if self.xaxis is 'time':
607 607 dt = self.getDateTime(self.data.max_time)
608 608 xmax = (dt.replace(hour=int(self.xmax), minute=59, second=59) -
609 609 datetime.datetime(1970, 1, 1) + datetime.timedelta(seconds=1)).total_seconds()
610 610 if self.data.localtime:
611 611 xmax += time.timezone
612 612 else:
613 613 xmax = self.xmax
614 614
615 615 ymin = self.ymin if self.ymin else numpy.nanmin(self.y)
616 616 ymax = self.ymax if self.ymax else numpy.nanmax(self.y)
617
618 617 Y = numpy.array([1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000])
619 618 i = 1 if numpy.where(
620 619 abs(ymax-ymin) <= Y)[0][0] < 0 else numpy.where(abs(ymax-ymin) <= Y)[0][0]
621 620 ystep = Y[i] / 10.
622 621
623 622 if self.xaxis is not 'time':
624 X = numpy.array([1, 2, 5, 10, 20, 50, 100,
623 X = numpy.array([0.02, 0.05, 0.1, 0.2, 0.5, 1, 2, 5, 10, 20, 50, 100,
625 624 200, 500, 1000, 2000, 5000])/2.
626 625 i = 1 if numpy.where(
627 626 abs(xmax-xmin) <= X)[0][0] < 0 else numpy.where(abs(xmax-xmin) <= X)[0][0]
628 xstep = X[i] / 10.
627 xstep = X[i] / 5.
629 628
630 629 for n, ax in enumerate(self.axes):
631 630 if ax.firsttime:
632 631 ax.set_facecolor(self.bgcolor)
633 632 ax.yaxis.set_major_locator(MultipleLocator(ystep))
634 633 if self.xscale:
635 634 ax.xaxis.set_major_formatter(FuncFormatter(
636 635 lambda x, pos: '{0:g}'.format(x*self.xscale)))
637 636 if self.xscale:
638 637 ax.yaxis.set_major_formatter(FuncFormatter(
639 638 lambda x, pos: '{0:g}'.format(x*self.yscale)))
640 639 if self.xaxis is 'time':
641 640 ax.xaxis.set_major_formatter(FuncFormatter(self.__fmtTime))
642 641 ax.xaxis.set_major_locator(LinearLocator(9))
643 642 else:
644 643 ax.xaxis.set_major_locator(MultipleLocator(xstep))
645 644 if self.xlabel is not None:
646 645 ax.set_xlabel(self.xlabel)
647 646 ax.set_ylabel(self.ylabel)
648 647 ax.firsttime = False
649 648 if self.showprofile:
650 649 self.pf_axes[n].set_ylim(ymin, ymax)
651 650 self.pf_axes[n].set_xlim(self.zmin, self.zmax)
652 651 self.pf_axes[n].set_xlabel('dB')
653 652 self.pf_axes[n].grid(b=True, axis='x')
654 653 [tick.set_visible(False)
655 654 for tick in self.pf_axes[n].get_yticklabels()]
656 655 if self.colorbar:
657 656 ax.cbar = plt.colorbar(
658 657 ax.plt, ax=ax, fraction=0.05, pad=0.02, aspect=10)
659 658 ax.cbar.ax.tick_params(labelsize=8)
660 659 ax.cbar.ax.press = None
661 660 if self.cb_label:
662 661 ax.cbar.set_label(self.cb_label, size=8)
663 662 elif self.cb_labels:
664 663 ax.cbar.set_label(self.cb_labels[n], size=8)
665 664 else:
666 665 ax.cbar = None
667 666 if self.grid:
668 667 ax.grid(True)
669 668
670 669 if not self.polar:
671 670 ax.set_xlim(xmin, xmax)
672 671 ax.set_ylim(ymin, ymax)
673 672 ax.set_title('{} {} {}'.format(
674 673 self.titles[n],
675 674 self.getDateTime(self.data.max_time).strftime(
676 675 '%Y-%m-%dT%H:%M:%S'),
677 676 self.time_label),
678 677 size=8)
679 678 else:
680 679 ax.set_title('{}'.format(self.titles[n]), size=8)
681 680 ax.set_ylim(0, 90)
682 681 ax.set_yticks(numpy.arange(0, 90, 20))
683 682 ax.yaxis.labelpad = 40
684 683
685 684 def clear_figures(self):
686 685 '''
687 686 Reset axes for redraw plots
688 687 '''
689 688
690 689 for ax in self.axes:
691 690 ax.clear()
692 691 ax.firsttime = True
693 692 if ax.cbar:
694 693 ax.cbar.remove()
695 694
696 695 def __plot(self):
697 696 '''
698 697 Main function to plot, format and save figures
699 698 '''
700 699
701 700 #try:
702 701 self.plot()
703 702 self.format()
704 703 #except Exception as e:
705 704 # log.warning('{} Plot could not be updated... check data'.format(
706 705 # self.CODE), self.name)
707 706 # log.error(str(e), '')
708 707 # return
709 708
710 709 for n, fig in enumerate(self.figures):
711 710 if self.nrows == 0 or self.nplots == 0:
712 711 log.warning('No data', self.name)
713 712 fig.text(0.5, 0.5, 'No Data', fontsize='large', ha='center')
714 713 fig.canvas.manager.set_window_title(self.CODE)
715 714 continue
716 715
717 716 fig.tight_layout()
718 717 fig.canvas.manager.set_window_title('{} - {}'.format(self.title,
719 718 self.getDateTime(self.data.max_time).strftime('%Y/%m/%d')))
720 719 fig.canvas.draw()
721 720
722 721 if self.save:
723 722
724 723 if self.save_labels:
725 724 labels = self.save_labels
726 725 else:
727 726 labels = list(range(self.nrows))
728 727
729 728 if self.oneFigure:
730 729 label = ''
731 730 else:
732 731 label = '-{}'.format(labels[n])
733 732 figname = os.path.join(
734 733 self.save,
735 734 self.CODE,
736 735 '{}{}_{}.png'.format(
737 736 self.CODE,
738 737 label,
739 738 self.getDateTime(self.data.max_time).strftime(
740 739 '%Y%m%d_%H%M%S'),
741 740 )
742 741 )
743 742 log.log('Saving figure: {}'.format(figname), self.name)
744 743 if not os.path.isdir(os.path.dirname(figname)):
745 744 os.makedirs(os.path.dirname(figname))
746 745 fig.savefig(figname)
747 746
748 747 def plot(self):
749 748 '''
750 749 Must be defined in the child class
751 750 '''
752 751 raise NotImplementedError
753 752
754 753 def run(self, dataOut, **kwargs):
755 754
756 755 if dataOut.error:
757 756 coerce = True
758 757 else:
759 758 coerce = False
760 759
761 760 if self.isConfig is False:
762 761 self.__setup(**kwargs)
763 762 self.data.setup()
764 763 self.isConfig = True
765 764
766 765 if dataOut.type == 'Parameters':
767 766 tm = dataOut.utctimeInit
768 767 else:
769 768 tm = dataOut.utctime
770 769
771 770 if dataOut.useLocalTime:
772 771 if not self.localtime:
773 772 tm += time.timezone
774 773 else:
775 774 if self.localtime:
776 775 tm -= time.timezone
777 776
778 777 if self.data and (tm - self.data.min_time) >= self.xrange*60*60:
779 778 self.__plot()
780 779 self.data.setup()
781 780 self.clear_figures()
782 781
783 782 self.data.update(dataOut, tm)
784 783
785 784 if self.isPlotConfig is False:
786 785 self.__setup_plot()
787 786 self.isPlotConfig = True
788 787
789 788 if self.realtime:
790 789 self.__plot()
791 790 else:
792 791 self.__throttle_plot(self.__plot, coerce=coerce)
793 792
794 793 figpause(0.001)
795 794
796 795 def close(self):
797 796
798 797 if self.data and self.pause:
799 798 figpause(10)
800 799
General Comments 0
You need to be logged in to leave comments. Login now