figure.py
656 lines
| 19.6 KiB
| text/x-python
|
PythonLexer
|
r212 | import os | |
|
r201 | import numpy | |
|
r231 | import time, datetime | |
|
r1167 | from schainpy.model.graphics import mpldriver | |
|
r497 | ||
|
r577 | from schainpy.model.proc.jroproc_base import Operation | |
|
r435 | ||
|
r760 | def isTimeInHourRange(datatime, xmin, xmax): | |
|
r897 | ||
|
r760 | if xmin == None or xmax == None: | |
return 1 | |||
hour = datatime.hour + datatime.minute/60.0 | |||
|
r897 | ||
|
r760 | if xmin < (xmax % 24): | |
|
r897 | ||
|
r760 | if hour >= xmin and hour <= xmax: | |
return 1 | |||
else: | |||
return 0 | |||
|
r897 | ||
|
r760 | else: | |
|
r897 | ||
|
r760 | if hour >= xmin or hour <= (xmax % 24): | |
return 1 | |||
else: | |||
return 0 | |||
|
r897 | ||
|
r760 | return 0 | |
|
r487 | def isRealtime(utcdatatime): | |
|
r897 | ||
|
r487 | utcnow = time.mktime(time.localtime()) | |
delta = abs(utcnow - utcdatatime) # abs | |||
if delta >= 30.: | |||
return False | |||
return True | |||
|
r577 | class Figure(Operation): | |
|
r897 | ||
|
r201 | __driver = mpldriver | |
|
r206 | fig = None | |
|
r897 | ||
|
r395 | id = None | |
|
r201 | wintitle = None | |
|
r192 | width = None | |
height = None | |||
|
r201 | nplots = None | |
|
r231 | timerange = None | |
|
r897 | ||
|
r201 | axesObjList = [] | |
|
r897 | ||
|
r696 | WIDTH = 300 | |
HEIGHT = 200 | |||
|
r212 | PREFIX = 'fig' | |
|
r897 | ||
|
r471 | xmin = None | |
xmax = None | |||
|
r897 | ||
|
r573 | counter_imagwr = 0 | |
|
r897 | ||
|
r573 | figfile = None | |
|
r897 | ||
|
r760 | created = False | |
|
r954 | parameters = {} | |
|
r897 | def __init__(self, **kwargs): | |
Operation.__init__(self, **kwargs) | |||
|
r206 | def __del__(self): | |
|
r897 | ||
|
r577 | self.__driver.closeFigure() | |
|
r897 | ||
|
r212 | def getFilename(self, name, ext='.png'): | |
|
r897 | ||
|
r395 | path = '%s%03d' %(self.PREFIX, self.id) | |
|
r248 | filename = '%s_%s%s' %(self.PREFIX, name, ext) | |
return os.path.join(path, filename) | |||
|
r897 | ||
|
r201 | def getAxesObjList(self): | |
|
r897 | ||
|
r201 | return self.axesObjList | |
|
r897 | ||
|
r201 | def getSubplots(self): | |
|
r897 | ||
|
r696 | raise NotImplementedError | |
|
r897 | ||
|
r210 | def getScreenDim(self, widthplot, heightplot): | |
|
r897 | ||
|
r201 | nrow, ncol = self.getSubplots() | |
|
r897 | ||
|
r210 | widthscreen = widthplot*ncol | |
heightscreen = heightplot*nrow | |||
|
r897 | ||
|
r210 | return widthscreen, heightscreen | |
|
r897 | ||
|
r568 | def getTimeLim(self, x, xmin=None, xmax=None, timerange=None): | |
|
r897 | ||
|
r760 | # if self.xmin != None and self.xmax != None: | |
# if timerange == None: | |||
# timerange = self.xmax - self.xmin | |||
# xmin = self.xmin + timerange | |||
# xmax = self.xmax + timerange | |||
|
r897 | # | |
|
r760 | # return xmin, xmax | |
|
r897 | ||
|
r568 | if timerange == None and (xmin==None or xmax==None): | |
|
r577 | timerange = 14400 #seconds | |
|
r897 | ||
|
r568 | if timerange != None: | |
|
r608 | txmin = x[0] #- x[0] % min(timerange/10, 10*60) | |
|
r504 | else: | |
|
r608 | txmin = x[0] #- x[0] % 10*60 | |
|
r897 | ||
|
r506 | thisdatetime = datetime.datetime.utcfromtimestamp(txmin) | |
thisdate = datetime.datetime.combine(thisdatetime.date(), datetime.time(0,0,0)) | |||
|
r897 | ||
|
r568 | if timerange != None: | |
|
r471 | xmin = (thisdatetime - thisdate).seconds/(60*60.) | |
xmax = xmin + timerange/(60*60.) | |||
|
r897 | ||
|
r814 | d1970 = datetime.datetime(1970,1,1) | |
|
r897 | ||
|
r814 | mindt = thisdate + datetime.timedelta(hours=xmin) #- datetime.timedelta(seconds=time.timezone) | |
xmin_sec = (mindt - d1970).total_seconds() #time.mktime(mindt.timetuple()) - time.timezone | |||
|
r897 | ||
|
r814 | maxdt = thisdate + datetime.timedelta(hours=xmax) #- datetime.timedelta(seconds=time.timezone) | |
xmax_sec = (maxdt - d1970).total_seconds() #time.mktime(maxdt.timetuple()) - time.timezone | |||
|
r471 | ||
return xmin_sec, xmax_sec | |||
|
r897 | ||
|
r395 | def init(self, id, nplots, wintitle): | |
|
r897 | ||
|
r1167 | raise NotImplementedError("This method has been replaced by createFigure") | |
|
r897 | ||
|
r395 | def createFigure(self, id, wintitle, widthplot=None, heightplot=None, show=True): | |
|
r897 | ||
|
r201 | """ | |
|
r204 | Crea la figura de acuerdo al driver y parametros seleccionados seleccionados. | |
Las dimensiones de la pantalla es calculada a partir de los atributos self.WIDTH | |||
y self.HEIGHT y el numero de subplots (nrow, ncol) | |||
|
r897 | ||
|
r201 | Input: | |
|
r897 | id : Los parametros necesarios son | |
wintitle : | |||
|
r201 | """ | |
|
r897 | ||
|
r210 | if widthplot == None: | |
widthplot = self.WIDTH | |||
|
r897 | ||
|
r210 | if heightplot == None: | |
heightplot = self.HEIGHT | |||
|
r897 | ||
|
r395 | self.id = id | |
|
r897 | ||
|
r201 | self.wintitle = wintitle | |
|
r897 | ||
|
r210 | self.widthscreen, self.heightscreen = self.getScreenDim(widthplot, heightplot) | |
|
r897 | ||
|
r760 | # if self.created: | |
# self.__driver.closeFigure(self.fig) | |||
|
r897 | ||
|
r760 | if not self.created: | |
self.fig = self.__driver.createFigure(id=self.id, | |||
wintitle=self.wintitle, | |||
width=self.widthscreen, | |||
height=self.heightscreen, | |||
show=show) | |||
else: | |||
self.__driver.clearFigure(self.fig) | |||
|
r897 | ||
|
r201 | self.axesObjList = [] | |
|
r573 | self.counter_imagwr = 0 | |
|
r283 | ||
|
r760 | self.created = True | |
|
r897 | ||
|
r201 | def setDriver(self, driver=mpldriver): | |
|
r897 | ||
|
r201 | self.__driver = driver | |
|
r897 | ||
|
r190 | def setTitle(self, title): | |
|
r897 | ||
|
r201 | self.__driver.setTitle(self.fig, title) | |
|
r897 | ||
|
r201 | def setWinTitle(self, title): | |
|
r897 | ||
|
r201 | self.__driver.setWinTitle(self.fig, title=title) | |
|
r897 | ||
|
r201 | def setTextFromAxes(self, text): | |
|
r897 | ||
|
r1167 | raise NotImplementedError("This method has been replaced with Axes.setText") | |
|
r897 | ||
|
r190 | def makeAxes(self, nrow, ncol, xpos, ypos, colspan, rowspan): | |
|
r897 | ||
|
r1167 | raise NotImplementedError("This method has been replaced with Axes.addAxes") | |
|
r897 | ||
|
r201 | def addAxes(self, *args): | |
""" | |||
|
r897 | ||
|
r201 | Input: | |
*args : Los parametros necesarios son | |||
nrow, ncol, xpos, ypos, colspan, rowspan | |||
""" | |||
|
r897 | ||
|
r201 | axesObj = Axes(self.fig, *args) | |
self.axesObjList.append(axesObj) | |||
|
r897 | ||
|
r212 | def saveFigure(self, figpath, figfile, *args): | |
|
r897 | ||
|
r212 | filename = os.path.join(figpath, figfile) | |
|
r897 | ||
|
r248 | fullpath = os.path.split(filename)[0] | |
|
r897 | ||
|
r248 | if not os.path.exists(fullpath): | |
|
r326 | subpath = os.path.split(fullpath)[0] | |
|
r897 | ||
|
r326 | if not os.path.exists(subpath): | |
os.mkdir(subpath) | |||
|
r897 | ||
|
r248 | os.mkdir(fullpath) | |
|
r897 | ||
|
r212 | self.__driver.saveFigure(self.fig, filename, *args) | |
|
r897 | ||
|
r573 | def save(self, figpath, figfile=None, save=True, ftp=False, wr_period=1, thisDatetime=None, update_figfile=True): | |
|
r897 | ||
|
r577 | self.counter_imagwr += 1 | |
if self.counter_imagwr < wr_period: | |||
|
r573 | return | |
|
r897 | ||
|
r577 | self.counter_imagwr = 0 | |
|
r897 | ||
|
r577 | if save: | |
|
r897 | ||
|
r600 | if not figfile: | |
|
r897 | ||
|
r577 | if not thisDatetime: | |
|
r1167 | raise ValueError("Saving figure: figfile or thisDatetime should be defined") | |
|
r577 | return | |
|
r897 | ||
|
r577 | str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S") | |
figfile = self.getFilename(name = str_datetime) | |||
|
r897 | ||
|
r577 | if self.figfile == None: | |
self.figfile = figfile | |||
|
r897 | ||
|
r577 | if update_figfile: | |
self.figfile = figfile | |||
|
r897 | ||
# store png plot to local folder | |||
|
r577 | self.saveFigure(figpath, self.figfile) | |
|
r897 | ||
|
r573 | if not ftp: | |
return | |||
|
r897 | ||
|
r573 | if not thisDatetime: | |
return | |||
|
r897 | ||
# store png plot to FTP server according to RT-Web format | |||
|
r596 | ftp_filename = self.getNameToFtp(thisDatetime, self.FTP_WEI, self.EXP_CODE, self.SUB_EXP_CODE, self.PLOT_CODE, self.PLOT_POS) | |
# ftp_filename = os.path.join(figpath, name) | |||
|
r897 | self.saveFigure(figpath, ftp_filename) | |
|
r401 | def getNameToFtp(self, thisDatetime, FTP_WEI, EXP_CODE, SUB_EXP_CODE, PLOT_CODE, PLOT_POS): | |
|
r897 | YEAR_STR = '%4.4d'%thisDatetime.timetuple().tm_year | |
|
r401 | DOY_STR = '%3.3d'%thisDatetime.timetuple().tm_yday | |
FTP_WEI = '%2.2d'%FTP_WEI | |||
EXP_CODE = '%3.3d'%EXP_CODE | |||
SUB_EXP_CODE = '%2.2d'%SUB_EXP_CODE | |||
PLOT_CODE = '%2.2d'%PLOT_CODE | |||
PLOT_POS = '%2.2d'%PLOT_POS | |||
name = YEAR_STR + DOY_STR + FTP_WEI + EXP_CODE + SUB_EXP_CODE + PLOT_CODE + PLOT_POS | |||
return name | |||
|
r897 | ||
|
r190 | def draw(self): | |
|
r897 | ||
|
r201 | self.__driver.draw(self.fig) | |
|
r897 | ||
|
r190 | def run(self): | |
|
r897 | ||
|
r696 | raise NotImplementedError | |
|
r897 | ||
|
r587 | def close(self, show=False): | |
|
r897 | ||
|
r587 | self.__driver.closeFigure(show=show, fig=self.fig) | |
|
r897 | ||
|
r201 | axesList = property(getAxesObjList) | |
|
r897 | ||
|
r190 | ||
class Axes: | |||
|
r897 | ||
|
r201 | __driver = mpldriver | |
fig = None | |||
|
r190 | ax = None | |
|
r201 | plot = None | |
|
r318 | __missing = 1E30 | |
|
r210 | __firsttime = None | |
|
r897 | ||
|
r204 | __showprofile = False | |
|
r897 | ||
|
r210 | xmin = None | |
xmax = None | |||
ymin = None | |||
ymax = None | |||
zmin = None | |||
zmax = None | |||
|
r897 | ||
|
r318 | x_buffer = None | |
z_buffer = None | |||
|
r897 | ||
|
r396 | decimationx = None | |
decimationy = None | |||
|
r897 | ||
|
r813 | __MAXNUMX = 200 | |
|
r869 | __MAXNUMY = 400 | |
|
r897 | ||
|
r813 | __MAXNUMTIME = 500 | |
|
r897 | ||
|
r201 | def __init__(self, *args): | |
|
r897 | ||
|
r201 | """ | |
|
r897 | ||
|
r201 | Input: | |
*args : Los parametros necesarios son | |||
fig, nrow, ncol, xpos, ypos, colspan, rowspan | |||
""" | |||
|
r897 | ||
|
r201 | ax = self.__driver.createAxes(*args) | |
self.fig = args[0] | |||
|
r190 | self.ax = ax | |
|
r201 | self.plot = None | |
|
r897 | ||
|
r210 | self.__firsttime = True | |
|
r239 | self.idlineList = [] | |
|
r897 | ||
|
r318 | self.x_buffer = numpy.array([]) | |
self.z_buffer = numpy.array([]) | |||
|
r897 | ||
|
r201 | def setText(self, text): | |
|
r897 | ||
|
r201 | self.__driver.setAxesText(self.ax, text) | |
|
r897 | ||
|
r209 | def setXAxisAsTime(self): | |
pass | |||
|
r897 | ||
|
r201 | def pline(self, x, y, | |
xmin=None, xmax=None, | |||
ymin=None, ymax=None, | |||
xlabel='', ylabel='', | |||
title='', | |||
**kwargs): | |||
|
r897 | ||
|
r201 | """ | |
|
r897 | ||
|
r201 | Input: | |
|
r897 | x : | |
y : | |||
|
r201 | xmin : | |
xmax : | |||
ymin : | |||
|
r897 | ymax : | |
|
r201 | xlabel : | |
ylabel : | |||
title : | |||
**kwargs : Los parametros aceptados son | |||
|
r897 | ||
|
r201 | ticksize | |
|
r204 | ytick_visible | |
|
r201 | """ | |
|
r897 | ||
|
r210 | if self.__firsttime: | |
|
r897 | ||
|
r201 | if xmin == None: xmin = numpy.nanmin(x) | |
if xmax == None: xmax = numpy.nanmax(x) | |||
if ymin == None: ymin = numpy.nanmin(y) | |||
if ymax == None: ymax = numpy.nanmax(y) | |||
|
r897 | ||
|
r201 | self.plot = self.__driver.createPline(self.ax, x, y, | |
xmin, xmax, | |||
ymin, ymax, | |||
xlabel=xlabel, | |||
ylabel=ylabel, | |||
title=title, | |||
**kwargs) | |||
|
r239 | ||
self.idlineList.append(0) | |||
|
r210 | self.__firsttime = False | |
|
r201 | return | |
|
r897 | ||
|
r201 | self.__driver.pline(self.plot, x, y, xlabel=xlabel, | |
ylabel=ylabel, | |||
title=title) | |||
|
r239 | ||
|
r631 | # self.__driver.pause() | |
|
r897 | ||
|
r239 | def addpline(self, x, y, idline, **kwargs): | |
lines = self.ax.lines | |||
|
r897 | ||
|
r239 | if idline in self.idlineList: | |
self.__driver.set_linedata(self.ax, x, y, idline) | |||
|
r897 | ||
|
r239 | if idline not in(self.idlineList): | |
self.__driver.addpline(self.ax, x, y, **kwargs) | |||
self.idlineList.append(idline) | |||
return | |||
|
r897 | ||
|
r229 | def pmultiline(self, x, y, | |
xmin=None, xmax=None, | |||
ymin=None, ymax=None, | |||
xlabel='', ylabel='', | |||
title='', | |||
**kwargs): | |||
|
r897 | ||
|
r229 | if self.__firsttime: | |
|
r897 | ||
|
r229 | if xmin == None: xmin = numpy.nanmin(x) | |
if xmax == None: xmax = numpy.nanmax(x) | |||
if ymin == None: ymin = numpy.nanmin(y) | |||
if ymax == None: ymax = numpy.nanmax(y) | |||
|
r897 | ||
|
r229 | self.plot = self.__driver.createPmultiline(self.ax, x, y, | |
xmin, xmax, | |||
ymin, ymax, | |||
xlabel=xlabel, | |||
ylabel=ylabel, | |||
title=title, | |||
**kwargs) | |||
self.__firsttime = False | |||
return | |||
|
r897 | ||
|
r229 | self.__driver.pmultiline(self.plot, x, y, xlabel=xlabel, | |
ylabel=ylabel, | |||
title=title) | |||
|
r897 | ||
|
r631 | # self.__driver.pause() | |
|
r897 | ||
|
r240 | def pmultilineyaxis(self, x, y, | |
xmin=None, xmax=None, | |||
ymin=None, ymax=None, | |||
xlabel='', ylabel='', | |||
title='', | |||
**kwargs): | |||
|
r897 | ||
|
r240 | if self.__firsttime: | |
|
r897 | ||
|
r240 | if xmin == None: xmin = numpy.nanmin(x) | |
if xmax == None: xmax = numpy.nanmax(x) | |||
if ymin == None: ymin = numpy.nanmin(y) | |||
if ymax == None: ymax = numpy.nanmax(y) | |||
|
r897 | ||
|
r240 | self.plot = self.__driver.createPmultilineYAxis(self.ax, x, y, | |
xmin, xmax, | |||
ymin, ymax, | |||
xlabel=xlabel, | |||
ylabel=ylabel, | |||
title=title, | |||
**kwargs) | |||
|
r245 | if self.xmin == None: self.xmin = xmin | |
if self.xmax == None: self.xmax = xmax | |||
if self.ymin == None: self.ymin = ymin | |||
if self.ymax == None: self.ymax = ymax | |||
|
r897 | ||
|
r240 | self.__firsttime = False | |
return | |||
|
r897 | ||
|
r240 | self.__driver.pmultilineyaxis(self.plot, x, y, xlabel=xlabel, | |
ylabel=ylabel, | |||
title=title) | |||
|
r897 | ||
|
r631 | # self.__driver.pause() | |
|
r897 | ||
|
r201 | def pcolor(self, x, y, z, | |
xmin=None, xmax=None, | |||
ymin=None, ymax=None, | |||
zmin=None, zmax=None, | |||
xlabel='', ylabel='', | |||
|
r813 | title='', colormap='jet', | |
|
r201 | **kwargs): | |
|
r897 | ||
|
r201 | """ | |
Input: | |||
|
r897 | x : | |
y : | |||
|
r201 | x : | |
xmin : | |||
xmax : | |||
ymin : | |||
ymax : | |||
zmin : | |||
zmax : | |||
xlabel : | |||
ylabel : | |||
title : | |||
**kwargs : Los parametros aceptados son | |||
ticksize=9, | |||
cblabel='' | |||
""" | |||
|
r897 | ||
|
r813 | #Decimating data | |
xlen = len(x) | |||
ylen = len(y) | |||
|
r897 | ||
decimationx = int(xlen/self.__MAXNUMX) + 1 | |||
|
r876 | decimationy = int(ylen/self.__MAXNUMY) + 1 | |
|
r897 | ||
|
r860 | x_buffer = x#[::decimationx] | |
|
r897 | y_buffer = y#[::decimationy] | |
|
r860 | z_buffer = z#[::decimationx, ::decimationy] | |
|
r813 | #=================================================== | |
|
r897 | ||
|
r210 | if self.__firsttime: | |
|
r897 | ||
|
r201 | if xmin == None: xmin = numpy.nanmin(x) | |
if xmax == None: xmax = numpy.nanmax(x) | |||
if ymin == None: ymin = numpy.nanmin(y) | |||
if ymax == None: ymax = numpy.nanmax(y) | |||
if zmin == None: zmin = numpy.nanmin(z) | |||
if zmax == None: zmax = numpy.nanmax(z) | |||
|
r897 | ||
|
r813 | self.plot = self.__driver.createPcolor(self.ax, x_buffer, | |
y_buffer, | |||
z_buffer, | |||
|
r201 | xmin, xmax, | |
ymin, ymax, | |||
zmin, zmax, | |||
xlabel=xlabel, | |||
ylabel=ylabel, | |||
title=title, | |||
|
r229 | colormap=colormap, | |
|
r201 | **kwargs) | |
|
r897 | ||
|
r210 | if self.xmin == None: self.xmin = xmin | |
if self.xmax == None: self.xmax = xmax | |||
if self.ymin == None: self.ymin = ymin | |||
if self.ymax == None: self.ymax = ymax | |||
if self.zmin == None: self.zmin = zmin | |||
if self.zmax == None: self.zmax = zmax | |||
|
r897 | ||
|
r210 | self.__firsttime = False | |
|
r201 | return | |
|
r897 | ||
|
r813 | self.__driver.pcolor(self.plot, | |
z_buffer, | |||
|
r210 | xlabel=xlabel, | |
ylabel=ylabel, | |||
title=title) | |||
|
r897 | ||
|
r631 | # self.__driver.pause() | |
|
r897 | ||
|
r318 | def pcolorbuffer(self, x, y, z, | |
xmin=None, xmax=None, | |||
ymin=None, ymax=None, | |||
zmin=None, zmax=None, | |||
xlabel='', ylabel='', | |||
|
r396 | title='', rti = True, colormap='jet', | |
|
r395 | maxNumX = None, maxNumY = None, | |
|
r318 | **kwargs): | |
|
r897 | ||
|
r395 | if maxNumX == None: | |
|
r813 | maxNumX = self.__MAXNUMTIME | |
|
r897 | ||
|
r395 | if maxNumY == None: | |
|
r897 | maxNumY = self.__MAXNUMY | |
if self.__firsttime: | |||
|
r318 | self.z_buffer = z | |
self.x_buffer = numpy.hstack((self.x_buffer, x)) | |||
|
r897 | ||
|
r318 | if xmin == None: xmin = numpy.nanmin(x) | |
if xmax == None: xmax = numpy.nanmax(x) | |||
if ymin == None: ymin = numpy.nanmin(y) | |||
if ymax == None: ymax = numpy.nanmax(y) | |||
if zmin == None: zmin = numpy.nanmin(z) | |||
if zmax == None: zmax = numpy.nanmax(z) | |||
|
r897 | ||
|
r318 | self.plot = self.__driver.createPcolor(self.ax, self.x_buffer, y, z, | |
xmin, xmax, | |||
ymin, ymax, | |||
zmin, zmax, | |||
xlabel=xlabel, | |||
ylabel=ylabel, | |||
title=title, | |||
colormap=colormap, | |||
**kwargs) | |||
|
r897 | ||
|
r318 | if self.xmin == None: self.xmin = xmin | |
if self.xmax == None: self.xmax = xmax | |||
if self.ymin == None: self.ymin = ymin | |||
if self.ymax == None: self.ymax = ymax | |||
if self.zmin == None: self.zmin = zmin | |||
if self.zmax == None: self.zmax = zmax | |||
|
r897 | ||
|
r396 | self.__firsttime = False | |
return | |||
|
r897 | ||
|
r779 | self.x_buffer = numpy.hstack((self.x_buffer[:-1], x[0], x[-1])) | |
|
r396 | self.z_buffer = numpy.hstack((self.z_buffer, z)) | |
|
r813 | z_buffer = self.z_buffer.reshape(-1,len(y)) | |
|
r897 | ||
|
r813 | #Decimating data | |
xlen = len(self.x_buffer) | |||
ylen = len(y) | |||
|
r897 | ||
|
r876 | decimationx = int(xlen/maxNumX) + 1 | |
decimationy = int(ylen/maxNumY) + 1 | |||
|
r897 | ||
|
r860 | x_buffer = self.x_buffer#[::decimationx] | |
|
r897 | y_buffer = y#[::decimationy] | |
|
r860 | z_buffer = z_buffer#[::decimationx, ::decimationy] | |
|
r396 | #=================================================== | |
|
r897 | ||
|
r396 | x_buffer, y_buffer, z_buffer = self.__fillGaps(x_buffer, y_buffer, z_buffer) | |
|
r897 | ||
|
r396 | self.__driver.addpcolorbuffer(self.ax, x_buffer, y_buffer, z_buffer, self.zmin, self.zmax, | |
xlabel=xlabel, | |||
ylabel=ylabel, | |||
title=title, | |||
colormap=colormap) | |||
|
r897 | ||
|
r631 | # self.__driver.pause() | |
|
r897 | ||
|
r502 | def polar(self, x, y, | |
title='', xlabel='',ylabel='',**kwargs): | |||
|
r897 | ||
|
r502 | if self.__firsttime: | |
self.plot = self.__driver.createPolar(self.ax, x, y, title = title, xlabel = xlabel, ylabel = ylabel) | |||
self.__firsttime = False | |||
self.x_buffer = x | |||
self.y_buffer = y | |||
return | |||
|
r897 | ||
|
r502 | self.x_buffer = numpy.hstack((self.x_buffer,x)) | |
self.y_buffer = numpy.hstack((self.y_buffer,y)) | |||
self.__driver.polar(self.plot, self.x_buffer, self.y_buffer, xlabel=xlabel, | |||
ylabel=ylabel, | |||
title=title) | |||
|
r897 | ||
|
r631 | # self.__driver.pause() | |
|
r897 | ||
|
r396 | def __fillGaps(self, x_buffer, y_buffer, z_buffer): | |
|
r897 | ||
|
r657 | if x_buffer.shape[0] < 2: | |
return x_buffer, y_buffer, z_buffer | |||
|
r897 | ||
|
r396 | deltas = x_buffer[1:] - x_buffer[0:-1] | |
x_median = numpy.median(deltas) | |||
|
r897 | ||
|
r663 | index = numpy.where(deltas > 5*x_median) | |
|
r897 | ||
|
r396 | if len(index[0]) != 0: | |
z_buffer[index[0],::] = self.__missing | |||
z_buffer = numpy.ma.masked_inside(z_buffer,0.99*self.__missing,1.01*self.__missing) | |||
|
r1167 | return x_buffer, y_buffer, z_buffer |