"""
Created on Feb 7, 2012

@autor $Author$
@version $Id$

"""
import os
import numpy
import sys
import time 
import datetime
import time
import plplot


def cmap1_init(colormap="gray"):
    
    if colormap == None:
        return
        
    ncolor = None
    rgb_lvl = None
    
    # Routine for defining a specific color map 1 in HLS space.
    # if gray is true, use basic grayscale variation from half-dark to light.
    # otherwise use false color variation from blue (240 deg) to red (360 deg).

    # Independent variable of control points.
    i = numpy.array((0., 1.))
    if colormap=="gray":
        ncolor = 256
        # Hue for control points.  Doesn't matter since saturation is zero.
        h = numpy.array((0., 0.))
        # Lightness ranging from half-dark (for interest) to light.
        l = numpy.array((0.5, 1.))
        # Gray scale has zero saturation
        s = numpy.array((0., 0.))
        
        # number of cmap1 colours is 256 in this case.
        plplot.plscmap1n(ncolor)
        # Interpolate between control points to set up cmap1.
        plplot.plscmap1l(0, i, h, l, s)
        
        return None
    
    if colormap == 'jet':
        ncolor = 256          
        pos = numpy.zeros((ncolor))
        r = numpy.zeros((ncolor))
        g = numpy.zeros((ncolor))
        b = numpy.zeros((ncolor))
        
        for i in range(ncolor):
            if(i <= 35.0/100*(ncolor-1)): rf = 0.0
            elif (i <= 66.0/100*(ncolor-1)): rf = (100.0/31)*i/(ncolor-1) - 35.0/31
            elif (i <= 89.0/100*(ncolor-1)): rf = 1.0
            else: rf = (-100.0/22)*i/(ncolor-1) + 111.0/22
    
            if(i <= 12.0/100*(ncolor-1)): gf = 0.0
            elif(i <= 38.0/100*(ncolor-1)): gf = (100.0/26)*i/(ncolor-1) - 12.0/26
            elif(i <= 64.0/100*(ncolor-1)): gf = 1.0
            elif(i <= 91.0/100*(ncolor-1)): gf = (-100.0/27)*i/(ncolor-1) + 91.0/27
            else: gf = 0.0
    
            if(i <= 11.0/100*(ncolor-1)): bf = (50.0/11)*i/(ncolor-1) + 0.5
            elif(i <= 34.0/100*(ncolor-1)): bf = 1.0
            elif(i <= 65.0/100*(ncolor-1)): bf = (-100.0/31)*i/(ncolor-1) + 65.0/31
            else: bf = 0           
            
            r[i] = rf
            g[i] = gf
            b[i] = bf
        
            pos[i] = float(i)/float(ncolor-1)
        

        plplot.plscmap1n(ncolor)
        plplot.plscmap1l(1, pos, r, g, b)
    
    
    
    if colormap=="br_green":
        ncolor = 256
        # Hue ranges from blue (240 deg) to red (0 or 360 deg)
        h = numpy.array((240., 0.))
        # Lightness and saturation are constant (values taken from C example).
        l = numpy.array((0.6, 0.6))
        s = numpy.array((0.8, 0.8))

        # number of cmap1 colours is 256 in this case.
        plplot.plscmap1n(ncolor)
        # Interpolate between control points to set up cmap1.
        plplot.plscmap1l(0, i, h, l, s)
        
        return None
    
    if colormap=="tricolor":
        ncolor = 3
        # Hue ranges from blue (240 deg) to red (0 or 360 deg)
        h = numpy.array((240., 0.))
        # Lightness and saturation are constant (values taken from C example).
        l = numpy.array((0.6, 0.6))
        s = numpy.array((0.8, 0.8))

        # number of cmap1 colours is 256 in this case.
        plplot.plscmap1n(ncolor)
        # Interpolate between control points to set up cmap1.
        plplot.plscmap1l(0, i, h, l, s)
        
        return None
    
    if colormap == 'rgb' or colormap == 'rgb666':
        
        color_sz = 6
        ncolor = color_sz*color_sz*color_sz
        pos = numpy.zeros((ncolor))
        r = numpy.zeros((ncolor))
        g = numpy.zeros((ncolor))
        b = numpy.zeros((ncolor))
        ind = 0
        for ri in range(color_sz):
            for gi in range(color_sz):
                for bi in range(color_sz):
                    r[ind] = ri/(color_sz-1.0)
                    g[ind] = gi/(color_sz-1.0)
                    b[ind] = bi/(color_sz-1.0)
                    pos[ind] = ind/(ncolor-1.0)
                    ind += 1
        rgb_lvl = [6,6,6]  #Levels for RGB colors
        
    if colormap == 'rgb676':
        ncolor = 6*7*6
        pos = numpy.zeros((ncolor))
        r = numpy.zeros((ncolor))
        g = numpy.zeros((ncolor))
        b = numpy.zeros((ncolor))
        ind = 0
        for ri in range(8):
            for gi in range(8):
                for bi in range(4):
                    r[ind] = ri/(6-1.0)
                    g[ind] = gi/(7-1.0)
                    b[ind] = bi/(6-1.0)
                    pos[ind] = ind/(ncolor-1.0)
                    ind += 1
        rgb_lvl = [6,7,6]  #Levels for RGB colors
    
    if colormap == 'rgb685':
        ncolor = 6*8*5
        pos = numpy.zeros((ncolor))
        r = numpy.zeros((ncolor))
        g = numpy.zeros((ncolor))
        b = numpy.zeros((ncolor))
        ind = 0
        for ri in range(8):
            for gi in range(8):
                for bi in range(4):
                    r[ind] = ri/(6-1.0)
                    g[ind] = gi/(8-1.0)
                    b[ind] = bi/(5-1.0)
                    pos[ind] = ind/(ncolor-1.0)
                    ind += 1
        rgb_lvl = [6,8,5]  #Levels for RGB colors
                    
    if colormap == 'rgb884':
        ncolor = 8*8*4
        pos = numpy.zeros((ncolor))
        r = numpy.zeros((ncolor))
        g = numpy.zeros((ncolor))
        b = numpy.zeros((ncolor))
        ind = 0
        for ri in range(8):
            for gi in range(8):
                for bi in range(4):
                    r[ind] = ri/(8-1.0)
                    g[ind] = gi/(8-1.0)
                    b[ind] = bi/(4-1.0)
                    pos[ind] = ind/(ncolor-1.0)
                    ind += 1
        rgb_lvl = [8,8,4]  #Levels for RGB colors
    
    if ncolor == None:
        raise ValueError, "The colormap selected is not valid"
    
    plplot.plscmap1n(ncolor)
    plplot.plscmap1l(1, pos, r, g, b)
    
    return rgb_lvl

def setColormap(colormap="jet"):
    cmap1_init(colormap)

def savePlplot(filename,width,height):
    curr_strm = plplot.plgstrm()
    save_strm = plplot.plmkstrm()
    plplot.plsetopt("geometry", "%dx%d"%(width,height))
    plplot.plsdev("png")
    plplot.plsfnam(filename)
    plplot.plcpstrm(curr_strm,0)
    plplot.plreplot()
    plplot.plend1()
    plplot.plsstrm(curr_strm)
    

def initPlplot(indexPlot,ncol,nrow,winTitle,width,height):
    plplot.plsstrm(indexPlot)
    plplot.plparseopts([winTitle],plplot.PL_PARSE_FULL)
    plplot.plsetopt("geometry", "%dx%d"%(width*ncol,height*nrow))
    plplot.plsdev("xwin")
    plplot.plscolbg(255,255,255)
    plplot.plscol0(1,0,0,0)
    plplot.plinit()
    plplot.plspause(False)
    plplot.plssub(ncol,nrow)

def setNewPage():
    plplot.plbop()
    plplot.pladv(0)

def closePage():
    plplot.pleop()
    
def clearData(objGraph):
    objGraph.plotBox(objGraph.xrange[0], objGraph.xrange[1], objGraph.yrange[0], objGraph.yrange[1], "bc", "bc")
    
    objGraph.setColor(15) #Setting Line Color to White
    
    if objGraph.datatype == "complex":        
        objGraph.basicXYPlot(objGraph.xdata,objGraph.ydata.real)
        objGraph.basicXYPlot(objGraph.xdata,objGraph.ydata.imag)

    if objGraph.datatype == "real":
        objGraph.basicXYPlot(objGraph.xdata,objGraph.ydata)
    
    objGraph.setColor(1) #Setting Line Color to Black
#    objGraph.setLineStyle(2)
#    objGraph.plotBox(objGraph.xrange[0], objGraph.xrange[1], objGraph.yrange[0], objGraph.yrange[1], "bcntg", "bc")
#    objGraph.setLineStyle(1)

def setStrm(indexPlot):
    plplot.plsstrm(indexPlot)

def plFlush():
    plplot.plflush()

def plShow():
    plplot.plspause(True)
    plplot.plend()
    
def setPlTitle(pltitle,color, szchar=0.7):
    setSubpages(1, 0)
    plplot.pladv(0)
    plplot.plvpor(0., 1., 0., 1.)
    
    if color == "black":
        plplot.plcol0(1)
    if color == "white":
        plplot.plcol0(15)
    
    plplot.plschr(0.0,szchar)
    plplot.plmtex("t",-1., 0.5, 0.5, pltitle)
    
def setSubpages(ncol,nrow):
    plplot.plssub(ncol,nrow)

class BaseGraph:
    
    __name = None
    __xpos = None
    __ypos = None
    __subplot = None
    __xg = None
    __yg = None
    xdata = None
    ydata = None
    getGrid = True
    xaxisIsTime = False
    deltax = None
    xmin = None
    xmax = None
    
    def __init__(self,name,subplot,xpos,ypos,xlabel,ylabel,title,szchar,xrange,yrange,zrange=None,deltax=1.0):
        
        self.setName(name)
        self.setScreenPos(xpos, ypos)
        self.setLabels(xlabel,ylabel,title)
        self.setSubPlot(subplot)
        self.setSizeOfChar(szchar)
        self.setXYZrange(xrange,yrange,zrange)
        self.getGrid = True
        self.xaxisIsTime = False
        self.deltax = deltax
    
    def setXYZrange(self,xrange,yrange,zrange):
        self.xrange = xrange
        self.yrange = yrange
        self.zrange = zrange
        
    def setName(self, name):
        self.__name = name
    
    def setScreenPos(self,xpos,ypos):
        self.__xpos = xpos
        self.__ypos = ypos
    
    def setXYData(self,xdata=None,ydata=None,datatype="real"):
        if((xdata != None) and (ydata != None)):
            self.xdata = xdata
            self.ydata = ydata
            self.datatype = datatype
            
        if((self.xdata == None) and (self.ydata == None)):
            return None
        
        return 1
    
    
    def setLabels(self,xlabel=None,ylabel=None,title=None):
        if xlabel != None: self.xlabel = xlabel
        if ylabel != None: self.ylabel = ylabel
        if title != None: self.title = title
    
    def setSubPlot(self,subplot):
        self.__subplot = subplot
    
    def setSizeOfChar(self,szchar):
        self.__szchar = szchar
        
    def setLineStyle(self,style):
        plplot.pllsty(style)
    
    def setColor(self,color):
        plplot.plcol0(color)
    
    def setXAxisAsTime(self,value=False):
        self.xaxisIsTime = value
    
    def basicLineTimePlot(self, x, y, xmin=None, xmax=None, ymin=None, ymax=None, colline=1):
        
        if xmin == None: xmin = x[0]
        if xmax == None: xmax = x[-1]
        if ymin == None: ymin = y[0]
        if ymax == None: ymax = y[-1]
        
        plplot.plcol0(colline)
        plplot.plline(x, y)
        plplot.plcol0(1)
    
    def basicXYPlot(self, x, y, xmin=None, xmax=None, ymin=None, ymax=None):
        
        if xmin == None: xmin = x[0]
        if xmax == None: xmax = x[-1]
        if ymin == None: ymin = y[0]
        if ymax == None: ymax = y[-1]
        
        plplot.plline(x, y)
    
    def basicPcolorPlot(self, data, x, y, xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None):
        """
        """
        if xmin == None: xmin = x[0]
        if xmax == None: xmax = x[-1]
        if ymin == None: ymin = y[0]
        if ymax == None: ymax = y[-1]
        if zmin == None: zmin = numpy.nanmin(data)
        if zmax == None: zmax = numpy.nanmax(data)
        
        plplot.plimage(data,
                       float(x[0]),
                       float(x[-1]),
                       float(y[0]),
                       float(y[-1]),
                       float(zmin),
                       float(zmax),
                       float(xmin),
                       float(xmax),
                       float(ymin),
                       float(ymax)
                       )
    
    def __getBoxpltr(self, x, y, deltax=None, deltay=None):        
        
        if not(len(x)>0 and len(y)>0):
            raise ValueError, "x axis and y axis are empty"
        
        if deltax == None: deltax = x[-1] - x[-2]
        if deltay == None: deltay = y[-1] - y[-2]
        
        x1 = numpy.append(x, x[-1] + deltax)
        y1 = numpy.append(y, y[-1] + deltay)
        
        xg = (numpy.multiply.outer(x1, numpy.ones(len(y1))))
        yg = (numpy.multiply.outer(numpy.ones(len(x1)), y1))
        
        self.__xg = xg
        self.__yg = yg
        
        return xg, yg
    
    
    def advPcolorPlot(self, data, x, y, xmin=None, xmax=None, ymin=None, ymax=None, zmin=0., zmax=0., deltax=1.0, deltay=None, getGrid = True):
        if getGrid:
            xg, yg = self.__getBoxpltr(x, y, deltax, deltay)
        else:
            xg = self.__xg
            yg = self.__yg    
        
        plplot.plimagefr(data, 
                         float(xmin), 
                         float(xmax), 
                         float(ymin), 
                         float(ymax), 
                         0., 
                         0., 
                         float(zmin), 
                         float(zmax), 
                         plplot.pltr2, 
                         xg, 
                         yg)


    def colorbarPlot(self, xmin=0., xmax=1., ymin=0., ymax=1.):
        data = numpy.arange(256)
        data = numpy.reshape(data, (1,-1))
        
        plplot.plimage(data,
                       float(xmin),
                       float(xmax),
                       float(ymin),
                       float(ymax),
                       0.,
                       255.,
                       float(xmin),
                       float(xmax),
                       float(ymin),
                       float(ymax))

    def plotBox(self, xmin, xmax, ymin, ymax, xopt, yopt, nolabels=False):
        
        plplot.plschr(0.0,self.__szchar-0.05)
        plplot.pladv(self.__subplot)
        plplot.plvpor(self.__xpos[0], self.__xpos[1], self.__ypos[0], self.__ypos[1])
        plplot.plwind(float(xmin), # self.xrange[0]
                      float(xmax), # self.xrange[1]
                      float(ymin), # self.yrange[0]
                      float(ymax) # self.yrange[1]
                      )
        
        
        
        if self.xaxisIsTime:
            plplot.pltimefmt("%H:%M")
            timedelta = (xmax - xmin + 1)/8.
            plplot.plbox(xopt, timedelta, 3, yopt, 0.0, 0)
        else:
            plplot.plbox(xopt, 0.0, 0, yopt, 0.0, 0)
        
        
        if not(nolabels):
            plplot.pllab(self.xlabel, self.ylabel, self.title)


    def delLabels(self):
        self.setColor(15) #Setting Line Color to White
        plplot.pllab(self.xlabel, self.ylabel, self.title)
        self.setColor(1) #Setting Line Color to Black
        
        
    
    def plotImage(self,x,y,z,xrange,yrange,zrange):
        xi = x[0]
        xf = x[-1]
        yi = y[0]
        yf = y[-1]
        
        plplot.plimage(z, 
                       float(xi), 
                       float(xf), 
                       float(yi), 
                       float(yf), 
                       float(zrange[0]), 
                       float(zrange[1]), 
                       float(xi), 
                       float(xf), 
                       float(yrange[0]), 
                       yrange[1])

class LinearPlot:
    linearObjDic = {}
    __xpos = None
    __ypos = None
    def __init__(self,indexPlot,nsubplot,winTitle):
        self.width = 700
        self.height = 150
        ncol = 1
        nrow = nsubplot
        initPlplot(indexPlot,ncol,nrow,winTitle,self.width,self.height)
    
    
    def setFigure(self,indexPlot):
        setStrm(indexPlot)
        
    def setPosition(self): 
        
        xi = 0.07; xf = 0.9 #0.8,0.7,0.5 
        yi = 0.15; yf = 0.8
        
        xpos = [xi,xf]
        ypos = [yi,yf]
        
        self.__xpos = xpos
        self.__ypos = ypos
        
        return xpos,ypos
    
    def show(self):
        plShow()
        
    def refresh(self):
        plFlush()
        
    def setup(self,subplot,xmin,xmax,ymin,ymax,title,xlabel,ylabel):
        szchar = 1.10
        name = "linear"
        key = name + "%d"%subplot
        xrange = [xmin,xmax]
        yrange = [ymin,ymax]
        
        xpos,ypos = self.setPosition()
        linearObj = BaseGraph(name,subplot,xpos,ypos,xlabel,ylabel,title,szchar,xrange,yrange)
        linearObj.plotBox(linearObj.xrange[0], linearObj.xrange[1], linearObj.yrange[0], linearObj.yrange[1], "bcnst", "bcnstv")
        self.linearObjDic[key] = linearObj
    
    def plot(self,subplot,x,y,type="power"):
        name = "linear"
        key = name + "%d"%subplot
        
        linearObj = self.linearObjDic[key]
        linearObj.plotBox(linearObj.xrange[0], linearObj.xrange[1], linearObj.yrange[0], linearObj.yrange[1], "bcst", "bcst")
        
        if linearObj.setXYData() != None:
                clearData(linearObj)
                
        else:
            if type.lower() == 'simple':
                linearObj.setXYData(x,y,"real")
            if type.lower() == 'power':
                linearObj.setXYData(x,abs(y),"real")
            if type.lower() == 'iq':
                linearObj.setXYData(x,y,"complex")
        
        if type.lower() == 'simple':
            colline = 9
            linearObj.basicLineTimePlot(x, y, xmin, xmax, ymin, ymax, colline)
            linearObj.setXYData(x,y,"real")
        
        if type.lower() == 'power':
            colline = 9
            linearObj.basicLineTimePlot(x, abs(y), xmin, xmax, ymin, ymax, colline)
            linearObj.setXYData(x,abs(y),"real")
        
        if type.lower() == 'iq':
            colline = 9
            linearObj.basicLineTimePlot(x=x, y=y.real, colline=colline)
            colline = 13
            linearObj.basicLineTimePlot(x=x, y=y.imag, colline=colline)
            
            linearObj.setXYData(x,y,"complex")
        
        linearObj.plotBox(linearObj.xrange[0], linearObj.xrange[1], linearObj.yrange[0], linearObj.yrange[1], "bcst", "bcst")
        
        
#        linearObj.plotBox(linearObj.xrange[0], linearObj.xrange[1], linearObj.yrange[0], linearObj.yrange[1], "bc", "bc")
#        linearObj.basicXYPlot(data,y)
#        linearObj.setXYData(data,y)
        
    

class PcolorPlot:
    pcolorObjDic = {}
    colorbarObjDic = {}
    pwprofileObjDic = {}
    showColorbar = None
    showPowerProfile = None
    XAxisAsTime = None
    width = None
    height = None
    __spcxpos = None
    __spcypos = None
    __cmapxpos = None
    __cmapypos = None
    __profxpos = None
    __profypos = None
    __lastTitle = None
    
    def __init__(self,indexPlot,nsubplot,winTitle,colormap,showColorbar,showPowerProfile,XAxisAsTime):
        self.width = 460
        self.height = 300
        self.showColorbar = showColorbar
        self.showPowerProfile = showPowerProfile
        self.XAxisAsTime = XAxisAsTime
        
        
        ncol = int(numpy.sqrt(nsubplot)+0.9)
        nrow = int(nsubplot*1./ncol + 0.9)
        
        initPlplot(indexPlot,ncol,nrow,winTitle,self.width,self.height)
        setColormap(colormap)
        self.ncol = ncol
        self.nrow = nrow

    def setFigure(self,indexPlot):
        setStrm(indexPlot)

    def setSpectraPos(self): #modificar valores de acuerdo al colorbar y pwprofile
        if self.showPowerProfile: xi = 0.09; xf = 0.6 #0.075
        else:   xi = 0.15; xf = 0.8 #0.8,0.7,0.5 
        yi = 0.15; yf = 0.80
        
        xpos = [xi,xf]
        ypos = [yi,yf]
        
        self.__spcxpos = xpos
        self.__spcypos = ypos
        
        return xpos,ypos
    
    def setColorbarScreenPos(self):
                        
        xi = self.__spcxpos[1] + 0.03; xf = xi + 0.03
        yi = self.__spcypos[0]; yf = self.__spcypos[1]
        
        xpos = [xi,xf]
        ypos = [yi,yf]
        
        self.__cmapxpos = xpos
        self.__cmapypos = ypos

        return xpos,ypos
    
    def setPowerprofileScreenPos(self):
        
        xi = self.__cmapxpos[1] + 0.07; xf = xi + 0.25
        yi = self.__spcypos[0]; yf = self.__spcypos[1]
        
        xpos = [xi,xf]
        ypos = [yi,yf]
        
        self.__profxpos = [xi,xf]
        self.__profypos = [yi,yf]

        return xpos,ypos
    
    def createObjects(self,subplot,xmin,xmax,ymin,ymax,zmin,zmax,title,xlabel,ylabel):
        """
        Crea los objetos necesarios para un subplot
        """
        
        # Config Spectra plot
        
        szchar = 0.7
        name = "spc"
        key = name + "%d"%subplot
        xrange = [xmin,xmax]
        yrange = [ymin,ymax]
        zrange = [zmin,zmax]
        
        xpos,ypos = self.setSpectraPos()
        pcolorObj = BaseGraph(name,subplot,xpos,ypos,xlabel,ylabel,title,szchar,xrange,yrange,zrange)
        self.pcolorObjDic[key] = pcolorObj
        
        # Config Colorbar
        if self.showColorbar:
            szchar = 0.65
            name = "colorbar"
            key = name + "%d"%subplot
            
            xpos,ypos = self.setColorbarScreenPos()
            xrange = [0.,1.]
            yrange = [zmin,zmax]
            cmapObj = BaseGraph(name,subplot,xpos,ypos,"","","dB",szchar,xrange,yrange)
            self.colorbarObjDic[key] = cmapObj
        
        # Config Power profile
        if self.showPowerProfile:
            szchar = 0.55
            name = "pwprofile"
            key = name + "%d"%subplot
            
            xpos,ypos = self.setPowerprofileScreenPos()
            xrange = [zmin,zmax]
            yrange = [ymin,ymax]
            powObj = BaseGraph(name,subplot,xpos,ypos,"dB","","Power Profile",szchar,xrange,yrange)
            self.pwprofileObjDic[key] = powObj
    
    def setNewPage(self, pltitle='No title'):
        szchar = 0.7
        setNewPage()
        setPlTitle(pltitle,"black", szchar=szchar)
        setSubpages(self.ncol, self.nrow)
        
    def closePage(self):
        closePage()
        
    def iniPlot(self,subplot):
        """
        Inicializa los subplots con su frame, titulo, etc
        """
        
        # Config Spectra plot
        name = "spc"
        key = name + "%d"%subplot
        
        pcolorObj = self.pcolorObjDic[key]
        pcolorObj.plotBox(pcolorObj.xrange[0], pcolorObj.xrange[1], pcolorObj.yrange[0], pcolorObj.yrange[1], "bcnst", "bcnstv")
        
        # Config Colorbar
        if self.showColorbar:
            name = "colorbar"
            key = name + "%d"%subplot
            
            cmapObj = self.colorbarObjDic[key]
            cmapObj.plotBox(cmapObj.xrange[0], cmapObj.xrange[1], cmapObj.yrange[0], cmapObj.yrange[1], "bc", "bcmtsv")
            cmapObj.colorbarPlot(cmapObj.xrange[0], cmapObj.xrange[1], cmapObj.yrange[0], cmapObj.yrange[1])
#            cmapObj.plotBox(cmapObj.xrange[0], cmapObj.xrange[1], cmapObj.yrange[0], cmapObj.yrange[1], "bc", "bcmtsv")
            
        # Config Power profile
        if self.showPowerProfile:
            name = "pwprofile"
            key = name + "%d"%subplot
            
            powObj = self.pwprofileObjDic[key]
            powObj.setLineStyle(2)
            powObj.plotBox(powObj.xrange[0], powObj.xrange[1], powObj.yrange[0], powObj.yrange[1], "bcntg", "bc")
            powObj.setLineStyle(1)
            powObj.plotBox(powObj.xrange[0], powObj.xrange[1], powObj.yrange[0], powObj.yrange[1], "bc", "bc")
    
    def printTitle(self,pltitle):
#        if self.__lastTitle != None:
#            setPlTitle(self.__lastTitle,"white")
#            
#        self.__lastTitle = pltitle
        
        setPlTitle(pltitle,"black")
        
#        setSubpages(self.ncol,self.nrow)
        
    def plot(self,subplot,x,y,z,subtitle):
        # Spectra plot
        
        name = "spc"
        key = name + "%d"%subplot
        
#        newx = [x[0],x[-1]]
        pcolorObj = self.pcolorObjDic[key]
        
        pcolorObj.plotBox(pcolorObj.xrange[0], pcolorObj.xrange[1], pcolorObj.yrange[0], pcolorObj.yrange[1], "bcst", "bcst")
        
        #pcolorObj.delLabels()
        pcolorObj.setLabels(title=subtitle)

        deltax = None; deltay = None
        
        pcolorObj.advPcolorPlot(z, 
                                x,
                                y, 
                                xmin=pcolorObj.xrange[0], 
                                xmax=pcolorObj.xrange[1], 
                                ymin=pcolorObj.yrange[0], 
                                ymax=pcolorObj.yrange[1], 
                                zmin=pcolorObj.zrange[0], 
                                zmax=pcolorObj.zrange[1],
                                deltax=deltax, 
                                deltay=deltay, 
                                getGrid=pcolorObj.getGrid)
        
        #Solo se calcula la primera vez que se ingresa a la funcion
        pcolorObj.getGrid = False
        
        pcolorObj.plotBox(pcolorObj.xrange[0], pcolorObj.xrange[1], pcolorObj.yrange[0], pcolorObj.yrange[1], "bcst", "bcst", nolabels=True)
        
        # Power Profile
        if self.showPowerProfile:
            power = numpy.average(z, axis=0)
            name = "pwprofile"
            key = name + "%d"%subplot
            powObj = self.pwprofileObjDic[key]
            
            if powObj.setXYData() != None:
                #clearData(powObj)
                powObj.setLineStyle(2)
                powObj.plotBox(powObj.xrange[0], powObj.xrange[1], powObj.yrange[0], powObj.yrange[1], "bcntg", "bc")
                powObj.setLineStyle(1)
            else:
                powObj.setXYData(power,y)
            
            powObj.plotBox(powObj.xrange[0], powObj.xrange[1], powObj.yrange[0], powObj.yrange[1], "bc", "bc")
            powObj.basicXYPlot(power,y)
            powObj.setXYData(power,y)
    
    def savePlot(self,indexPlot,filename):
        
        width = self.width*self.ncol
        hei = self.height*self.nrow
        savePlplot(filename,width,hei)
    
    def refresh(self):
        plFlush()

class RtiPlot:
    
    pcolorObjDic = {}
    colorbarObjDic = {}
    pwprofileObjDic = {}
    showColorbar = None
    showPowerProfile = None
    XAxisAsTime = None
    widht = None
    height = None
    __rtixpos = None
    __rtiypos = None
    __cmapxpos = None
    __cmapypos = None
    __profxpos = None
    __profypos = None
    
    def __init__(self,indexPlot,nsubplot,winTitle,colormap,showColorbar,showPowerProfile,XAxisAsTime):
        self.width = 700
        self.height = 150
        self.showColorbar = showColorbar
        self.showPowerProfile = showPowerProfile
        self.XAxisAsTime = XAxisAsTime
        
        ncol = 1
        nrow = nsubplot
        initPlplot(indexPlot,ncol,nrow,winTitle,self.width,self.height)
        setColormap(colormap)
        self.ncol = ncol
        self.nrow = nrow
    
    def setFigure(self,indexPlot):
        setStrm(indexPlot)
    
    def setRtiScreenPos(self):
                    
        if self.showPowerProfile: xi = 0.07; xf = 0.65
        else:   xi = 0.07; xf = 0.9 
        yi = 0.15; yf = 0.80
        
        xpos = [xi,xf]
        ypos = [yi,yf]
        
        self.__rtixpos = xpos
        self.__rtiypos = ypos
        
        return xpos,ypos
    
    def setColorbarScreenPos(self):
                        
        xi = self.__rtixpos[1] + 0.03; xf = xi + 0.03
        
        yi = self.__rtiypos[0]; yf = self.__rtiypos[1]
        
        xpos = [xi,xf]
        ypos = [yi,yf]
        
        self.__cmapxpos = xpos
        self.__cmapypos = ypos

        return xpos,ypos
    
    def setPowerprofileScreenPos(self):
        
        xi = self.__cmapxpos[1] + 0.05; xf = xi + 0.20

        yi = self.__rtiypos[0]; yf = self.__rtiypos[1]
        
        xpos = [xi,xf]
        ypos = [yi,yf]
        
        self.__profxpos = [xi,xf]
        self.__profypos = [yi,yf]

        return xpos,ypos

    def setup(self,subplot,xmin,xmax,ymin,ymax,zmin,zmax,title,xlabel,ylabel,timedata,timezone="lt",npoints=100):
        # Config Rti plot
        szchar = 1.10
        name = "rti"
        key = name + "%d"%subplot
        
        # xmin, xmax --> minHour, max Hour : valores que definen el ejex x=[horaInicio,horaFinal]
        thisDateTime = datetime.datetime.fromtimestamp(timedata)
        startDateTime = datetime.datetime(thisDateTime.year,thisDateTime.month,thisDateTime.day,xmin,0,0)
        endDateTime = datetime.datetime(thisDateTime.year,thisDateTime.month,thisDateTime.day,xmax,59,59)
        deltaTime = 0
        if timezone == "lt":
            deltaTime = time.timezone
        startTimeInSecs = time.mktime(startDateTime.timetuple()) - deltaTime
        endTimeInSecs = time.mktime(endDateTime.timetuple()) - deltaTime
        
        xrange = [startTimeInSecs,endTimeInSecs]
        totalTimeInXrange = endTimeInSecs - startTimeInSecs + 1.
        deltax = totalTimeInXrange / npoints
        
        yrange = [ymin,ymax]
        zrange = [zmin,zmax] 
        
        xpos,ypos = self.setRtiScreenPos()
        pcolorObj = BaseGraph(name,subplot,xpos,ypos,xlabel,ylabel,title,szchar,xrange,yrange,zrange,deltax)
        if self.XAxisAsTime:
            pcolorObj.setXAxisAsTime(self.XAxisAsTime)
            xopt = "bcnstd"
            yopt = "bcnstv"
        else:
            xopt = "bcnst"
            yopt = "bcnstv"
        
        pcolorObj.plotBox(pcolorObj.xrange[0], pcolorObj.xrange[1], pcolorObj.yrange[0], pcolorObj.yrange[1], xopt, yopt)
        self.pcolorObjDic[key] = pcolorObj
        

        # Config Colorbar
        if self.showColorbar:
            szchar = 0.9
            name = "colorbar"
            key = name + "%d"%subplot
            
            xpos,ypos = self.setColorbarScreenPos()
            xrange = [0.,1.]
            yrange = [zmin,zmax]
            cmapObj = BaseGraph(name,subplot,xpos,ypos,"","","dB",szchar,xrange,yrange)
            cmapObj.plotBox(cmapObj.xrange[0], cmapObj.xrange[1], cmapObj.yrange[0], cmapObj.yrange[1], "bc", "bcm")
            cmapObj.colorbarPlot(cmapObj.xrange[0], cmapObj.xrange[1], cmapObj.yrange[0], cmapObj.yrange[1])
            cmapObj.plotBox(cmapObj.xrange[0], cmapObj.xrange[1], cmapObj.yrange[0], cmapObj.yrange[1], "bc", "bcmtsv")
            self.colorbarObjDic[key] = cmapObj
        
        
        # Config Power profile
        if self.showPowerProfile:
            szchar = 0.8
            name = "pwprofile"
            key = name + "%d"%subplot
            
            xpos,ypos = self.setPowerprofileScreenPos()
            xrange = [zmin,zmax]
            yrange = [ymin,ymax]
            powObj = BaseGraph(name,subplot,xpos,ypos,"dB","","Power Profile",szchar,xrange,yrange)
            powObj.setLineStyle(2)
            powObj.plotBox(powObj.xrange[0], powObj.xrange[1], powObj.yrange[0], powObj.yrange[1], "bcntg", "bc")
            powObj.setLineStyle(1)
            powObj.plotBox(powObj.xrange[0], powObj.xrange[1], powObj.yrange[0], powObj.yrange[1], "bc", "bc")
            self.pwprofileObjDic[key] = powObj

    
    def plot(self,subplot,x,y,z):
        # RTI plot
        name = "rti"
        key = name + "%d"%subplot
        
        data = numpy.reshape(z, (1,-1))
        data = numpy.abs(data)
        data = 10*numpy.log10(data)
        newx = [x,x+1]
        
        pcolorObj = self.pcolorObjDic[key]
        
        if pcolorObj.xaxisIsTime:
            xopt = "bcstd"
            yopt = "bcst"
        else:
            xopt = "bcst"
            yopt = "bcst"
            
        pcolorObj.plotBox(pcolorObj.xrange[0], pcolorObj.xrange[1], pcolorObj.yrange[0], pcolorObj.yrange[1], xopt, yopt)
        
        deltax = pcolorObj.deltax
        deltay = None
        
        if pcolorObj.xmin == None and pcolorObj.xmax == None:
            pcolorObj.xmin = x
            pcolorObj.xmax = x
        
        if x >= pcolorObj.xmax:
            xmin = x
            xmax = x + deltax
            x = [x]
            pcolorObj.advPcolorPlot(data, 
                                    x, 
                                    y, 
                                    xmin=xmin, 
                                    xmax=xmax, 
                                    ymin=pcolorObj.yrange[0], 
                                    ymax=pcolorObj.yrange[1], 
                                    zmin=pcolorObj.zrange[0], 
                                    zmax=pcolorObj.zrange[1],
                                    deltax=deltax, 
                                    deltay=deltay, 
                                    getGrid=pcolorObj.getGrid)
            
            pcolorObj.xmin = xmin
            pcolorObj.xmax = xmax
            
        
        # Power Profile
        if self.showPowerProfile:
            data = numpy.reshape(data,(numpy.size(data)))
            name = "pwprofile"
            key = name + "%d"%subplot
            powObj = self.pwprofileObjDic[key]
            
            if powObj.setXYData() != None:
                clearData(powObj)
                powObj.setLineStyle(2)
                powObj.plotBox(powObj.xrange[0], powObj.xrange[1], powObj.yrange[0], powObj.yrange[1], "bcntg", "bc")
                powObj.setLineStyle(1)
            else:
                powObj.setXYData(data,y)
            
            powObj.plotBox(powObj.xrange[0], powObj.xrange[1], powObj.yrange[0], powObj.yrange[1], "bc", "bc")
            powObj.basicXYPlot(data,y)
            powObj.setXYData(data,y)
            
    def savePlot(self,indexPlot,filename):
        
        width = self.width*self.ncol
        hei = self.height*self.nrow
        savePlplot(filename,width,hei)
        
    def refresh(self):
        plFlush()

if __name__ == '__main__':
    
    #Setting the signal
    fs = 8000
    f0 = 200
    f1 = 400
    T = 1./fs
    x = numpy.arange(160)
    y1 = numpy.sin(2*numpy.pi*f0*x*T)
    y2 = numpy.sin(2*numpy.pi*f1*x*T)
    signalList = [y1,y2]
    
    xmin = numpy.min(x)
    xmax = numpy.max(x)
    ymin = numpy.min(y1)
    ymax = numpy.max(y1)
    
    # Creating Object
    indexPlot = 1
    nsubplot = 2
    winTitle = "mi grafico v1"
    
    subplotTitle = "subplot - No."
    xlabel = ""
    ylabel = ""
    
    linearObj = LinearPlot(indexPlot,nsubplot,winTitle)
    
    #Config SubPlots
    for subplot in range(nsubplot):
        indexplot = subplot + 1
        title = subplotTitle + '%d'%indexplot
        linearObj.setup(indexplot, xmin, xmax, ymin, ymax, title, xlabel, ylabel)
    
    #Plotting
    type = "simple"
    for subplot in range(nsubplot):
        indexplot = subplot + 1
        y = signalList[subplot]
        linearObj.plot(indexplot, x, y, type)
        
    linearObj.refresh()
    linearObj.show()

    print "end"