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