schain Commit - r211:d98d98fc1eef · Jicamarca Repository

Se adecuo el ancho del colorbar de acuerdo al tipo de grafico

Miguel Valdez -

r211:d98d98fc1eef

parent child

Context file:

r211:d98d98fc1eef

Collapse all files

schainpy/model/graphics/mpldriver.py +3 -4

             import numpy
             import datetime
             import matplotlib
             matplotlib.use("TKAgg")
             import matplotlib.pyplot
             import matplotlib.dates
             #import scitools.numpyutils
             from mpl_toolkits.axes_grid1 import make_axes_locatable
             from matplotlib.dates import DayLocator, HourLocator, MinuteLocator, SecondLocator, DateFormatter
             from matplotlib.ticker import FuncFormatter
             from matplotlib.ticker import *
             def init(idfigure, wintitle, width, height, facecolor="w"):
                 matplotlib.pyplot.ioff()
                 fig = matplotlib.pyplot.matplotlib.pyplot.figure(num=idfigure, facecolor=facecolor)
                 fig.canvas.manager.set_window_title(wintitle)
                 fig.canvas.manager.resize(width, height)
                 matplotlib.pyplot.ion()
                 return fig
             def setWinTitle(fig, title):
                 fig.canvas.manager.set_window_title(title)
             def setTitle(idfigure, title):
                 fig = matplotlib.pyplot.figure(idfigure)
                 fig.suptitle(title)
             def makeAxes(idfigure, nrow, ncol, xpos, ypos, colspan, rowspan):
                 fig = matplotlib.pyplot.figure(idfigure)
                 ax = matplotlib.pyplot.subplot2grid((nrow, ncol), (xpos, ypos), colspan=colspan, rowspan=rowspan)
                 return ax
             def setTextFromAxes(idfigure, ax, title):
                 fig = matplotlib.pyplot.figure(idfigure)
                 ax.annotate(title, xy=(.1, .99),
                             xycoords='figure fraction',
                             horizontalalignment='left', verticalalignment='top',
                             fontsize=10)
             def pline(ax, x, y, xmin, xmax, ymin, ymax, xlabel, ylabel, title, firsttime):
                 if firsttime:
                     ax.plot(x, y)
                     ax.set_xlim([xmin,xmax])
                     ax.set_ylim([ymin,ymax])
                     ax.set_xlabel(xlabel, size=8)
                     ax.set_ylabel(ylabel, size=8)
                     ax.set_title(title, size=10)
                     matplotlib.pyplot.tight_layout()
                 else:
                     ax.lines[0].set_data(x,y)
             def draw(idfigure):
                 fig = matplotlib.pyplot.figure(idfigure)
                 fig.canvas.draw()
             def pcolor(ax, x, y, z, xmin, xmax, ymin, ymax, zmin, zmax, xlabel, ylabel, title, firsttime, mesh):
                 if firsttime:
                     divider = make_axes_locatable(ax)
                     ax_cb = divider.new_horizontal(size="4%", pad=0.05)
                     fig1 = ax.get_figure()
                     fig1.add_axes(ax_cb)
                     ax.set_xlim([xmin,xmax])
                     ax.set_ylim([ymin,ymax])
                     ax.set_xlabel(xlabel)
                     ax.set_ylabel(ylabel)
                     ax.set_title(title)
                     print x
                     imesh=ax.pcolormesh(x,y,z.T,vmin=zmin,vmax=zmax)
                     matplotlib.pyplot.colorbar(imesh, cax=ax_cb)
                     ax_cb.yaxis.tick_right()
                     for tl in ax_cb.get_yticklabels():
                         tl.set_visible(True)
                     ax_cb.yaxis.tick_right()
                     matplotlib.pyplot.tight_layout()
                     return imesh
                 else:
             #        ax.set_xlim([xmin,xmax])
             #        ax.set_ylim([ymin,ymax])
                     ax.set_xlabel(xlabel)
                     ax.set_ylabel(ylabel)
                     ax.set_title(title)
                     z = z.T
             #        z = z[0:-1,0:-1]
                     mesh.set_array(z.ravel())
                     return mesh
             ###########################################
             #Actualizacion de las funciones del driver
             ###########################################
             def createFigure(idfigure, wintitle, width, height, facecolor="w"):
                 matplotlib.pyplot.ioff()
                 fig = matplotlib.pyplot.matplotlib.pyplot.figure(num=idfigure, facecolor=facecolor)
                 fig.canvas.manager.set_window_title(wintitle)
                 fig.canvas.manager.resize(width, height)
                 matplotlib.pyplot.ion()
                 return fig
             def closeFigure():
                 matplotlib.pyplot.ioff()
                 matplotlib.pyplot.show()
                 return
             def saveFigure(fig, filename):
                 fig.savefig(filename)
             def setWinTitle(fig, title):
                 fig.canvas.manager.set_window_title(title)
             def setTitle(fig, title):
                 fig.suptitle(title)
             def createAxes(fig, nrow, ncol, xpos, ypos, colspan, rowspan):
                 matplotlib.pyplot.figure(fig.number)
                 axes = matplotlib.pyplot.subplot2grid((nrow, ncol),
                                                     (xpos, ypos),
                                                     colspan=colspan,
                                                     rowspan=rowspan)
                 return axes
             def setAxesText(ax, text):
                 ax.annotate(text,
                             xy = (.1, .99),
                             xycoords = 'figure fraction',
                             horizontalalignment = 'left',
                             verticalalignment = 'top',
                             fontsize = 10)
             def printLabels(ax, xlabel, ylabel, title):
                 ax.set_xlabel(xlabel, size=11)
                 ax.set_ylabel(ylabel, size=11)
                 ax.set_title(title, size=12)
             def createPline(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', title='',
                             ticksize=9, xtick_visible=True, ytick_visible=True,
                             nxticks=4, nyticks=10,
                             grid=None):
                 """
                 Input:
                     grid    :    None, 'both', 'x', 'y'
                 """
                 ax.plot(x, y)
                 ax.set_xlim([xmin,xmax])
                 ax.set_ylim([ymin,ymax])
                 printLabels(ax, xlabel, ylabel, title)
                 ######################################################
                 xtickspos = numpy.arange(nxticks)*int((xmax-xmin)/nxticks) + int(xmin)
                 ax.set_xticks(xtickspos)
                 for tick in ax.get_xticklabels():
                     tick.set_visible(xtick_visible)
                 for tick in ax.xaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 ######################################################
                 for tick in ax.get_yticklabels():
                     tick.set_visible(ytick_visible)
                 for tick in ax.yaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 ######################################################
                 if grid != None:
                     ax.grid(b=True, which='major', axis=grid)
                 matplotlib.pyplot.tight_layout()
                 iplot = ax.lines[-1]
                 return iplot
             def pline(iplot, x, y, xlabel='', ylabel='', title=''):
                 ax = iplot.get_axes()
                 printLabels(ax, xlabel, ylabel, title)
                 iplot.set_data(x, y)
             def createPcolor(ax, x, y, z, xmin, xmax, ymin, ymax, zmin, zmax,
                              xlabel='', ylabel='', title='', ticksize = 9,
-                             cblabel='',XAxisAsTime=False):
+                             cblabel='', cbsize="5%",
+                             XAxisAsTime=False):
                 divider = make_axes_locatable(ax)
-                ax_cb = divider.new_horizontal(size="4%", pad=0.05)
+                ax_cb = divider.new_horizontal(size=cbsize, pad=0.05)
                 fig = ax.get_figure()
                 fig.add_axes(ax_cb)
                 ax.set_xlim([xmin,xmax])
                 ax.set_ylim([ymin,ymax])
                 printLabels(ax, xlabel, ylabel, title)
                 imesh = ax.pcolormesh(x,y,z.T,vmin=zmin,vmax=zmax)
                 cb =  matplotlib.pyplot.colorbar(imesh, cax=ax_cb)
                 cb.set_label(cblabel)
-                ax_cb.yaxis.tick_right()
             #    for tl in ax_cb.get_yticklabels():
             #        tl.set_visible(True)
                 for tick in ax.yaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 for tick in ax.xaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 for tick in cb.ax.get_yticklabels():
                     tick.set_fontsize(ticksize)
                 ax_cb.yaxis.tick_right()
                 matplotlib.pyplot.tight_layout()
                 if XAxisAsTime:
                     func = lambda x, pos: ('%s') %(datetime.datetime.fromtimestamp(x).strftime("%H:%M:%S"))
                     ax.xaxis.set_major_formatter(FuncFormatter(func))
                     ax.xaxis.set_major_locator(LinearLocator(7))
             #        seconds = numpy.array([xmin, xmax])
             #        datesList = map(datetime.datetime.fromtimestamp, seconds)
             #        ax.set_xlim([datesList[0],datesList[-1]])
             #        ax.xaxis.set_major_locator(MinuteLocator(numpy.arange(0,61,10)))
             #        ax.xaxis.set_minor_locator(SecondLocator(numpy.arange(0,61,60)))
             #        ax.xaxis.set_major_formatter(DateFormatter("%H:%M:%S"))
             #        xdateList = map(datetime.datetime.fromtimestamp, x)
             #        xdate = matplotlib.dates.date2num(xdateList)
             #        x = xdate
             #        labels = []
             #        for item in ax.xaxis.get_ticklabels():
             #            stri = item.get_text()
             #            text = datetime.datetime.fromtimestamp(float(stri))
             #            labels.append(text)
             #
             #        ax.xaxis.set_ticklabels(labels)
                 return imesh
             def pcolor(imesh, z, xlabel='', ylabel='', title=''):
                 z = z.T
                 ax = imesh.get_axes()
                 printLabels(ax, xlabel, ylabel, title)
                 imesh.set_array(z.ravel())
             def addpcolor(ax, x, y, z, zmin, zmax, xlabel='', ylabel='', title=''):
             #    xdateList = map(datetime.datetime.fromtimestamp, x)
             #    xdate = matplotlib.dates.date2num(xdateList)
                 printLabels(ax, xlabel, ylabel, title)
                 imesh = ax.pcolormesh(x,y,z.T,vmin=zmin,vmax=zmax)
             def draw(fig):
                 if type(fig) == 'int':
                     raise ValueError, "This parameter should be of tpye matplotlib figure"
                 fig.canvas.draw()

schainpy/model/jroplot.py +1 -1

             import numpy
             import time, datetime
             from graphics.figure import  *
             class RTIPlot(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 def __init__(self):
                     self.__timerange = 24*60*60
                     self.__isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 800
                     self.HEIGHT = 300
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                 def getSubplots(self):
                     ncol = 1
                     nrow = self.nplots
                     return nrow, ncol
                 def setup(self, idfigure, nplots, wintitle, showprofile=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 7
                         colspan = 6
                         self.__nsubplots = 2
                     self.createFigure(idfigure = idfigure,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                             counter += 1
                 def __getTimeLim(self, x, xmin, xmax):
                     thisdatetime = datetime.datetime.fromtimestamp(numpy.min(x))
                     thisdate = datetime.datetime.combine(thisdatetime.date(), datetime.time(0,0,0))
                     ####################################################
                     #If the x is out of xrange
                     if xmax < (thisdatetime - thisdate).seconds/(60*60.):
                         xmin = None
                         xmax = None
                     if xmin == None:
                         td = thisdatetime - thisdate
                         xmin = td.seconds/(60*60.)
                     if xmax == None:
                         xmax = xmin + self.__timerange/(60*60.)
                     mindt = thisdate + datetime.timedelta(0,0,0,0,0, xmin)
                     tmin = time.mktime(mindt.timetuple())
                     maxdt = thisdate + datetime.timedelta(0,0,0,0,0, xmax)
                     tmax = time.mktime(maxdt.timetuple())
                     self.__timerange = tmax - tmin
                     return tmin, tmax
                 def run(self, dataOut, idfigure, wintitle="", channelList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         timerange=None,
                         save=False, filename=None):
                     """
                     Input:
                         dataOut         :
                         idfigure        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError, "Channel %d is not in dataOut.channelList"
                             channelIndexList.append(channel)
                     if timerange != None:
                         self.__timerange = timerange
                     tmin = None
                     tmax = None
                     x = dataOut.getDatatime()
                     y = dataOut.getHeiRange()
                     z = 10.*numpy.log10(dataOut.data_spc[channelIndexList,:,:])
                     avg = numpy.average(z, axis=1)
                     noise = dataOut.getNoise()
                     if not self.__isConfig:
                         nplots = len(channelIndexList)
                         self.setup(idfigure=idfigure,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile)
                         tmin, tmax = self.__getTimeLim(x, xmin, xmax)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = numpy.nanmin(avg)*0.9
                         if zmax == None: zmax = numpy.nanmax(avg)*0.9
                         self.__isConfig = True
                     thisDatetime = datetime.datetime.fromtimestamp(dataOut.utctime)
                     title = "RTI: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = "Velocity (m/s)"
                     ylabel = "Range (Km)"
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         title = "Channel %d: %s" %(dataOut.channelList[i], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                         axes = self.axesList[i*self.__nsubplots]
                         z = avg[i].reshape((1,-1))
                         axes.pcolor(x, y, z,
                                     xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
-                                    ticksize=9, cblabel='')
+                                    ticksize=9, cblabel='', cbsize="1%")
                         if self.__showprofile:
                             axes = self.axesList[i*self.__nsubplots +1]
                             axes.pline(avg[i], y,
                                     xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
                                     xlabel='dB', ylabel='', title='',
                                     ytick_visible=False,
                                     grid='x')
                     self.draw()
                     if save:
                         self.saveFigure(filename)
                     if x[1] + (x[1]-x[0]) >= self.axesList[0].xmax:
                         self.__isConfig = False
             class SpectraPlot(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 def __init__(self):
                     self.__isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 300
                     self.HEIGHT = 400
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                 def getSubplots(self):
                     ncol = int(numpy.sqrt(self.nplots)+0.9)
                     nrow = int(self.nplots*1./ncol + 0.9)
                     return nrow, ncol
                 def setup(self, idfigure, nplots, wintitle, showprofile=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 3
                         colspan = 2
                         self.__nsubplots = 2
                     self.createFigure(idfigure = idfigure,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                             counter += 1
                 def run(self, dataOut, idfigure, wintitle="", channelList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None, save=False, filename=None):
                     """
                     Input:
                         dataOut         :
                         idfigure        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError, "Channel %d is not in dataOut.channelList"
                             channelIndexList.append(channel)
                     x = dataOut.getVelRange(1)
                     y = dataOut.getHeiRange()
                     z = 10.*numpy.log10(dataOut.data_spc[channelIndexList,:,:])
                     avg = numpy.average(z, axis=1)
                     noise = dataOut.getNoise()
                     if not self.__isConfig:
                         nplots = len(channelIndexList)
                         self.setup(idfigure=idfigure,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile)
                         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(avg)*0.9
                         if zmax == None: zmax = numpy.nanmax(avg)*0.9
                         self.__isConfig = True
                     thisDatetime = datetime.datetime.fromtimestamp(dataOut.utctime)
                     title = "Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = "Velocity (m/s)"
                     ylabel = "Range (Km)"
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         title = "Channel %d: %4.2fdB" %(dataOut.channelList[i], noise[i])
                         axes = self.axesList[i*self.__nsubplots]
                         axes.pcolor(x, y, z[i,:,:],
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, cblabel='')
                         if self.__showprofile:
                             axes = self.axesList[i*self.__nsubplots +1]
                             axes.pline(avg[i], y,
                                     xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
                                     xlabel='dB', ylabel='', title='',
                                     ytick_visible=False,
                                     grid='x')
                     self.draw()
                     if save:
                         self.saveFigure(filename)
             class Scope(Figure):
                 __isConfig = None
                 def __init__(self):
                     self.__isConfig = False
                     self.WIDTH = 600
                     self.HEIGHT = 200
                 def getSubplots(self):
                     nrow = self.nplots
                     ncol = 3
                     return nrow, ncol
                 def setup(self, idfigure, nplots, wintitle):
                     self.createFigure(idfigure, wintitle)
                     nrow,ncol = self.getSubplots()
                     colspan = 3
                     rowspan = 1
                     for i in range(nplots):
                         self.addAxes(nrow, ncol, i, 0, colspan, rowspan)
                     self.nplots = nplots
                 def run(self, dataOut, idfigure, wintitle="", channelList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None, save=False, filename=None):
                     """
                     Input:
                         dataOut         :
                         idfigure        :
                         wintitle        :
                         channelList     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                     """
                     if channelList == None:
                         channelList = dataOut.channelList
                     x = dataOut.heightList
                     y = dataOut.data[channelList,:] * numpy.conjugate(dataOut.data[channelList,:])
                     y = y.real
                     noise = dataOut.getNoise()
                     if not self.__isConfig:
                         nplots = len(channelList)
                         self.setup(idfigure=idfigure,
                                    nplots=nplots,
                                    wintitle=wintitle)
                         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)
                         self.__isConfig = True
                     thisDatetime = datetime.datetime.fromtimestamp(dataOut.utctime)
                     title = "Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = "Range (Km)"
                     ylabel = "Intensity"
                     self.setWinTitle(title)
                     for i in range(len(self.axesList)):
                         title = "Channel %d: %4.2fdB" %(i, noise[i])
                         axes = self.axesList[i]
                         ychannel = y[i,:]
                         axes.pline(x, ychannel,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                                     xlabel=xlabel, ylabel=ylabel, title=title)
                     self.draw()
                     if save:
                         self.saveFigure(filename)
   No newline at end of file

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages