##// END OF EJS Templates
schain
RSS
pause between figures were eliminated
Miguel Valdez -
r631:bddac5bdfb1f
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,622 +1,622
1 1 import os
2 2 import numpy
3 3 import time, datetime
4 4 import mpldriver
5 5
6 6 from schainpy.model.proc.jroproc_base import Operation
7 7
8 8 def isRealtime(utcdatatime):
9 9 utcnow = time.mktime(time.localtime())
10 10 delta = abs(utcnow - utcdatatime) # abs
11 11 if delta >= 30.:
12 12 return False
13 13 return True
14 14
15 15 class Figure(Operation):
16 16
17 17 __driver = mpldriver
18 18 __isConfigThread = False
19 19 fig = None
20 20
21 21 id = None
22 22 wintitle = None
23 23 width = None
24 24 height = None
25 25 nplots = None
26 26 timerange = None
27 27
28 28 axesObjList = []
29 29
30 30 WIDTH = None
31 31 HEIGHT = None
32 32 PREFIX = 'fig'
33 33
34 34 xmin = None
35 35 xmax = None
36 36
37 37 counter_imagwr = 0
38 38
39 39 figfile = None
40 40
41 41 def __init__(self):
42 42
43 43 raise ValueError, "This method is not implemented"
44 44
45 45 def __del__(self):
46 46
47 47 self.__driver.closeFigure()
48 48
49 49 def getFilename(self, name, ext='.png'):
50 50
51 51 path = '%s%03d' %(self.PREFIX, self.id)
52 52 filename = '%s_%s%s' %(self.PREFIX, name, ext)
53 53 return os.path.join(path, filename)
54 54
55 55 def getAxesObjList(self):
56 56
57 57 return self.axesObjList
58 58
59 59 def getSubplots(self):
60 60
61 61 raise ValueError, "Abstract method: This method should be defined"
62 62
63 63 def getScreenDim(self, widthplot, heightplot):
64 64
65 65 nrow, ncol = self.getSubplots()
66 66
67 67 widthscreen = widthplot*ncol
68 68 heightscreen = heightplot*nrow
69 69
70 70 return widthscreen, heightscreen
71 71
72 72 def getTimeLim(self, x, xmin=None, xmax=None, timerange=None):
73 73
74 74 if self.xmin != None and self.xmax != None:
75 75 if timerange == None:
76 76 timerange = self.xmax - self.xmin
77 77 xmin = self.xmin + timerange
78 78 xmax = self.xmax + timerange
79 79
80 80 return xmin, xmax
81 81
82 82 if timerange == None and (xmin==None or xmax==None):
83 83 timerange = 14400 #seconds
84 84 #raise ValueError, "(timerange) or (xmin & xmax) should be defined"
85 85
86 86 if timerange != None:
87 87 txmin = x[0] #- x[0] % min(timerange/10, 10*60)
88 88 else:
89 89 txmin = x[0] #- x[0] % 10*60
90 90
91 91 thisdatetime = datetime.datetime.utcfromtimestamp(txmin)
92 92 thisdate = datetime.datetime.combine(thisdatetime.date(), datetime.time(0,0,0))
93 93
94 94 if timerange != None:
95 95 xmin = (thisdatetime - thisdate).seconds/(60*60.)
96 96 xmax = xmin + timerange/(60*60.)
97 97
98 98 mindt = thisdate + datetime.timedelta(hours=xmin) - datetime.timedelta(seconds=time.timezone)
99 99 xmin_sec = time.mktime(mindt.timetuple())
100 100
101 101 maxdt = thisdate + datetime.timedelta(hours=xmax) - datetime.timedelta(seconds=time.timezone)
102 102 xmax_sec = time.mktime(maxdt.timetuple())
103 103
104 104 return xmin_sec, xmax_sec
105 105
106 106 def init(self, id, nplots, wintitle):
107 107
108 108 raise ValueError, "This method has been replaced with createFigure"
109 109
110 110 def createFigure(self, id, wintitle, widthplot=None, heightplot=None, show=True):
111 111
112 112 """
113 113 Crea la figura de acuerdo al driver y parametros seleccionados seleccionados.
114 114 Las dimensiones de la pantalla es calculada a partir de los atributos self.WIDTH
115 115 y self.HEIGHT y el numero de subplots (nrow, ncol)
116 116
117 117 Input:
118 118 id : Los parametros necesarios son
119 119 wintitle :
120 120
121 121 """
122 122
123 123 if widthplot == None:
124 124 widthplot = self.WIDTH
125 125
126 126 if heightplot == None:
127 127 heightplot = self.HEIGHT
128 128
129 129 self.id = id
130 130
131 131 self.wintitle = wintitle
132 132
133 133 self.widthscreen, self.heightscreen = self.getScreenDim(widthplot, heightplot)
134 134
135 135 self.fig = self.__driver.createFigure(id=self.id,
136 136 wintitle=self.wintitle,
137 137 width=self.widthscreen,
138 138 height=self.heightscreen,
139 139 show=show)
140 140
141 141 self.axesObjList = []
142 142 self.counter_imagwr = 0
143 143
144 144
145 145 def setDriver(self, driver=mpldriver):
146 146
147 147 self.__driver = driver
148 148
149 149 def setTitle(self, title):
150 150
151 151 self.__driver.setTitle(self.fig, title)
152 152
153 153 def setWinTitle(self, title):
154 154
155 155 self.__driver.setWinTitle(self.fig, title=title)
156 156
157 157 def setTextFromAxes(self, text):
158 158
159 159 raise ValueError, "Este metodo ha sido reemplazaado con el metodo setText de la clase Axes"
160 160
161 161 def makeAxes(self, nrow, ncol, xpos, ypos, colspan, rowspan):
162 162
163 163 raise ValueError, "Este metodo ha sido reemplazaado con el metodo addAxes"
164 164
165 165 def addAxes(self, *args):
166 166 """
167 167
168 168 Input:
169 169 *args : Los parametros necesarios son
170 170 nrow, ncol, xpos, ypos, colspan, rowspan
171 171 """
172 172
173 173 axesObj = Axes(self.fig, *args)
174 174 self.axesObjList.append(axesObj)
175 175
176 176 def saveFigure(self, figpath, figfile, *args):
177 177
178 178 filename = os.path.join(figpath, figfile)
179 179
180 180 fullpath = os.path.split(filename)[0]
181 181
182 182 if not os.path.exists(fullpath):
183 183 subpath = os.path.split(fullpath)[0]
184 184
185 185 if not os.path.exists(subpath):
186 186 os.mkdir(subpath)
187 187
188 188 os.mkdir(fullpath)
189 189
190 190 self.__driver.saveFigure(self.fig, filename, *args)
191 191
192 192 def save(self, figpath, figfile=None, save=True, ftp=False, wr_period=1, thisDatetime=None, update_figfile=True):
193 193
194 194 self.counter_imagwr += 1
195 195 if self.counter_imagwr < wr_period:
196 196 return
197 197
198 198 self.counter_imagwr = 0
199 199
200 200 if save:
201 201
202 202 if not figfile:
203 203
204 204 if not thisDatetime:
205 205 raise ValueError, "Saving figure: figfile or thisDatetime should be defined"
206 206 return
207 207
208 208 str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
209 209 figfile = self.getFilename(name = str_datetime)
210 210
211 211 if self.figfile == None:
212 212 self.figfile = figfile
213 213
214 214 if update_figfile:
215 215 self.figfile = figfile
216 216
217 217 # store png plot to local folder
218 218 self.saveFigure(figpath, self.figfile)
219 219
220 220
221 221 if not ftp:
222 222 return
223 223
224 224 if not thisDatetime:
225 225 return
226 226
227 227 # store png plot to FTP server according to RT-Web format
228 228 ftp_filename = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS)
229 229 # ftp_filename = os.path.join(figpath, name)
230 230 self.saveFigure(figpath, ftp_filename)
231 231
232 232 def getNameToFtp(self, thisDatetime, FTP_WEI, EXP_CODE, SUB_EXP_CODE, PLOT_CODE, PLOT_POS):
233 233 YEAR_STR = '%4.4d'%thisDatetime.timetuple().tm_year
234 234 DOY_STR = '%3.3d'%thisDatetime.timetuple().tm_yday
235 235 FTP_WEI = '%2.2d'%FTP_WEI
236 236 EXP_CODE = '%3.3d'%EXP_CODE
237 237 SUB_EXP_CODE = '%2.2d'%SUB_EXP_CODE
238 238 PLOT_CODE = '%2.2d'%PLOT_CODE
239 239 PLOT_POS = '%2.2d'%PLOT_POS
240 240 name = YEAR_STR + DOY_STR + FTP_WEI + EXP_CODE + SUB_EXP_CODE + PLOT_CODE + PLOT_POS
241 241 return name
242 242
243 243 def draw(self):
244 244
245 245 self.__driver.draw(self.fig)
246 246
247 247 def run(self):
248 248
249 249 raise ValueError, "This method is not implemented"
250 250
251 251 def close(self, show=False):
252 252
253 253 self.__driver.closeFigure(show=show, fig=self.fig)
254 254
255 255 axesList = property(getAxesObjList)
256 256
257 257
258 258 class Axes:
259 259
260 260 __driver = mpldriver
261 261 fig = None
262 262 ax = None
263 263 plot = None
264 264 __missing = 1E30
265 265 __firsttime = None
266 266
267 267 __showprofile = False
268 268
269 269 xmin = None
270 270 xmax = None
271 271 ymin = None
272 272 ymax = None
273 273 zmin = None
274 274 zmax = None
275 275
276 276 x_buffer = None
277 277 z_buffer = None
278 278
279 279 decimationx = None
280 280 decimationy = None
281 281
282 282 __MAXNUMX = 300
283 283 __MAXNUMY = 150
284 284
285 285 def __init__(self, *args):
286 286
287 287 """
288 288
289 289 Input:
290 290 *args : Los parametros necesarios son
291 291 fig, nrow, ncol, xpos, ypos, colspan, rowspan
292 292 """
293 293
294 294 ax = self.__driver.createAxes(*args)
295 295 self.fig = args[0]
296 296 self.ax = ax
297 297 self.plot = None
298 298
299 299 self.__firsttime = True
300 300 self.idlineList = []
301 301
302 302 self.x_buffer = numpy.array([])
303 303 self.z_buffer = numpy.array([])
304 304
305 305 def setText(self, text):
306 306
307 307 self.__driver.setAxesText(self.ax, text)
308 308
309 309 def setXAxisAsTime(self):
310 310 pass
311 311
312 312 def pline(self, x, y,
313 313 xmin=None, xmax=None,
314 314 ymin=None, ymax=None,
315 315 xlabel='', ylabel='',
316 316 title='',
317 317 **kwargs):
318 318
319 319 """
320 320
321 321 Input:
322 322 x :
323 323 y :
324 324 xmin :
325 325 xmax :
326 326 ymin :
327 327 ymax :
328 328 xlabel :
329 329 ylabel :
330 330 title :
331 331 **kwargs : Los parametros aceptados son
332 332
333 333 ticksize
334 334 ytick_visible
335 335 """
336 336
337 337 if self.__firsttime:
338 338
339 339 if xmin == None: xmin = numpy.nanmin(x)
340 340 if xmax == None: xmax = numpy.nanmax(x)
341 341 if ymin == None: ymin = numpy.nanmin(y)
342 342 if ymax == None: ymax = numpy.nanmax(y)
343 343
344 344 self.plot = self.__driver.createPline(self.ax, x, y,
345 345 xmin, xmax,
346 346 ymin, ymax,
347 347 xlabel=xlabel,
348 348 ylabel=ylabel,
349 349 title=title,
350 350 **kwargs)
351 351
352 352 self.idlineList.append(0)
353 353 self.__firsttime = False
354 354 return
355 355
356 356 self.__driver.pline(self.plot, x, y, xlabel=xlabel,
357 357 ylabel=ylabel,
358 358 title=title)
359 359
360 self.__driver.pause()
360 # self.__driver.pause()
361 361
362 362 def addpline(self, x, y, idline, **kwargs):
363 363 lines = self.ax.lines
364 364
365 365 if idline in self.idlineList:
366 366 self.__driver.set_linedata(self.ax, x, y, idline)
367 367
368 368 if idline not in(self.idlineList):
369 369 self.__driver.addpline(self.ax, x, y, **kwargs)
370 370 self.idlineList.append(idline)
371 371
372 372 return
373 373
374 374 def pmultiline(self, x, y,
375 375 xmin=None, xmax=None,
376 376 ymin=None, ymax=None,
377 377 xlabel='', ylabel='',
378 378 title='',
379 379 **kwargs):
380 380
381 381 if self.__firsttime:
382 382
383 383 if xmin == None: xmin = numpy.nanmin(x)
384 384 if xmax == None: xmax = numpy.nanmax(x)
385 385 if ymin == None: ymin = numpy.nanmin(y)
386 386 if ymax == None: ymax = numpy.nanmax(y)
387 387
388 388 self.plot = self.__driver.createPmultiline(self.ax, x, y,
389 389 xmin, xmax,
390 390 ymin, ymax,
391 391 xlabel=xlabel,
392 392 ylabel=ylabel,
393 393 title=title,
394 394 **kwargs)
395 395 self.__firsttime = False
396 396 return
397 397
398 398 self.__driver.pmultiline(self.plot, x, y, xlabel=xlabel,
399 399 ylabel=ylabel,
400 400 title=title)
401 401
402 self.__driver.pause()
402 # self.__driver.pause()
403 403
404 404 def pmultilineyaxis(self, x, y,
405 405 xmin=None, xmax=None,
406 406 ymin=None, ymax=None,
407 407 xlabel='', ylabel='',
408 408 title='',
409 409 **kwargs):
410 410
411 411 if self.__firsttime:
412 412
413 413 if xmin == None: xmin = numpy.nanmin(x)
414 414 if xmax == None: xmax = numpy.nanmax(x)
415 415 if ymin == None: ymin = numpy.nanmin(y)
416 416 if ymax == None: ymax = numpy.nanmax(y)
417 417
418 418 self.plot = self.__driver.createPmultilineYAxis(self.ax, x, y,
419 419 xmin, xmax,
420 420 ymin, ymax,
421 421 xlabel=xlabel,
422 422 ylabel=ylabel,
423 423 title=title,
424 424 **kwargs)
425 425 if self.xmin == None: self.xmin = xmin
426 426 if self.xmax == None: self.xmax = xmax
427 427 if self.ymin == None: self.ymin = ymin
428 428 if self.ymax == None: self.ymax = ymax
429 429
430 430 self.__firsttime = False
431 431 return
432 432
433 433 self.__driver.pmultilineyaxis(self.plot, x, y, xlabel=xlabel,
434 434 ylabel=ylabel,
435 435 title=title)
436 436
437 self.__driver.pause()
437 # self.__driver.pause()
438 438
439 439 def pcolor(self, x, y, z,
440 440 xmin=None, xmax=None,
441 441 ymin=None, ymax=None,
442 442 zmin=None, zmax=None,
443 443 xlabel='', ylabel='',
444 444 title='', rti = False, colormap='jet',
445 445 **kwargs):
446 446
447 447 """
448 448 Input:
449 449 x :
450 450 y :
451 451 x :
452 452 xmin :
453 453 xmax :
454 454 ymin :
455 455 ymax :
456 456 zmin :
457 457 zmax :
458 458 xlabel :
459 459 ylabel :
460 460 title :
461 461 **kwargs : Los parametros aceptados son
462 462 ticksize=9,
463 463 cblabel=''
464 464 rti = True or False
465 465 """
466 466
467 467 if self.__firsttime:
468 468
469 469 if xmin == None: xmin = numpy.nanmin(x)
470 470 if xmax == None: xmax = numpy.nanmax(x)
471 471 if ymin == None: ymin = numpy.nanmin(y)
472 472 if ymax == None: ymax = numpy.nanmax(y)
473 473 if zmin == None: zmin = numpy.nanmin(z)
474 474 if zmax == None: zmax = numpy.nanmax(z)
475 475
476 476
477 477 self.plot = self.__driver.createPcolor(self.ax, x, y, z,
478 478 xmin, xmax,
479 479 ymin, ymax,
480 480 zmin, zmax,
481 481 xlabel=xlabel,
482 482 ylabel=ylabel,
483 483 title=title,
484 484 colormap=colormap,
485 485 **kwargs)
486 486
487 487 if self.xmin == None: self.xmin = xmin
488 488 if self.xmax == None: self.xmax = xmax
489 489 if self.ymin == None: self.ymin = ymin
490 490 if self.ymax == None: self.ymax = ymax
491 491 if self.zmin == None: self.zmin = zmin
492 492 if self.zmax == None: self.zmax = zmax
493 493
494 494 self.__firsttime = False
495 495 return
496 496
497 497 if rti:
498 498 self.__driver.addpcolor(self.ax, x, y, z, self.zmin, self.zmax,
499 499 xlabel=xlabel,
500 500 ylabel=ylabel,
501 501 title=title,
502 502 colormap=colormap)
503 503 return
504 504
505 505 self.__driver.pcolor(self.plot, z,
506 506 xlabel=xlabel,
507 507 ylabel=ylabel,
508 508 title=title)
509 509
510 self.__driver.pause()
510 # self.__driver.pause()
511 511
512 512 def pcolorbuffer(self, x, y, z,
513 513 xmin=None, xmax=None,
514 514 ymin=None, ymax=None,
515 515 zmin=None, zmax=None,
516 516 xlabel='', ylabel='',
517 517 title='', rti = True, colormap='jet',
518 518 maxNumX = None, maxNumY = None,
519 519 **kwargs):
520 520
521 521 if maxNumX == None:
522 522 maxNumX = self.__MAXNUMX
523 523
524 524 if maxNumY == None:
525 525 maxNumY = self.__MAXNUMY
526 526
527 527 if self.__firsttime:
528 528 self.z_buffer = z
529 529 self.x_buffer = numpy.hstack((self.x_buffer, x))
530 530
531 531 if xmin == None: xmin = numpy.nanmin(x)
532 532 if xmax == None: xmax = numpy.nanmax(x)
533 533 if ymin == None: ymin = numpy.nanmin(y)
534 534 if ymax == None: ymax = numpy.nanmax(y)
535 535 if zmin == None: zmin = numpy.nanmin(z)
536 536 if zmax == None: zmax = numpy.nanmax(z)
537 537
538 538
539 539 self.plot = self.__driver.createPcolor(self.ax, self.x_buffer, y, z,
540 540 xmin, xmax,
541 541 ymin, ymax,
542 542 zmin, zmax,
543 543 xlabel=xlabel,
544 544 ylabel=ylabel,
545 545 title=title,
546 546 colormap=colormap,
547 547 **kwargs)
548 548
549 549 if self.xmin == None: self.xmin = xmin
550 550 if self.xmax == None: self.xmax = xmax
551 551 if self.ymin == None: self.ymin = ymin
552 552 if self.ymax == None: self.ymax = ymax
553 553 if self.zmin == None: self.zmin = zmin
554 554 if self.zmax == None: self.zmax = zmax
555 555
556 556 self.__firsttime = False
557 557 return
558 558
559 559 self.x_buffer = numpy.hstack((self.x_buffer, x[-1]))
560 560 self.z_buffer = numpy.hstack((self.z_buffer, z))
561 561
562 562 if self.decimationx == None:
563 563 deltax = float(self.xmax - self.xmin)/maxNumX
564 564 deltay = float(self.ymax - self.ymin)/maxNumY
565 565
566 566 resolutionx = self.x_buffer[2]-self.x_buffer[0]
567 567 resolutiony = y[1]-y[0]
568 568
569 569 self.decimationx = numpy.ceil(deltax / resolutionx)
570 570 self.decimationy = numpy.ceil(deltay / resolutiony)
571 571
572 572 z_buffer = self.z_buffer.reshape(-1,len(y))
573 573
574 574 x_buffer = self.x_buffer[::self.decimationx]
575 575 y_buffer = y[::self.decimationy]
576 576 z_buffer = z_buffer[::self.decimationx, ::self.decimationy]
577 577 #===================================================
578 578
579 579 x_buffer, y_buffer, z_buffer = self.__fillGaps(x_buffer, y_buffer, z_buffer)
580 580
581 581 self.__driver.addpcolorbuffer(self.ax, x_buffer, y_buffer, z_buffer, self.zmin, self.zmax,
582 582 xlabel=xlabel,
583 583 ylabel=ylabel,
584 584 title=title,
585 585 colormap=colormap)
586 586
587 self.__driver.pause()
587 # self.__driver.pause()
588 588
589 589 def polar(self, x, y,
590 590 title='', xlabel='',ylabel='',**kwargs):
591 591
592 592 if self.__firsttime:
593 593 self.plot = self.__driver.createPolar(self.ax, x, y, title = title, xlabel = xlabel, ylabel = ylabel)
594 594 self.__firsttime = False
595 595 self.x_buffer = x
596 596 self.y_buffer = y
597 597 return
598 598
599 599 self.x_buffer = numpy.hstack((self.x_buffer,x))
600 600 self.y_buffer = numpy.hstack((self.y_buffer,y))
601 601 self.__driver.polar(self.plot, self.x_buffer, self.y_buffer, xlabel=xlabel,
602 602 ylabel=ylabel,
603 603 title=title)
604 604
605 self.__driver.pause()
605 # self.__driver.pause()
606 606
607 607 def __fillGaps(self, x_buffer, y_buffer, z_buffer):
608 608
609 609 deltas = x_buffer[1:] - x_buffer[0:-1]
610 610 x_median = numpy.median(deltas)
611 611
612 612 index = numpy.where(deltas >= 2*x_median)
613 613
614 614 if len(index[0]) != 0:
615 615 z_buffer[index[0],::] = self.__missing
616 616 z_buffer = numpy.ma.masked_inside(z_buffer,0.99*self.__missing,1.01*self.__missing)
617 617
618 618 return x_buffer, y_buffer, z_buffer
619 619
620 620
621 621
622 622 No newline at end of file
General Comments 0
You need to be logged in to leave comments. Login now