##// END OF EJS Templates
schain
RSS
Optimizacion de graficos con buffer, el buffer se crea en la clase Axes del modulo figure.py, se agrega el metodo pcolorbuffer....
Daniel Valdez -
r318:2312df9eac7d
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,414 +1,491
1 1 import os
2 2 import numpy
3 3 import time, datetime
4 4 import mpldriver
5 5 from customftp import *
6 6
7 7 class Figure:
8 8
9 9 __driver = mpldriver
10 10 fig = None
11 11
12 12 idfigure = None
13 13 wintitle = None
14 14 width = None
15 15 height = None
16 16 nplots = None
17 17 timerange = None
18 18
19 19 axesObjList = []
20 20
21 21 WIDTH = None
22 22 HEIGHT = None
23 23 PREFIX = 'fig'
24 24
25 25 def __init__(self):
26 26
27 27 raise ValueError, "This method is not implemented"
28 28
29 29 def __del__(self):
30 30
31 31 self.__driver.closeFigure()
32 32
33 33 def getFilename(self, name, ext='.png'):
34 34
35 35 path = '%s%03d' %(self.PREFIX, self.idfigure)
36 36 filename = '%s_%s%s' %(self.PREFIX, name, ext)
37 37
38 38 return os.path.join(path, filename)
39 39
40 40 def getAxesObjList(self):
41 41
42 42 return self.axesObjList
43 43
44 44 def getSubplots(self):
45 45
46 46 raise ValueError, "Abstract method: This method should be defined"
47 47
48 48 def getScreenDim(self, widthplot, heightplot):
49 49
50 50 nrow, ncol = self.getSubplots()
51 51
52 52 widthscreen = widthplot*ncol
53 53 heightscreen = heightplot*nrow
54 54
55 55 return widthscreen, heightscreen
56 56
57 57 def getTimeLim(self, x, xmin, xmax):
58 58
59 59 thisdatetime = datetime.datetime.utcfromtimestamp(numpy.min(x))
60 60 thisdate = datetime.datetime.combine(thisdatetime.date(), datetime.time(0,0,0))
61 61
62 62 ####################################################
63 63 #If the x is out of xrange
64 64 if xmax < (thisdatetime - thisdate).seconds/(60*60.):
65 65 xmin = None
66 66 xmax = None
67 67
68 68 if xmin == None:
69 69 td = thisdatetime - thisdate
70 70 xmin = td.seconds/(60*60.)
71 71
72 72 if xmax == None:
73 73 xmax = xmin + self.timerange/(60*60.)
74 74
75 75 mindt = thisdate + datetime.timedelta(hours=xmin) - datetime.timedelta(seconds=time.timezone)
76 76 tmin = time.mktime(mindt.timetuple())
77 77
78 78 maxdt = thisdate + datetime.timedelta(hours=xmax) - datetime.timedelta(seconds=time.timezone)
79 79 tmax = time.mktime(maxdt.timetuple())
80 80
81 81 self.timerange = tmax - tmin
82 82
83 83 return tmin, tmax
84 84
85 85 def init(self, idfigure, nplots, wintitle):
86 86
87 87 raise ValueError, "This method has been replaced with createFigure"
88 88
89 89 def createFigure(self, idfigure, wintitle, widthplot=None, heightplot=None):
90 90
91 91 """
92 92 Crea la figura de acuerdo al driver y parametros seleccionados seleccionados.
93 93 Las dimensiones de la pantalla es calculada a partir de los atributos self.WIDTH
94 94 y self.HEIGHT y el numero de subplots (nrow, ncol)
95 95
96 96 Input:
97 97 idfigure : Los parametros necesarios son
98 98 wintitle :
99 99
100 100 """
101 101
102 102 if widthplot == None:
103 103 widthplot = self.WIDTH
104 104
105 105 if heightplot == None:
106 106 heightplot = self.HEIGHT
107 107
108 108 self.idfigure = idfigure
109 109
110 110 self.wintitle = wintitle
111 111
112 112 self.widthscreen, self.heightscreen = self.getScreenDim(widthplot, heightplot)
113 113
114 114 self.fig = self.__driver.createFigure(self.idfigure,
115 115 self.wintitle,
116 116 self.widthscreen,
117 117 self.heightscreen)
118 118
119 119 self.axesObjList = []
120 120
121 121
122 122 def setDriver(self, driver=mpldriver):
123 123
124 124 self.__driver = driver
125 125
126 126 def setTitle(self, title):
127 127
128 128 self.__driver.setTitle(self.fig, title)
129 129
130 130 def setWinTitle(self, title):
131 131
132 132 self.__driver.setWinTitle(self.fig, title=title)
133 133
134 134 def setTextFromAxes(self, text):
135 135
136 136 raise ValueError, "Este metodo ha sido reemplazaado con el metodo setText de la clase Axes"
137 137
138 138 def makeAxes(self, nrow, ncol, xpos, ypos, colspan, rowspan):
139 139
140 140 raise ValueError, "Este metodo ha sido reemplazaado con el metodo addAxes"
141 141
142 142 def addAxes(self, *args):
143 143 """
144 144
145 145 Input:
146 146 *args : Los parametros necesarios son
147 147 nrow, ncol, xpos, ypos, colspan, rowspan
148 148 """
149 149
150 150 axesObj = Axes(self.fig, *args)
151 151 self.axesObjList.append(axesObj)
152 152
153 153 def saveFigure(self, figpath, figfile, *args):
154 154
155 155 filename = os.path.join(figpath, figfile)
156 156
157 157 fullpath = os.path.split(filename)[0]
158 158
159 159 if not os.path.exists(fullpath):
160 160 os.mkdir(fullpath)
161 161
162 162 self.__driver.saveFigure(self.fig, filename, *args)
163 163
164 164 def sendByFTP(self, figfilename):
165 165 ftpObj = Ftp()
166 166 ftpObj.upload(figfilename)
167 167 ftpObj.close()
168 168
169 169 def draw(self):
170 170
171 171 self.__driver.draw(self.fig)
172 172
173 173 def run(self):
174 174
175 175 raise ValueError, "This method is not implemented"
176 176
177 177 axesList = property(getAxesObjList)
178 178
179 179
180 180 class Axes:
181 181
182 182 __driver = mpldriver
183 183 fig = None
184 184 ax = None
185 185 plot = None
186
186 __missing = 1E30
187 187 __firsttime = None
188 188
189 189 __showprofile = False
190 190
191 191 xmin = None
192 192 xmax = None
193 193 ymin = None
194 194 ymax = None
195 195 zmin = None
196 196 zmax = None
197 197
198 x_buffer = None
199 z_buffer = None
200
198 201 def __init__(self, *args):
199 202
200 203 """
201 204
202 205 Input:
203 206 *args : Los parametros necesarios son
204 207 fig, nrow, ncol, xpos, ypos, colspan, rowspan
205 208 """
206 209
207 210 ax = self.__driver.createAxes(*args)
208 211 self.fig = args[0]
209 212 self.ax = ax
210 213 self.plot = None
211 214
212 215 self.__firsttime = True
213 216 self.idlineList = []
214 217
218 self.x_buffer = numpy.array([])
219 self.z_buffer = numpy.array([])
220
215 221 def setText(self, text):
216 222
217 223 self.__driver.setAxesText(self.ax, text)
218 224
219 225 def setXAxisAsTime(self):
220 226 pass
221 227
222 228 def pline(self, x, y,
223 229 xmin=None, xmax=None,
224 230 ymin=None, ymax=None,
225 231 xlabel='', ylabel='',
226 232 title='',
227 233 **kwargs):
228 234
229 235 """
230 236
231 237 Input:
232 238 x :
233 239 y :
234 240 xmin :
235 241 xmax :
236 242 ymin :
237 243 ymax :
238 244 xlabel :
239 245 ylabel :
240 246 title :
241 247 **kwargs : Los parametros aceptados son
242 248
243 249 ticksize
244 250 ytick_visible
245 251 """
246 252
247 253 if self.__firsttime:
248 254
249 255 if xmin == None: xmin = numpy.nanmin(x)
250 256 if xmax == None: xmax = numpy.nanmax(x)
251 257 if ymin == None: ymin = numpy.nanmin(y)
252 258 if ymax == None: ymax = numpy.nanmax(y)
253 259
254 260 self.plot = self.__driver.createPline(self.ax, x, y,
255 261 xmin, xmax,
256 262 ymin, ymax,
257 263 xlabel=xlabel,
258 264 ylabel=ylabel,
259 265 title=title,
260 266 **kwargs)
261 267
262 268 self.idlineList.append(0)
263 269 self.__firsttime = False
264 270 return
265 271
266 272 self.__driver.pline(self.plot, x, y, xlabel=xlabel,
267 273 ylabel=ylabel,
268 274 title=title)
269 275
270 276 def addpline(self, x, y, idline, **kwargs):
271 277 lines = self.ax.lines
272 278
273 279 if idline in self.idlineList:
274 280 self.__driver.set_linedata(self.ax, x, y, idline)
275 281
276 282 if idline not in(self.idlineList):
277 283 self.__driver.addpline(self.ax, x, y, **kwargs)
278 284 self.idlineList.append(idline)
279 285
280 286 return
281 287
282 288 def pmultiline(self, x, y,
283 289 xmin=None, xmax=None,
284 290 ymin=None, ymax=None,
285 291 xlabel='', ylabel='',
286 292 title='',
287 293 **kwargs):
288 294
289 295 if self.__firsttime:
290 296
291 297 if xmin == None: xmin = numpy.nanmin(x)
292 298 if xmax == None: xmax = numpy.nanmax(x)
293 299 if ymin == None: ymin = numpy.nanmin(y)
294 300 if ymax == None: ymax = numpy.nanmax(y)
295 301
296 302 self.plot = self.__driver.createPmultiline(self.ax, x, y,
297 303 xmin, xmax,
298 304 ymin, ymax,
299 305 xlabel=xlabel,
300 306 ylabel=ylabel,
301 307 title=title,
302 308 **kwargs)
303 309 self.__firsttime = False
304 310 return
305 311
306 312 self.__driver.pmultiline(self.plot, x, y, xlabel=xlabel,
307 313 ylabel=ylabel,
308 314 title=title)
309 315
310 316 def pmultilineyaxis(self, x, y,
311 317 xmin=None, xmax=None,
312 318 ymin=None, ymax=None,
313 319 xlabel='', ylabel='',
314 320 title='',
315 321 **kwargs):
316 322
317 323 if self.__firsttime:
318 324
319 325 if xmin == None: xmin = numpy.nanmin(x)
320 326 if xmax == None: xmax = numpy.nanmax(x)
321 327 if ymin == None: ymin = numpy.nanmin(y)
322 328 if ymax == None: ymax = numpy.nanmax(y)
323 329
324 330 self.plot = self.__driver.createPmultilineYAxis(self.ax, x, y,
325 331 xmin, xmax,
326 332 ymin, ymax,
327 333 xlabel=xlabel,
328 334 ylabel=ylabel,
329 335 title=title,
330 336 **kwargs)
331 337 if self.xmin == None: self.xmin = xmin
332 338 if self.xmax == None: self.xmax = xmax
333 339 if self.ymin == None: self.ymin = ymin
334 340 if self.ymax == None: self.ymax = ymax
335 341
336 342 self.__firsttime = False
337 343 return
338 344
339 345 self.__driver.pmultilineyaxis(self.plot, x, y, xlabel=xlabel,
340 346 ylabel=ylabel,
341 347 title=title)
342 348
343 349 def pcolor(self, x, y, z,
344 350 xmin=None, xmax=None,
345 351 ymin=None, ymax=None,
346 352 zmin=None, zmax=None,
347 353 xlabel='', ylabel='',
348 354 title='', rti = False, colormap='jet',
349 355 **kwargs):
350 356
351 357 """
352 358 Input:
353 359 x :
354 360 y :
355 361 x :
356 362 xmin :
357 363 xmax :
358 364 ymin :
359 365 ymax :
360 366 zmin :
361 367 zmax :
362 368 xlabel :
363 369 ylabel :
364 370 title :
365 371 **kwargs : Los parametros aceptados son
366 372 ticksize=9,
367 373 cblabel=''
368 374 rti = True or False
369 375 """
370 376
371 377 if self.__firsttime:
372 378
373 379 if xmin == None: xmin = numpy.nanmin(x)
374 380 if xmax == None: xmax = numpy.nanmax(x)
375 381 if ymin == None: ymin = numpy.nanmin(y)
376 382 if ymax == None: ymax = numpy.nanmax(y)
377 383 if zmin == None: zmin = numpy.nanmin(z)
378 384 if zmax == None: zmax = numpy.nanmax(z)
379 385
380 386
381 387 self.plot = self.__driver.createPcolor(self.ax, x, y, z,
382 388 xmin, xmax,
383 389 ymin, ymax,
384 390 zmin, zmax,
385 391 xlabel=xlabel,
386 392 ylabel=ylabel,
387 393 title=title,
388 394 colormap=colormap,
389 395 **kwargs)
390 396
391 397 if self.xmin == None: self.xmin = xmin
392 398 if self.xmax == None: self.xmax = xmax
393 399 if self.ymin == None: self.ymin = ymin
394 400 if self.ymax == None: self.ymax = ymax
395 401 if self.zmin == None: self.zmin = zmin
396 402 if self.zmax == None: self.zmax = zmax
397 403
398 404 self.__firsttime = False
399 405 return
400 406
401 407 if rti:
402 408 self.__driver.addpcolor(self.ax, x, y, z, self.zmin, self.zmax,
403 409 xlabel=xlabel,
404 410 ylabel=ylabel,
405 411 title=title,
406 412 colormap=colormap)
407 413 return
408 414
409 415 self.__driver.pcolor(self.plot, z,
410 416 xlabel=xlabel,
411 417 ylabel=ylabel,
412 418 title=title)
413 419
420 def pcolorbuffer(self, x, y, z,
421 xmin=None, xmax=None,
422 ymin=None, ymax=None,
423 zmin=None, zmax=None,
424 xlabel='', ylabel='',
425 title='', rti = False, colormap='jet',
426 **kwargs):
427
428
429 if self.__firsttime:
430 self.z_buffer = z
431 self.x_buffer = numpy.hstack((self.x_buffer, x))
432
433 if xmin == None: xmin = numpy.nanmin(x)
434 if xmax == None: xmax = numpy.nanmax(x)
435 if ymin == None: ymin = numpy.nanmin(y)
436 if ymax == None: ymax = numpy.nanmax(y)
437 if zmin == None: zmin = numpy.nanmin(z)
438 if zmax == None: zmax = numpy.nanmax(z)
439
440
441 self.plot = self.__driver.createPcolor(self.ax, self.x_buffer, y, z,
442 xmin, xmax,
443 ymin, ymax,
444 zmin, zmax,
445 xlabel=xlabel,
446 ylabel=ylabel,
447 title=title,
448 colormap=colormap,
449 **kwargs)
450
451 if self.xmin == None: self.xmin = xmin
452 if self.xmax == None: self.xmax = xmax
453 if self.ymin == None: self.ymin = ymin
454 if self.ymax == None: self.ymax = ymax
455 if self.zmin == None: self.zmin = zmin
456 if self.zmax == None: self.zmax = zmax
457
458 self.__firsttime = False
459 return
460
461 if rti:
462 if x[0]>self.x_buffer[-1]:
463 gap = z.copy()
464 gap[:] = self.__missing
465 self.z_buffer = numpy.hstack((self.z_buffer, gap))
466 self.z_buffer = numpy.ma.masked_inside(self.z_buffer,0.99*self.__missing,1.01*self.__missing)
467 self.x_buffer = numpy.hstack((self.x_buffer, x))
468
469 else:
470 self.x_buffer = numpy.hstack((self.x_buffer, x[-1]))
471
472 self.z_buffer = numpy.hstack((self.z_buffer, z))
473
474 newydim = len(y)
475
476 # self.z_buffer = numpy.ma.masked_inside(self.z_buffer,0.99*self.__missing,1.01*self.__missing)
477
478 z_buffer = self.z_buffer.reshape(-1,newydim)
479
480 self.__driver.addpcolorbuffer(self.ax, self.x_buffer, y, z_buffer, self.zmin, self.zmax,
481 xlabel=xlabel,
482 ylabel=ylabel,
483 title=title,
484 colormap=colormap)
485 return
486
487 self.__driver.pcolor(self.plot, z,
488 xlabel=xlabel,
489 ylabel=ylabel,
490 title=title)
414 491 No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,373 +1,379
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("TKAgg")
11 11
12 12 import matplotlib.pyplot
13 13
14 14 from mpl_toolkits.axes_grid1 import make_axes_locatable
15 15 from matplotlib.ticker import *
16 16
17 17 ###########################################
18 18 #Actualizacion de las funciones del driver
19 19 ###########################################
20 20
21 21 def createFigure(idfigure, wintitle, width, height, facecolor="w"):
22 22
23 23 matplotlib.pyplot.ioff()
24 24 fig = matplotlib.pyplot.figure(num=idfigure, 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 matplotlib.pyplot.show()
29 29
30 30 return fig
31 31
32 32 def closeFigure():
33 33
34 34 matplotlib.pyplot.ioff()
35 35 matplotlib.pyplot.show()
36 36
37 37 return
38 38
39 39 def saveFigure(fig, filename):
40 40
41 41 matplotlib.pyplot.ioff()
42 42 fig.savefig(filename)
43 43 matplotlib.pyplot.ion()
44 44
45 45 def setWinTitle(fig, title):
46 46
47 47 fig.canvas.manager.set_window_title(title)
48 48
49 49 def setTitle(fig, title):
50 50
51 51 fig.suptitle(title)
52 52
53 53 def createAxes(fig, nrow, ncol, xpos, ypos, colspan, rowspan):
54 54
55 55 matplotlib.pyplot.ioff()
56 56 matplotlib.pyplot.figure(fig.number)
57 57 axes = matplotlib.pyplot.subplot2grid((nrow, ncol),
58 58 (xpos, ypos),
59 59 colspan=colspan,
60 60 rowspan=rowspan)
61 61
62 62 matplotlib.pyplot.ion()
63 63 return axes
64 64
65 65 def setAxesText(ax, text):
66 66
67 67 ax.annotate(text,
68 68 xy = (.1, .99),
69 69 xycoords = 'figure fraction',
70 70 horizontalalignment = 'left',
71 71 verticalalignment = 'top',
72 72 fontsize = 10)
73 73
74 74 def printLabels(ax, xlabel, ylabel, title):
75 75
76 76 ax.set_xlabel(xlabel, size=11)
77 77 ax.set_ylabel(ylabel, size=11)
78 78 ax.set_title(title, size=12)
79 79
80 80 def createPline(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', title='',
81 81 ticksize=9, xtick_visible=True, ytick_visible=True,
82 82 nxticks=4, nyticks=10,
83 83 grid=None):
84 84
85 85 """
86 86
87 87 Input:
88 88 grid : None, 'both', 'x', 'y'
89 89 """
90 90
91 91 matplotlib.pyplot.ioff()
92 92
93 93 ax.set_xlim([xmin,xmax])
94 94 ax.set_ylim([ymin,ymax])
95 95
96 96 printLabels(ax, xlabel, ylabel, title)
97 97
98 98 ######################################################
99 99 if (xmax-xmin)<=1:
100 100 xtickspos = numpy.linspace(xmin,xmax,nxticks)
101 101 xtickspos = numpy.array([float("%.1f"%i) for i in xtickspos])
102 102 ax.set_xticks(xtickspos)
103 103 else:
104 104 xtickspos = numpy.arange(nxticks)*int((xmax-xmin)/(nxticks)) + int(xmin)
105 105 ax.set_xticks(xtickspos)
106 106
107 107 for tick in ax.get_xticklabels():
108 108 tick.set_visible(xtick_visible)
109 109
110 110 for tick in ax.xaxis.get_major_ticks():
111 111 tick.label.set_fontsize(ticksize)
112 112
113 113 ######################################################
114 114 for tick in ax.get_yticklabels():
115 115 tick.set_visible(ytick_visible)
116 116
117 117 for tick in ax.yaxis.get_major_ticks():
118 118 tick.label.set_fontsize(ticksize)
119 119
120 120 ax.plot(x, y)
121 121 iplot = ax.lines[-1]
122 122
123 123 ######################################################
124 124 if '0.' in matplotlib.__version__[0:2]:
125 125 print "The matplotlib version has to be updated to 1.1 or newer"
126 126 return iplot
127 127
128 128 if '1.0.' in matplotlib.__version__[0:4]:
129 129 print "The matplotlib version has to be updated to 1.1 or newer"
130 130 return iplot
131 131
132 132 if grid != None:
133 133 ax.grid(b=True, which='major', axis=grid)
134 134
135 135 matplotlib.pyplot.tight_layout()
136 136
137 137 matplotlib.pyplot.ion()
138 138
139 139 return iplot
140 140
141 141 def set_linedata(ax, x, y, idline):
142 142
143 143 ax.lines[idline].set_data(x,y)
144 144
145 145 def pline(iplot, x, y, xlabel='', ylabel='', title=''):
146 146
147 147 ax = iplot.get_axes()
148 148
149 149 printLabels(ax, xlabel, ylabel, title)
150 150
151 151 set_linedata(ax, x, y, idline=0)
152 152
153 153 def addpline(ax, x, y, color, linestyle, lw):
154 154
155 155 ax.plot(x,y,color=color,linestyle=linestyle,lw=lw)
156 156
157 157
158 158 def createPcolor(ax, x, y, z, xmin, xmax, ymin, ymax, zmin, zmax,
159 159 xlabel='', ylabel='', title='', ticksize = 9,
160 160 colormap='jet',cblabel='', cbsize="5%",
161 161 XAxisAsTime=False):
162 162
163 163 matplotlib.pyplot.ioff()
164 164
165 165 divider = make_axes_locatable(ax)
166 166 ax_cb = divider.new_horizontal(size=cbsize, pad=0.05)
167 167 fig = ax.get_figure()
168 168 fig.add_axes(ax_cb)
169 169
170 170 ax.set_xlim([xmin,xmax])
171 171 ax.set_ylim([ymin,ymax])
172 172
173 173 printLabels(ax, xlabel, ylabel, title)
174 174
175 175 imesh = ax.pcolormesh(x,y,z.T, vmin=zmin, vmax=zmax, cmap=matplotlib.pyplot.get_cmap(colormap))
176 176 cb = matplotlib.pyplot.colorbar(imesh, cax=ax_cb)
177 177 cb.set_label(cblabel)
178 178
179 179 # for tl in ax_cb.get_yticklabels():
180 180 # tl.set_visible(True)
181 181
182 182 for tick in ax.yaxis.get_major_ticks():
183 183 tick.label.set_fontsize(ticksize)
184 184
185 185 for tick in ax.xaxis.get_major_ticks():
186 186 tick.label.set_fontsize(ticksize)
187 187
188 188 for tick in cb.ax.get_yticklabels():
189 189 tick.set_fontsize(ticksize)
190 190
191 191 ax_cb.yaxis.tick_right()
192 192
193 193 if '0.' in matplotlib.__version__[0:2]:
194 194 print "The matplotlib version has to be updated to 1.1 or newer"
195 195 return imesh
196 196
197 197 if '1.0.' in matplotlib.__version__[0:4]:
198 198 print "The matplotlib version has to be updated to 1.1 or newer"
199 199 return imesh
200 200
201 201 matplotlib.pyplot.tight_layout()
202 202
203 203 if XAxisAsTime:
204 204
205 205 func = lambda x, pos: ('%s') %(datetime.datetime.utcfromtimestamp(x).strftime("%H:%M:%S"))
206 206 ax.xaxis.set_major_formatter(FuncFormatter(func))
207 207 ax.xaxis.set_major_locator(LinearLocator(7))
208 208
209 209 matplotlib.pyplot.ion()
210 210 return imesh
211 211
212 212 def pcolor(imesh, z, xlabel='', ylabel='', title=''):
213 213
214 214 z = z.T
215 215
216 216 ax = imesh.get_axes()
217 217
218 218 printLabels(ax, xlabel, ylabel, title)
219 219
220 220 imesh.set_array(z.ravel())
221 221
222 222 def addpcolor(ax, x, y, z, zmin, zmax, xlabel='', ylabel='', title='', colormap='jet'):
223 223
224 224 printLabels(ax, xlabel, ylabel, title)
225 225
226 # ax.collections.remove(ax.collections[0])
226 ax.pcolormesh(x,y,z.T,vmin=zmin,vmax=zmax, cmap=matplotlib.pyplot.get_cmap(colormap))
227
228 def addpcolorbuffer(ax, x, y, z, zmin, zmax, xlabel='', ylabel='', title='', colormap='jet'):
229
230 printLabels(ax, xlabel, ylabel, title)
231
232 ax.collections.remove(ax.collections[0])
227 233
228 234 ax.pcolormesh(x,y,z.T,vmin=zmin,vmax=zmax, cmap=matplotlib.pyplot.get_cmap(colormap))
229 235
230 236 def createPmultiline(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', title='', legendlabels=None,
231 237 ticksize=9, xtick_visible=True, ytick_visible=True,
232 238 nxticks=4, nyticks=10,
233 239 grid=None):
234 240
235 241 """
236 242
237 243 Input:
238 244 grid : None, 'both', 'x', 'y'
239 245 """
240 246
241 247 matplotlib.pyplot.ioff()
242 248
243 249 lines = ax.plot(x.T, y)
244 250 leg = ax.legend(lines, legendlabels, loc='upper right')
245 251 leg.get_frame().set_alpha(0.5)
246 252 ax.set_xlim([xmin,xmax])
247 253 ax.set_ylim([ymin,ymax])
248 254 printLabels(ax, xlabel, ylabel, title)
249 255
250 256 xtickspos = numpy.arange(nxticks)*int((xmax-xmin)/(nxticks)) + int(xmin)
251 257 ax.set_xticks(xtickspos)
252 258
253 259 for tick in ax.get_xticklabels():
254 260 tick.set_visible(xtick_visible)
255 261
256 262 for tick in ax.xaxis.get_major_ticks():
257 263 tick.label.set_fontsize(ticksize)
258 264
259 265 for tick in ax.get_yticklabels():
260 266 tick.set_visible(ytick_visible)
261 267
262 268 for tick in ax.yaxis.get_major_ticks():
263 269 tick.label.set_fontsize(ticksize)
264 270
265 271 iplot = ax.lines[-1]
266 272
267 273 if '0.' in matplotlib.__version__[0:2]:
268 274 print "The matplotlib version has to be updated to 1.1 or newer"
269 275 return iplot
270 276
271 277 if '1.0.' in matplotlib.__version__[0:4]:
272 278 print "The matplotlib version has to be updated to 1.1 or newer"
273 279 return iplot
274 280
275 281 if grid != None:
276 282 ax.grid(b=True, which='major', axis=grid)
277 283
278 284 matplotlib.pyplot.tight_layout()
279 285
280 286 matplotlib.pyplot.ion()
281 287
282 288 return iplot
283 289
284 290
285 291 def pmultiline(iplot, x, y, xlabel='', ylabel='', title=''):
286 292
287 293 ax = iplot.get_axes()
288 294
289 295 printLabels(ax, xlabel, ylabel, title)
290 296
291 297 for i in range(len(ax.lines)):
292 298 line = ax.lines[i]
293 299 line.set_data(x[i,:],y)
294 300
295 301 def createPmultilineYAxis(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', title='', legendlabels=None,
296 302 ticksize=9, xtick_visible=True, ytick_visible=True,
297 303 nxticks=4, nyticks=10, marker='^', markersize=8, linestyle="solid",
298 304 grid=None, XAxisAsTime=False):
299 305
300 306 """
301 307
302 308 Input:
303 309 grid : None, 'both', 'x', 'y'
304 310 """
305 311
306 312 matplotlib.pyplot.ioff()
307 313
308 314 lines = ax.plot(x, y.T, marker=marker,markersize=markersize,linestyle=linestyle)
309 315 leg = ax.legend(lines, legendlabels, loc='upper left', bbox_to_anchor=(1.01, 1.00), numpoints=1, handlelength=1.5, \
310 316 handletextpad=0.5, borderpad=0.5, labelspacing=0.5, borderaxespad=0.)
311 317
312 318 for label in leg.get_texts(): label.set_fontsize(9)
313 319
314 320 ax.set_xlim([xmin,xmax])
315 321 ax.set_ylim([ymin,ymax])
316 322 printLabels(ax, xlabel, ylabel, title)
317 323
318 324 # xtickspos = numpy.arange(nxticks)*int((xmax-xmin)/(nxticks)) + int(xmin)
319 325 # ax.set_xticks(xtickspos)
320 326
321 327 for tick in ax.get_xticklabels():
322 328 tick.set_visible(xtick_visible)
323 329
324 330 for tick in ax.xaxis.get_major_ticks():
325 331 tick.label.set_fontsize(ticksize)
326 332
327 333 for tick in ax.get_yticklabels():
328 334 tick.set_visible(ytick_visible)
329 335
330 336 for tick in ax.yaxis.get_major_ticks():
331 337 tick.label.set_fontsize(ticksize)
332 338
333 339 iplot = ax.lines[-1]
334 340
335 341 if '0.' in matplotlib.__version__[0:2]:
336 342 print "The matplotlib version has to be updated to 1.1 or newer"
337 343 return iplot
338 344
339 345 if '1.0.' in matplotlib.__version__[0:4]:
340 346 print "The matplotlib version has to be updated to 1.1 or newer"
341 347 return iplot
342 348
343 349 if grid != None:
344 350 ax.grid(b=True, which='major', axis=grid)
345 351
346 352 matplotlib.pyplot.tight_layout()
347 353
348 354 if XAxisAsTime:
349 355
350 356 func = lambda x, pos: ('%s') %(datetime.datetime.utcfromtimestamp(x).strftime("%H:%M:%S"))
351 357 ax.xaxis.set_major_formatter(FuncFormatter(func))
352 358 ax.xaxis.set_major_locator(LinearLocator(7))
353 359
354 360 matplotlib.pyplot.ion()
355 361
356 362 return iplot
357 363
358 364 def pmultilineyaxis(iplot, x, y, xlabel='', ylabel='', title=''):
359 365
360 366 ax = iplot.get_axes()
361 367
362 368 printLabels(ax, xlabel, ylabel, title)
363 369
364 370 for i in range(len(ax.lines)):
365 371 line = ax.lines[i]
366 372 line.set_data(x,y[i,:])
367 373
368 374 def draw(fig):
369 375
370 376 if type(fig) == 'int':
371 377 raise ValueError, "This parameter should be of tpye matplotlib figure"
372 378
373 379 fig.canvas.draw() No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,1004 +1,1004
1 1 import numpy
2 2 import time, datetime, os
3 3 from graphics.figure import *
4 4
5 5 class CrossSpectraPlot(Figure):
6 6
7 7 __isConfig = None
8 8 __nsubplots = None
9 9
10 10 WIDTH = None
11 11 HEIGHT = None
12 12 WIDTHPROF = None
13 13 HEIGHTPROF = None
14 14 PREFIX = 'cspc'
15 15
16 16 def __init__(self):
17 17
18 18 self.__isConfig = False
19 19 self.__nsubplots = 4
20 20
21 21 self.WIDTH = 250
22 22 self.HEIGHT = 250
23 23 self.WIDTHPROF = 0
24 24 self.HEIGHTPROF = 0
25 25
26 26 def getSubplots(self):
27 27
28 28 ncol = 4
29 29 nrow = self.nplots
30 30
31 31 return nrow, ncol
32 32
33 33 def setup(self, idfigure, nplots, wintitle, showprofile=True):
34 34
35 35 self.__showprofile = showprofile
36 36 self.nplots = nplots
37 37
38 38 ncolspan = 1
39 39 colspan = 1
40 40
41 41 self.createFigure(idfigure = idfigure,
42 42 wintitle = wintitle,
43 43 widthplot = self.WIDTH + self.WIDTHPROF,
44 44 heightplot = self.HEIGHT + self.HEIGHTPROF)
45 45
46 46 nrow, ncol = self.getSubplots()
47 47
48 48 counter = 0
49 49 for y in range(nrow):
50 50 for x in range(ncol):
51 51 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
52 52
53 53 counter += 1
54 54
55 55 def run(self, dataOut, idfigure, wintitle="", pairsList=None, showprofile='True',
56 56 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
57 57 save=False, figpath='./', figfile=None,
58 58 power_cmap='jet', coherence_cmap='jet', phase_cmap='RdBu_r'):
59 59
60 60 """
61 61
62 62 Input:
63 63 dataOut :
64 64 idfigure :
65 65 wintitle :
66 66 channelList :
67 67 showProfile :
68 68 xmin : None,
69 69 xmax : None,
70 70 ymin : None,
71 71 ymax : None,
72 72 zmin : None,
73 73 zmax : None
74 74 """
75 75
76 76 if pairsList == None:
77 77 pairsIndexList = dataOut.pairsIndexList
78 78 else:
79 79 pairsIndexList = []
80 80 for pair in pairsList:
81 81 if pair not in dataOut.pairsList:
82 82 raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
83 83 pairsIndexList.append(dataOut.pairsList.index(pair))
84 84
85 85 if pairsIndexList == []:
86 86 return
87 87
88 88 if len(pairsIndexList) > 4:
89 89 pairsIndexList = pairsIndexList[0:4]
90 90 factor = dataOut.normFactor
91 91 x = dataOut.getVelRange(1)
92 92 y = dataOut.getHeiRange()
93 93 z = dataOut.data_spc[:,:,:]/factor
94 94 # z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
95 95 avg = numpy.abs(numpy.average(z, axis=1))
96 96 noise = dataOut.getNoise()/factor
97 97
98 98 zdB = 10*numpy.log10(z)
99 99 avgdB = 10*numpy.log10(avg)
100 100 noisedB = 10*numpy.log10(noise)
101 101
102 102
103 103 thisDatetime = dataOut.datatime
104 104 title = "Cross-Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
105 105 xlabel = "Velocity (m/s)"
106 106 ylabel = "Range (Km)"
107 107
108 108 if not self.__isConfig:
109 109
110 110 nplots = len(pairsIndexList)
111 111
112 112 self.setup(idfigure=idfigure,
113 113 nplots=nplots,
114 114 wintitle=wintitle,
115 115 showprofile=showprofile)
116 116
117 117 if xmin == None: xmin = numpy.nanmin(x)
118 118 if xmax == None: xmax = numpy.nanmax(x)
119 119 if ymin == None: ymin = numpy.nanmin(y)
120 120 if ymax == None: ymax = numpy.nanmax(y)
121 121 if zmin == None: zmin = numpy.nanmin(avgdB)*0.9
122 122 if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
123 123
124 124 self.__isConfig = True
125 125
126 126 self.setWinTitle(title)
127 127
128 128 for i in range(self.nplots):
129 129 pair = dataOut.pairsList[pairsIndexList[i]]
130 130
131 131 title = "Channel %d: %4.2fdB" %(pair[0], noisedB[pair[0]])
132 132 zdB = 10.*numpy.log10(dataOut.data_spc[pair[0],:,:]/factor)
133 133 axes0 = self.axesList[i*self.__nsubplots]
134 134 axes0.pcolor(x, y, zdB,
135 135 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
136 136 xlabel=xlabel, ylabel=ylabel, title=title,
137 137 ticksize=9, colormap=power_cmap, cblabel='')
138 138
139 139 title = "Channel %d: %4.2fdB" %(pair[1], noisedB[pair[1]])
140 140 zdB = 10.*numpy.log10(dataOut.data_spc[pair[1],:,:]/factor)
141 141 axes0 = self.axesList[i*self.__nsubplots+1]
142 142 axes0.pcolor(x, y, zdB,
143 143 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
144 144 xlabel=xlabel, ylabel=ylabel, title=title,
145 145 ticksize=9, colormap=power_cmap, cblabel='')
146 146
147 147 coherenceComplex = dataOut.data_cspc[pairsIndexList[i],:,:]/numpy.sqrt(dataOut.data_spc[pair[0],:,:]*dataOut.data_spc[pair[1],:,:])
148 148 coherence = numpy.abs(coherenceComplex)
149 149 # phase = numpy.arctan(-1*coherenceComplex.imag/coherenceComplex.real)*180/numpy.pi
150 150 phase = numpy.arctan2(coherenceComplex.imag, coherenceComplex.real)*180/numpy.pi
151 151
152 152 title = "Coherence %d%d" %(pair[0], pair[1])
153 153 axes0 = self.axesList[i*self.__nsubplots+2]
154 154 axes0.pcolor(x, y, coherence,
155 155 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=0, zmax=1,
156 156 xlabel=xlabel, ylabel=ylabel, title=title,
157 157 ticksize=9, colormap=coherence_cmap, cblabel='')
158 158
159 159 title = "Phase %d%d" %(pair[0], pair[1])
160 160 axes0 = self.axesList[i*self.__nsubplots+3]
161 161 axes0.pcolor(x, y, phase,
162 162 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=-180, zmax=180,
163 163 xlabel=xlabel, ylabel=ylabel, title=title,
164 164 ticksize=9, colormap=phase_cmap, cblabel='')
165 165
166 166
167 167
168 168 self.draw()
169 169
170 170 if save:
171 171 date = thisDatetime.strftime("%Y%m%d_%H%M%S")
172 172 if figfile == None:
173 173 figfile = self.getFilename(name = date)
174 174
175 175 self.saveFigure(figpath, figfile)
176 176
177 177
178 178 class RTIPlot(Figure):
179 179
180 180 __isConfig = None
181 181 __nsubplots = None
182 182
183 183 WIDTHPROF = None
184 184 HEIGHTPROF = None
185 185 PREFIX = 'rti'
186 186
187 187 def __init__(self):
188 188
189 189 self.timerange = 2*60*60
190 190 self.__isConfig = False
191 191 self.__nsubplots = 1
192 192
193 193 self.WIDTH = 800
194 194 self.HEIGHT = 150
195 195 self.WIDTHPROF = 120
196 196 self.HEIGHTPROF = 0
197 197 self.counterftp = 0
198 198
199 199 def getSubplots(self):
200 200
201 201 ncol = 1
202 202 nrow = self.nplots
203 203
204 204 return nrow, ncol
205 205
206 206 def setup(self, idfigure, nplots, wintitle, showprofile=True):
207 207
208 208 self.__showprofile = showprofile
209 209 self.nplots = nplots
210 210
211 211 ncolspan = 1
212 212 colspan = 1
213 213 if showprofile:
214 214 ncolspan = 7
215 215 colspan = 6
216 216 self.__nsubplots = 2
217 217
218 218 self.createFigure(idfigure = idfigure,
219 219 wintitle = wintitle,
220 220 widthplot = self.WIDTH + self.WIDTHPROF,
221 221 heightplot = self.HEIGHT + self.HEIGHTPROF)
222 222
223 223 nrow, ncol = self.getSubplots()
224 224
225 225 counter = 0
226 226 for y in range(nrow):
227 227 for x in range(ncol):
228 228
229 229 if counter >= self.nplots:
230 230 break
231 231
232 232 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
233 233
234 234 if showprofile:
235 235 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
236 236
237 237 counter += 1
238 238
239 239 def run(self, dataOut, idfigure, wintitle="", channelList=None, showprofile='True',
240 240 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
241 241 timerange=None,
242 242 save=False, figpath='./', figfile=None, ftp=False, ftpratio=1):
243 243
244 244 """
245 245
246 246 Input:
247 247 dataOut :
248 248 idfigure :
249 249 wintitle :
250 250 channelList :
251 251 showProfile :
252 252 xmin : None,
253 253 xmax : None,
254 254 ymin : None,
255 255 ymax : None,
256 256 zmin : None,
257 257 zmax : None
258 258 """
259 259
260 260 if channelList == None:
261 261 channelIndexList = dataOut.channelIndexList
262 262 else:
263 263 channelIndexList = []
264 264 for channel in channelList:
265 265 if channel not in dataOut.channelList:
266 266 raise ValueError, "Channel %d is not in dataOut.channelList"
267 267 channelIndexList.append(dataOut.channelList.index(channel))
268 268
269 269 if timerange != None:
270 270 self.timerange = timerange
271 271
272 272 tmin = None
273 273 tmax = None
274 274 factor = dataOut.normFactor
275 275 x = dataOut.getTimeRange()
276 276 y = dataOut.getHeiRange()
277 277
278 278 z = dataOut.data_spc[channelIndexList,:,:]/factor
279 279 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
280 280 avg = numpy.average(z, axis=1)
281 281
282 282 avgdB = 10.*numpy.log10(avg)
283 283
284 284
285 285 thisDatetime = dataOut.datatime
286 286 title = "RTI: %s" %(thisDatetime.strftime("%d-%b-%Y"))
287 287 xlabel = ""
288 288 ylabel = "Range (Km)"
289 289
290 290 if not self.__isConfig:
291 291
292 292 nplots = len(channelIndexList)
293 293
294 294 self.setup(idfigure=idfigure,
295 295 nplots=nplots,
296 296 wintitle=wintitle,
297 297 showprofile=showprofile)
298 298
299 299 tmin, tmax = self.getTimeLim(x, xmin, xmax)
300 300 if ymin == None: ymin = numpy.nanmin(y)
301 301 if ymax == None: ymax = numpy.nanmax(y)
302 302 if zmin == None: zmin = numpy.nanmin(avgdB)*0.9
303 303 if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
304 304
305 305 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
306 306 self.__isConfig = True
307 307
308 308
309 309 self.setWinTitle(title)
310 310
311 311 for i in range(self.nplots):
312 312 title = "Channel %d: %s" %(dataOut.channelList[i], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
313 313 axes = self.axesList[i*self.__nsubplots]
314 314 zdB = avgdB[i].reshape((1,-1))
315 axes.pcolor(x, y, zdB,
315 axes.pcolorbuffer(x, y, zdB,
316 316 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
317 317 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
318 318 ticksize=9, cblabel='', cbsize="1%")
319 319
320 320 if self.__showprofile:
321 321 axes = self.axesList[i*self.__nsubplots +1]
322 322 axes.pline(avgdB[i], y,
323 323 xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
324 324 xlabel='dB', ylabel='', title='',
325 325 ytick_visible=False,
326 326 grid='x')
327 327
328 328 self.draw()
329 329
330 330 if save:
331 331
332 332 if figfile == None:
333 333 figfile = self.getFilename(name = self.name)
334 334
335 335 self.saveFigure(figpath, figfile)
336 336
337 337 self.counterftp += 1
338 338 if (ftp and (self.counterftp==ftpratio)):
339 339 figfilename = os.path.join(figpath,figfile)
340 340 self.sendByFTP(figfilename)
341 341 self.counterftp = 0
342 342
343 343 if x[1] + (x[1]-x[0]) >= self.axesList[0].xmax:
344 344 self.__isConfig = False
345 345
346 346 class SpectraPlot(Figure):
347 347
348 348 __isConfig = None
349 349 __nsubplots = None
350 350
351 351 WIDTHPROF = None
352 352 HEIGHTPROF = None
353 353 PREFIX = 'spc'
354 354
355 355 def __init__(self):
356 356
357 357 self.__isConfig = False
358 358 self.__nsubplots = 1
359 359
360 360 self.WIDTH = 230
361 361 self.HEIGHT = 250
362 362 self.WIDTHPROF = 120
363 363 self.HEIGHTPROF = 0
364 364
365 365 def getSubplots(self):
366 366
367 367 ncol = int(numpy.sqrt(self.nplots)+0.9)
368 368 nrow = int(self.nplots*1./ncol + 0.9)
369 369
370 370 return nrow, ncol
371 371
372 372 def setup(self, idfigure, nplots, wintitle, showprofile=True):
373 373
374 374 self.__showprofile = showprofile
375 375 self.nplots = nplots
376 376
377 377 ncolspan = 1
378 378 colspan = 1
379 379 if showprofile:
380 380 ncolspan = 3
381 381 colspan = 2
382 382 self.__nsubplots = 2
383 383
384 384 self.createFigure(idfigure = idfigure,
385 385 wintitle = wintitle,
386 386 widthplot = self.WIDTH + self.WIDTHPROF,
387 387 heightplot = self.HEIGHT + self.HEIGHTPROF)
388 388
389 389 nrow, ncol = self.getSubplots()
390 390
391 391 counter = 0
392 392 for y in range(nrow):
393 393 for x in range(ncol):
394 394
395 395 if counter >= self.nplots:
396 396 break
397 397
398 398 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
399 399
400 400 if showprofile:
401 401 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
402 402
403 403 counter += 1
404 404
405 405 def run(self, dataOut, idfigure, wintitle="", channelList=None, showprofile='True',
406 406 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
407 407 save=False, figpath='./', figfile=None):
408 408
409 409 """
410 410
411 411 Input:
412 412 dataOut :
413 413 idfigure :
414 414 wintitle :
415 415 channelList :
416 416 showProfile :
417 417 xmin : None,
418 418 xmax : None,
419 419 ymin : None,
420 420 ymax : None,
421 421 zmin : None,
422 422 zmax : None
423 423 """
424 424
425 425 if channelList == None:
426 426 channelIndexList = dataOut.channelIndexList
427 427 else:
428 428 channelIndexList = []
429 429 for channel in channelList:
430 430 if channel not in dataOut.channelList:
431 431 raise ValueError, "Channel %d is not in dataOut.channelList"
432 432 channelIndexList.append(dataOut.channelList.index(channel))
433 433 factor = dataOut.normFactor
434 434 x = dataOut.getVelRange(1)
435 435 y = dataOut.getHeiRange()
436 436
437 437 z = dataOut.data_spc[channelIndexList,:,:]/factor
438 438 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
439 439 avg = numpy.average(z, axis=1)
440 440 noise = dataOut.getNoise()/factor
441 441
442 442 zdB = 10*numpy.log10(z)
443 443 avgdB = 10*numpy.log10(avg)
444 444 noisedB = 10*numpy.log10(noise)
445 445
446 446 thisDatetime = dataOut.datatime
447 447 title = "Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
448 448 xlabel = "Velocity (m/s)"
449 449 ylabel = "Range (Km)"
450 450
451 451 if not self.__isConfig:
452 452
453 453 nplots = len(channelIndexList)
454 454
455 455 self.setup(idfigure=idfigure,
456 456 nplots=nplots,
457 457 wintitle=wintitle,
458 458 showprofile=showprofile)
459 459
460 460 if xmin == None: xmin = numpy.nanmin(x)
461 461 if xmax == None: xmax = numpy.nanmax(x)
462 462 if ymin == None: ymin = numpy.nanmin(y)
463 463 if ymax == None: ymax = numpy.nanmax(y)
464 464 if zmin == None: zmin = numpy.nanmin(avgdB)*0.9
465 465 if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
466 466
467 467 self.__isConfig = True
468 468
469 469 self.setWinTitle(title)
470 470
471 471 for i in range(self.nplots):
472 472 title = "Channel %d: %4.2fdB" %(dataOut.channelList[i], noisedB[i])
473 473 axes = self.axesList[i*self.__nsubplots]
474 474 axes.pcolor(x, y, zdB[i,:,:],
475 475 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
476 476 xlabel=xlabel, ylabel=ylabel, title=title,
477 477 ticksize=9, cblabel='')
478 478
479 479 if self.__showprofile:
480 480 axes = self.axesList[i*self.__nsubplots +1]
481 481 axes.pline(avgdB[i], y,
482 482 xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
483 483 xlabel='dB', ylabel='', title='',
484 484 ytick_visible=False,
485 485 grid='x')
486 486
487 487 noiseline = numpy.repeat(noisedB[i], len(y))
488 488 axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2)
489 489
490 490 self.draw()
491 491
492 492 if save:
493 493 date = thisDatetime.strftime("%Y%m%d_%H%M%S")
494 494 if figfile == None:
495 495 figfile = self.getFilename(name = date)
496 496
497 497 self.saveFigure(figpath, figfile)
498 498
499 499 class Scope(Figure):
500 500
501 501 __isConfig = None
502 502
503 503 def __init__(self):
504 504
505 505 self.__isConfig = False
506 506 self.WIDTH = 600
507 507 self.HEIGHT = 200
508 508
509 509 def getSubplots(self):
510 510
511 511 nrow = self.nplots
512 512 ncol = 3
513 513 return nrow, ncol
514 514
515 515 def setup(self, idfigure, nplots, wintitle):
516 516
517 517 self.nplots = nplots
518 518
519 519 self.createFigure(idfigure, wintitle)
520 520
521 521 nrow,ncol = self.getSubplots()
522 522 colspan = 3
523 523 rowspan = 1
524 524
525 525 for i in range(nplots):
526 526 self.addAxes(nrow, ncol, i, 0, colspan, rowspan)
527 527
528 528
529 529
530 530 def run(self, dataOut, idfigure, wintitle="", channelList=None,
531 531 xmin=None, xmax=None, ymin=None, ymax=None, save=False,
532 532 figpath='./', figfile=None):
533 533
534 534 """
535 535
536 536 Input:
537 537 dataOut :
538 538 idfigure :
539 539 wintitle :
540 540 channelList :
541 541 xmin : None,
542 542 xmax : None,
543 543 ymin : None,
544 544 ymax : None,
545 545 """
546 546
547 547 if channelList == None:
548 548 channelIndexList = dataOut.channelIndexList
549 549 else:
550 550 channelIndexList = []
551 551 for channel in channelList:
552 552 if channel not in dataOut.channelList:
553 553 raise ValueError, "Channel %d is not in dataOut.channelList"
554 554 channelIndexList.append(dataOut.channelList.index(channel))
555 555
556 556 x = dataOut.heightList
557 557 y = dataOut.data[channelIndexList,:] * numpy.conjugate(dataOut.data[channelIndexList,:])
558 558 y = y.real
559 559
560 560 thisDatetime = dataOut.datatime
561 561 title = "Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
562 562 xlabel = "Range (Km)"
563 563 ylabel = "Intensity"
564 564
565 565 if not self.__isConfig:
566 566 nplots = len(channelIndexList)
567 567
568 568 self.setup(idfigure=idfigure,
569 569 nplots=nplots,
570 570 wintitle=wintitle)
571 571
572 572 if xmin == None: xmin = numpy.nanmin(x)
573 573 if xmax == None: xmax = numpy.nanmax(x)
574 574 if ymin == None: ymin = numpy.nanmin(y)
575 575 if ymax == None: ymax = numpy.nanmax(y)
576 576
577 577 self.__isConfig = True
578 578
579 579 self.setWinTitle(title)
580 580
581 581 for i in range(len(self.axesList)):
582 582 title = "Channel %d" %(i)
583 583 axes = self.axesList[i]
584 584 ychannel = y[i,:]
585 585 axes.pline(x, ychannel,
586 586 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
587 587 xlabel=xlabel, ylabel=ylabel, title=title)
588 588
589 589 self.draw()
590 590
591 591 if save:
592 592 date = thisDatetime.strftime("%Y%m%d_%H%M%S")
593 593 if figfile == None:
594 594 figfile = self.getFilename(name = date)
595 595
596 596 self.saveFigure(figpath, figfile)
597 597
598 598 class ProfilePlot(Figure):
599 599 __isConfig = None
600 600 __nsubplots = None
601 601
602 602 WIDTHPROF = None
603 603 HEIGHTPROF = None
604 604 PREFIX = 'spcprofile'
605 605
606 606 def __init__(self):
607 607 self.__isConfig = False
608 608 self.__nsubplots = 1
609 609
610 610 self.WIDTH = 300
611 611 self.HEIGHT = 500
612 612
613 613 def getSubplots(self):
614 614 ncol = 1
615 615 nrow = 1
616 616
617 617 return nrow, ncol
618 618
619 619 def setup(self, idfigure, nplots, wintitle):
620 620
621 621 self.nplots = nplots
622 622
623 623 ncolspan = 1
624 624 colspan = 1
625 625
626 626 self.createFigure(idfigure = idfigure,
627 627 wintitle = wintitle,
628 628 widthplot = self.WIDTH,
629 629 heightplot = self.HEIGHT)
630 630
631 631 nrow, ncol = self.getSubplots()
632 632
633 633 counter = 0
634 634 for y in range(nrow):
635 635 for x in range(ncol):
636 636 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
637 637
638 638 def run(self, dataOut, idfigure, wintitle="", channelList=None,
639 639 xmin=None, xmax=None, ymin=None, ymax=None,
640 640 save=False, figpath='./', figfile=None):
641 641
642 642 if channelList == None:
643 643 channelIndexList = dataOut.channelIndexList
644 644 channelList = dataOut.channelList
645 645 else:
646 646 channelIndexList = []
647 647 for channel in channelList:
648 648 if channel not in dataOut.channelList:
649 649 raise ValueError, "Channel %d is not in dataOut.channelList"
650 650 channelIndexList.append(dataOut.channelList.index(channel))
651 651
652 652 factor = dataOut.normFactor
653 653 y = dataOut.getHeiRange()
654 654 x = dataOut.data_spc[channelIndexList,:,:]/factor
655 655 x = numpy.where(numpy.isfinite(x), x, numpy.NAN)
656 656 avg = numpy.average(x, axis=1)
657 657
658 658 avgdB = 10*numpy.log10(avg)
659 659
660 660 thisDatetime = dataOut.datatime
661 661 title = "Power Profile"
662 662 xlabel = "dB"
663 663 ylabel = "Range (Km)"
664 664
665 665 if not self.__isConfig:
666 666
667 667 nplots = 1
668 668
669 669 self.setup(idfigure=idfigure,
670 670 nplots=nplots,
671 671 wintitle=wintitle)
672 672
673 673 if ymin == None: ymin = numpy.nanmin(y)
674 674 if ymax == None: ymax = numpy.nanmax(y)
675 675 if xmin == None: xmin = numpy.nanmin(avgdB)*0.9
676 676 if xmax == None: xmax = numpy.nanmax(avgdB)*0.9
677 677
678 678 self.__isConfig = True
679 679
680 680 self.setWinTitle(title)
681 681
682 682
683 683 title = "Power Profile: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
684 684 axes = self.axesList[0]
685 685
686 686 legendlabels = ["channel %d"%x for x in channelList]
687 687 axes.pmultiline(avgdB, y,
688 688 xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
689 689 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels,
690 690 ytick_visible=True, nxticks=5,
691 691 grid='x')
692 692
693 693 self.draw()
694 694
695 695 if save:
696 696 date = thisDatetime.strftime("%Y%m%d")
697 697 if figfile == None:
698 698 figfile = self.getFilename(name = date)
699 699
700 700 self.saveFigure(figpath, figfile)
701 701
702 702 class CoherenceMap(Figure):
703 703 __isConfig = None
704 704 __nsubplots = None
705 705
706 706 WIDTHPROF = None
707 707 HEIGHTPROF = None
708 708 PREFIX = 'cmap'
709 709
710 710 def __init__(self):
711 711 self.timerange = 2*60*60
712 712 self.__isConfig = False
713 713 self.__nsubplots = 1
714 714
715 715 self.WIDTH = 800
716 716 self.HEIGHT = 150
717 717 self.WIDTHPROF = 120
718 718 self.HEIGHTPROF = 0
719 719 self.counterftp = 0
720 720
721 721 def getSubplots(self):
722 722 ncol = 1
723 723 nrow = self.nplots*2
724 724
725 725 return nrow, ncol
726 726
727 727 def setup(self, idfigure, nplots, wintitle, showprofile=True):
728 728 self.__showprofile = showprofile
729 729 self.nplots = nplots
730 730
731 731 ncolspan = 1
732 732 colspan = 1
733 733 if showprofile:
734 734 ncolspan = 7
735 735 colspan = 6
736 736 self.__nsubplots = 2
737 737
738 738 self.createFigure(idfigure = idfigure,
739 739 wintitle = wintitle,
740 740 widthplot = self.WIDTH + self.WIDTHPROF,
741 741 heightplot = self.HEIGHT + self.HEIGHTPROF)
742 742
743 743 nrow, ncol = self.getSubplots()
744 744
745 745 for y in range(nrow):
746 746 for x in range(ncol):
747 747
748 748 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
749 749
750 750 if showprofile:
751 751 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
752 752
753 753 def run(self, dataOut, idfigure, wintitle="", pairsList=None, showprofile='True',
754 754 xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
755 755 timerange=None,
756 756 save=False, figpath='./', figfile=None, ftp=False, ftpratio=1,
757 757 coherence_cmap='jet', phase_cmap='RdBu_r'):
758 758
759 759 if pairsList == None:
760 760 pairsIndexList = dataOut.pairsIndexList
761 761 else:
762 762 pairsIndexList = []
763 763 for pair in pairsList:
764 764 if pair not in dataOut.pairsList:
765 765 raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
766 766 pairsIndexList.append(dataOut.pairsList.index(pair))
767 767
768 768 if timerange != None:
769 769 self.timerange = timerange
770 770
771 771 if pairsIndexList == []:
772 772 return
773 773
774 774 if len(pairsIndexList) > 4:
775 775 pairsIndexList = pairsIndexList[0:4]
776 776
777 777 tmin = None
778 778 tmax = None
779 779 x = dataOut.getTimeRange()
780 780 y = dataOut.getHeiRange()
781 781
782 782 thisDatetime = dataOut.datatime
783 783 title = "CoherenceMap: %s" %(thisDatetime.strftime("%d-%b-%Y"))
784 784 xlabel = ""
785 785 ylabel = "Range (Km)"
786 786
787 787 if not self.__isConfig:
788 788 nplots = len(pairsIndexList)
789 789 self.setup(idfigure=idfigure,
790 790 nplots=nplots,
791 791 wintitle=wintitle,
792 792 showprofile=showprofile)
793 793
794 794 tmin, tmax = self.getTimeLim(x, xmin, xmax)
795 795 if ymin == None: ymin = numpy.nanmin(y)
796 796 if ymax == None: ymax = numpy.nanmax(y)
797 797
798 798 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
799 799
800 800 self.__isConfig = True
801 801
802 802 self.setWinTitle(title)
803 803
804 804 for i in range(self.nplots):
805 805
806 806 pair = dataOut.pairsList[pairsIndexList[i]]
807 807 coherenceComplex = dataOut.data_cspc[pairsIndexList[i],:,:]/numpy.sqrt(dataOut.data_spc[pair[0],:,:]*dataOut.data_spc[pair[1],:,:])
808 808 avgcoherenceComplex = numpy.average(coherenceComplex, axis=0)
809 809 coherence = numpy.abs(avgcoherenceComplex)
810 810 # coherence = numpy.abs(coherenceComplex)
811 811 # avg = numpy.average(coherence, axis=0)
812 812
813 813 z = coherence.reshape((1,-1))
814 814
815 815 counter = 0
816 816
817 817 title = "Coherence %d%d: %s" %(pair[0], pair[1], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
818 818 axes = self.axesList[i*self.__nsubplots*2]
819 axes.pcolor(x, y, z,
819 axes.pcolorbuffer(x, y, z,
820 820 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax, zmin=0, zmax=1,
821 821 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
822 822 ticksize=9, cblabel='', colormap=coherence_cmap, cbsize="1%")
823 823
824 824 if self.__showprofile:
825 825 counter += 1
826 826 axes = self.axesList[i*self.__nsubplots*2 + counter]
827 827 axes.pline(coherence, y,
828 828 xmin=0, xmax=1, ymin=ymin, ymax=ymax,
829 829 xlabel='', ylabel='', title='', ticksize=7,
830 830 ytick_visible=False, nxticks=5,
831 831 grid='x')
832 832
833 833 counter += 1
834 834 # phase = numpy.arctan(-1*coherenceComplex.imag/coherenceComplex.real)*180/numpy.pi
835 835 phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
836 836 # avg = numpy.average(phase, axis=0)
837 837 z = phase.reshape((1,-1))
838 838
839 839 title = "Phase %d%d: %s" %(pair[0], pair[1], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
840 840 axes = self.axesList[i*self.__nsubplots*2 + counter]
841 axes.pcolor(x, y, z,
841 axes.pcolorbuffer(x, y, z,
842 842 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax, zmin=-180, zmax=180,
843 843 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
844 844 ticksize=9, cblabel='', colormap=phase_cmap, cbsize="1%")
845 845
846 846 if self.__showprofile:
847 847 counter += 1
848 848 axes = self.axesList[i*self.__nsubplots*2 + counter]
849 849 axes.pline(phase, y,
850 850 xmin=-180, xmax=180, ymin=ymin, ymax=ymax,
851 851 xlabel='', ylabel='', title='', ticksize=7,
852 852 ytick_visible=False, nxticks=4,
853 853 grid='x')
854 854
855 855 self.draw()
856 856
857 857 if save:
858 858
859 859 if figfile == None:
860 860 figfile = self.getFilename(name = self.name)
861 861
862 862 self.saveFigure(figpath, figfile)
863 863
864 864 self.counterftp += 1
865 865 if (ftp and (self.counterftp==ftpratio)):
866 866 figfilename = os.path.join(figpath,figfile)
867 867 self.sendByFTP(figfilename)
868 868 self.counterftp = 0
869 869
870 870 if x[1] + (x[1]-x[0]) >= self.axesList[0].xmax:
871 871 self.__isConfig = False
872 872
873 873 class RTIfromNoise(Figure):
874 874
875 875 __isConfig = None
876 876 __nsubplots = None
877 877
878 878 PREFIX = 'rtinoise'
879 879
880 880 def __init__(self):
881 881
882 882 self.timerange = 24*60*60
883 883 self.__isConfig = False
884 884 self.__nsubplots = 1
885 885
886 886 self.WIDTH = 820
887 887 self.HEIGHT = 200
888 888 self.WIDTHPROF = 120
889 889 self.HEIGHTPROF = 0
890 890 self.xdata = None
891 891 self.ydata = None
892 892
893 893 def getSubplots(self):
894 894
895 895 ncol = 1
896 896 nrow = 1
897 897
898 898 return nrow, ncol
899 899
900 900 def setup(self, idfigure, nplots, wintitle, showprofile=True):
901 901
902 902 self.__showprofile = showprofile
903 903 self.nplots = nplots
904 904
905 905 ncolspan = 7
906 906 colspan = 6
907 907 self.__nsubplots = 2
908 908
909 909 self.createFigure(idfigure = idfigure,
910 910 wintitle = wintitle,
911 911 widthplot = self.WIDTH+self.WIDTHPROF,
912 912 heightplot = self.HEIGHT+self.HEIGHTPROF)
913 913
914 914 nrow, ncol = self.getSubplots()
915 915
916 916 self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
917 917
918 918
919 919 def run(self, dataOut, idfigure, wintitle="", channelList=None, showprofile='True',
920 920 xmin=None, xmax=None, ymin=None, ymax=None,
921 921 timerange=None,
922 922 save=False, figpath='./', figfile=None):
923 923
924 924 if channelList == None:
925 925 channelIndexList = dataOut.channelIndexList
926 926 channelList = dataOut.channelList
927 927 else:
928 928 channelIndexList = []
929 929 for channel in channelList:
930 930 if channel not in dataOut.channelList:
931 931 raise ValueError, "Channel %d is not in dataOut.channelList"
932 932 channelIndexList.append(dataOut.channelList.index(channel))
933 933
934 934 if timerange != None:
935 935 self.timerange = timerange
936 936
937 937 tmin = None
938 938 tmax = None
939 939 x = dataOut.getTimeRange()
940 940 y = dataOut.getHeiRange()
941 941 factor = dataOut.normFactor
942 942 noise = dataOut.getNoise()/factor
943 943 noisedB = 10*numpy.log10(noise)
944 944
945 945 thisDatetime = dataOut.datatime
946 946 title = "RTI Noise: %s" %(thisDatetime.strftime("%d-%b-%Y"))
947 947 xlabel = ""
948 948 ylabel = "Range (Km)"
949 949
950 950 if not self.__isConfig:
951 951
952 952 nplots = 1
953 953
954 954 self.setup(idfigure=idfigure,
955 955 nplots=nplots,
956 956 wintitle=wintitle,
957 957 showprofile=showprofile)
958 958
959 959 tmin, tmax = self.getTimeLim(x, xmin, xmax)
960 960 if ymin == None: ymin = numpy.nanmin(noisedB)
961 961 if ymax == None: ymax = numpy.nanmax(noisedB)
962 962
963 963 self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
964 964 self.__isConfig = True
965 965
966 966 self.xdata = numpy.array([])
967 967 self.ydata = numpy.array([])
968 968
969 969 self.setWinTitle(title)
970 970
971 971
972 972 title = "RTI Noise %s" %(thisDatetime.strftime("%d-%b-%Y"))
973 973
974 974 legendlabels = ["channel %d"%idchannel for idchannel in channelList]
975 975 axes = self.axesList[0]
976 976
977 977 self.xdata = numpy.hstack((self.xdata, x[0:1]))
978 978
979 979 if len(self.ydata)==0:
980 980 self.ydata = noisedB[channelIndexList].reshape(-1,1)
981 981 else:
982 982 self.ydata = numpy.hstack((self.ydata, noisedB[channelIndexList].reshape(-1,1)))
983 983
984 984
985 985 axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
986 986 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax,
987 987 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
988 988 XAxisAsTime=True
989 989 )
990 990
991 991 self.draw()
992 992
993 993 if save:
994 994
995 995 if figfile == None:
996 996 figfile = self.getFilename(name = self.name)
997 997
998 998 self.saveFigure(figpath, figfile)
999 999
1000 1000 if x[1] + (x[1]-x[0]) >= self.axesList[0].xmax:
1001 1001 self.__isConfig = False
1002 1002 del self.xdata
1003 1003 del self.ydata
1004 1004 No newline at end of file
General Comments 0
You need to be logged in to leave comments. Login now