schain-jc Commit - r112:a4769f3a76cc

Cambio en la forma de generacion de graficos espectrales

Miguel Valdez -

r112:a4769f3a76cc

parent child

Context file:

r112:a4769f3a76cc

Collapse all files

schainpy/Graphics/BaseGraph.py +73 -28

             """
             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.plclear()
                 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 setPlTitle(pltitle,color):
+            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),
 .,
 .,
                                      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),
 .,
 .,
                                    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 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() == 'power':
                             linearObj.setXYData(x,abs(y),"real")
                         if type.lower() == 'iq':
                             linearObj.setXYData(x,y,"complex")
                     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 SpectraPlot:
+            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
-                    nrow = 2
-                    if (nsubplot%2)==0:
+                    ncol = int(numpy.sqrt(nsubplot)+0.9)
-                        ncol = nsubplot/nrow
+                    nrow = int(nsubplot*1./ncol + 0.9)
-                    else:
-                        ncol = int(nsubplot)/nrow + 1
                     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 setup(self,subplot,xmin,xmax,ymin,ymax,zmin,zmax,title,xlabel,ylabel):
+                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)
-                    pcolorObj.plotBox(pcolorObj.xrange[0], pcolorObj.xrange[1], pcolorObj.yrange[0], pcolorObj.yrange[1], "bcnst", "bcnstv")
                     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)
-                        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.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")
-                        self.pwprofileObjDic[key] = powObj
                 def printTitle(self,pltitle):
-                    if self.__lastTitle != None:
+            #        if self.__lastTitle != None:
-                        setPlTitle(self.__lastTitle,"white")
+            #            setPlTitle(self.__lastTitle,"white")
+            #
-                    self.__lastTitle = pltitle
+            #        self.__lastTitle = pltitle
                     setPlTitle(pltitle,"black")
-                    setSubpages(self.ncol,self.nrow)
+            #        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.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")
+                    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)
+                            #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,path):
+                def savePlot(self,indexPlot,filename):
-                    now = datetime.datetime.now().timetuple()
-                    file = "spc_img%02d_%03d_%02d%02d%02d"%(indexPlot,now[7],now[3],now[4],now[5])
-                    filename = os.path.join(path,file+".png")
                     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)
                 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 refresh(self):
                     plFlush()

schainpy/Graphics/SpectraPlot.py +75 -31

             '''
             Created on Feb 7, 2012
             @author $Author$
             @version $Id$
             '''
             import numpy
             import os
             import sys
             import plplot
             import datetime
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Graphics.BaseGraph import *
             from Model.Spectra import Spectra
             class Spectrum:
                 colorplotObj = None
                 def __init__(self,Spectra, index):
                     self.__isPlotConfig = False
                     self.__isPlotIni = False
                     self.__xrange = None
                     self.__yrange = None
-                    self.nGraphs = 0
+                    self.nsubplots = 0
                     self.indexPlot = index
                     self.spectraObj = Spectra
-                def setup(self,indexPlot,nsubplot,winTitle='',colormap="br_green",showColorbar=False,showPowerProfile=False,XAxisAsTime=False):
+                def setup(self,indexPlot, nsubplots, winTitle='', colormap="br_green", showColorbar=False, showPowerProfile=False, XAxisAsTime=False):
-                    self.colorplotObj = SpectraPlot(indexPlot,nsubplot,winTitle,colormap,showColorbar,showPowerProfile,XAxisAsTime)
+                    """
+                    Crea un objeto colorPlot con las opciones seleccinoadas
-                def initPlot(self,xmin,xmax,ymin,ymax,zmin,zmax,titleList,xlabelList,ylabelList):
+                    """
-                    nsubplot = self.spectraObj.nChannels
+                    self.nsubplots = nsubplots
+                    self.colorplotObj = PcolorPlot(indexPlot,
+                                                    nsubplots,
+                                                    winTitle,
+                                                    colormap,
+                                                    showColorbar,
+                                                    showPowerProfile,
+                                                    XAxisAsTime)
+                def createObjects(self,xmin,xmax,ymin,ymax,zmin,zmax,titleList,xlabelList,ylabelList):
+                    """
+                    Configura cada subplot con los valores maximos y minimos incluyendo los subtitulos
+                    """
-                    for index in range(nsubplot):
+                    for index in range(self.nsubplots):
                         title = titleList[index]
                         xlabel = xlabelList[index]
                         ylabel = ylabelList[index]
                         subplot = index
-                        self.colorplotObj.setup(subplot+1,xmin,xmax,ymin,ymax,zmin,zmax,title,xlabel,ylabel)
+                        self.colorplotObj.createObjects(subplot+1,xmin,xmax,ymin,ymax,zmin,zmax,title,xlabel,ylabel)
+                def initPlot(self):
+                    """
+                    Configura cada subplot con los valores maximos y minimos incluyendo los subtitulos
+                    """
+                    for index in range(self.nsubplots):
+                        subplot = index
+                        self.colorplotObj.iniPlot(subplot+1)
                 def plotData(self,
                              xmin=None,
                              xmax=None,
                              ymin=None,
                              ymax=None,
                              zmin=None,
                              zmax=None,
                              titleList=None,
                              xlabelList=None,
                              ylabelList=None,
                              winTitle='',
                              colormap = "br_green",
                              showColorbar = True,
                              showPowerProfile = True,
                              XAxisAsTime = False,
-                             save = False):
+                             save = False,
+                             channelList=[]):
+                    if channelList == []:
+                        channelList = numpy.arange(self.spectraObj.nChannels)
-                    databuffer = 10.*numpy.log10(self.spectraObj.data_spc)
+                    nsubplots = len(channelList)
-                    noise = 10.*numpy.log10(self.spectraObj.noise)
+                    nX = self.spectraObj.nFFTPoints
+                    nY = self.spectraObj.nHeights
-                    nsubplot = self.spectraObj.nChannels
+                    if self.spectraObj.noise == None:
-                    nsubplot, nX, nY = numpy.shape(databuffer)
+                        noise = numpy.ones(nsubplots)
+                    else:
+                        noise = 10.*numpy.log10(self.spectraObj.noise[channelList])
+                    datadB = 10.*numpy.log10(self.spectraObj.data_spc[channelList,:,:])
+                    noisedB = 10.*numpy.log10(noise)
                     x = numpy.arange(nX)
                     y = self.spectraObj.heightList
                     indexPlot = self.indexPlot
                     if not(self.__isPlotConfig):
-                        self.setup(indexPlot,nsubplot,winTitle,colormap,showColorbar,showPowerProfile,XAxisAsTime)
+                        self.setup(indexPlot,
+                                   nsubplots,
+                                   winTitle,
+                                   colormap,
+                                   showColorbar,
+                                   showPowerProfile,
+                                   XAxisAsTime)
                         self.__isPlotConfig = True
                     if not(self.__isPlotIni):
                         if titleList == None:
                             titleList = []
-                            for i in range(nsubplot):
+                            for i in range(nsubplots):
                                 titleList.append("Channel: %d - Noise: %.2f" %(i, noise[i]))
                         if xlabelList == None:
                             xlabelList = []
-                            for i in range(nsubplot):
+                            for i in range(nsubplots):
                                 xlabelList.append("")
                         if ylabelList == None:
                             ylabelList = []
-                            for i in range(nsubplot):
+                            for i in range(nsubplots):
                                 ylabelList.append("Range (Km)")
                         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 = 0
                         if zmax == None: zmax = 120
-                        self.initPlot(xmin,xmax,ymin,ymax,zmin,zmax,titleList,xlabelList,ylabelList)
+                        self.createObjects(xmin,xmax,ymin,ymax,zmin,zmax,titleList,xlabelList,ylabelList)
                         self.__isPlotIni = True
-                    self.colorplotObj.setFigure(indexPlot)
                     thisDatetime = datetime.datetime.fromtimestamp(self.spectraObj.m_BasicHeader.utc)
                     pltitle = "Self Spectra - Date: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
-                    self.colorplotObj.printTitle(pltitle) #setPlTitle(pltitle)
+                    self.colorplotObj.setFigure(indexPlot)
+                    self.colorplotObj.setNewPage(pltitle)
-                    for index in range(nsubplot):
+                    self.initPlot()
-                        data = databuffer[index,:,:]
-                        subtitle = "Channel: %d - Noise: %.2f" %(index, noise[index])
-                        self.colorplotObj.plot(index+1,x,y,data,subtitle)
+                    for channel in range(nsubplots):
+                        data = datadB[channel,:,:]
+                        subtitle = "Channel: %d - Noise: %.2f" %(channel, noise[channel])
+                        self.colorplotObj.plot(channel+1, x, y, data, subtitle)
                     self.colorplotObj.refresh()
                     if save:
                         self.colorplotObj.setFigure(indexPlot)
-                        path4plot = "/Users/jro/Pictures"
+                        path = "/home/roj-idl71/tmp/"
-                        self.colorplotObj.savePlot(indexPlot,path4plot)
+                        now = datetime.datetime.now().timetuple()
+                        file = "spc_img%02d_%03d_%02d%02d%02d.png"%(indexPlot,now[7],now[3],now[4],now[5])
+                        filename = os.path.join(path,file)
+                        self.colorplotObj.savePlot(indexPlot, filename)
+                    self.colorplotObj.closePage()

schainpy/Graphics/VoltagePlot.py 0 -7

             '''
             Created on Feb 7, 2012
             @author $Author$
             @version $Id$
             '''
             import numpy
             import os
             import sys
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Graphics.BaseGraph import *
             from Model.Voltage import Voltage
             class Osciloscope:
                 linearplotObj = None
                 def __init__(self, Voltage, index):
                     self.__isPlotConfig = False
                     self.__isPlotIni = False
                     self.__xrange = None
                     self.__yrange = None
                     self.indexPlot = index
                     self.voltageObj = Voltage
                 def setup(self,indexPlot,nsubplot,winTitle=''):
                     self.linearplotObj = LinearPlot(indexPlot,nsubplot,winTitle)
                 def initPlot(self,xmin,xmax,ymin,ymax,titleList,xlabelList,ylabelList):
                     nsubplot = self.voltageObj.nChannels
                     for index in range(nsubplot):
                         title = titleList[index]
                         xlabel = xlabelList[index]
                         ylabel = ylabelList[index]
                         subplot = index
                         self.linearplotObj.setup(subplot+1,xmin,xmax,ymin,ymax,title,xlabel,ylabel)
                 def plotData(self,
                              xmin=None,
                              xmax=None,
                              ymin=None,
                              ymax=None,
                              titleList=None,
                              xlabelList=None,
                              ylabelList=None,
                              winTitle='',
                              type="power"):
                     databuffer = self.voltageObj.data
                     height = self.voltageObj.heightList
                     nsubplot = self.voltageObj.nChannels
                     indexPlot = self.indexPlot
                     if not(self.__isPlotConfig):
                         self.setup(indexPlot,nsubplot,winTitle)
                         self.__isPlotConfig = True
                     if not(self.__isPlotIni):
                         if titleList == None:
                             titleList = []
                             thisDatetime = datetime.datetime.fromtimestamp(self.voltageObj.m_BasicHeader.utc)
                             txtdate = "Date: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                             for i in range(nsubplot):
                                 titleList.append("Channel: %d %s" %(i, txtdate))
                         if xlabelList == None:
                             xlabelList = []
                             for i in range(nsubplot):
                                 xlabelList.append("")
                         if ylabelList == None:
                             ylabelList = []
                             for i in range(nsubplot):
                                 ylabelList.append("")
                         if xmin == None: xmin = height[0]
                         if xmax == None: xmax = height[-1]
                         if ymin == None: ymin = numpy.nanmin(abs(databuffer))
                         if ymax == None: ymax = numpy.nanmax(abs(databuffer))
                         self.initPlot(xmin,xmax,ymin,ymax,titleList,xlabelList,ylabelList)
                         self.__isPlotIni = True
                     self.linearplotObj.setFigure(indexPlot)
                     for index in range(nsubplot):
                         data = databuffer[index,:]
                         self.linearplotObj.plot(subplot=index+1,x=height,y=data,type=type)
                     self.linearplotObj.refresh()
             class RTI:
                 colorplotObj = None
                 def __init__(self, Voltage, index):
                     self.__isPlotConfig = False
                     self.__isPlotIni = False
                     self.__xrange = None
                     self.__yrange = None
                     self.indexPlot = index
                     self.voltageObj = Voltage
                 def setup(self,indexPlot,nsubplot,winTitle='',colormap="br_green",showColorbar=False,showPowerProfile=False,XAxisAsTime=False):
                     self.colorplotObj = RtiPlot(indexPlot,nsubplot,winTitle,colormap,showColorbar,showPowerProfile,XAxisAsTime)
                 def initPlot(self,xmin,xmax,ymin,ymax,zmin,zmax,titleList,xlabelList,ylabelList,timezone,npoints):
                     nsubplot = self.voltageObj.nChannels
                     timedata = self.voltageObj.m_BasicHeader.utc
                     for index in range(nsubplot):
                         title = titleList[index]
                         xlabel = xlabelList[index]
                         ylabel = ylabelList[index]
                         subplot = index
                         self.colorplotObj.setup(subplot+1,xmin,xmax,ymin,ymax,zmin,zmax,title,xlabel,ylabel,timedata,timezone,npoints)
                 def plotData(self,
                              xmin=None,
                              xmax=None,
                              ymin=None,
                              ymax=None,
                              zmin=None,
                              zmax=None,
                              titleList=None,
                              xlabelList=None,
                              ylabelList=None,
                              winTitle='',
                              timezone='lt',
                              npoints=1000.0,
                              colormap="br_green",
                              showColorbar=True,
                              showPowerProfile=True,
                              XAxisAsTime=True):
                     databuffer = self.voltageObj.data
                     timedata = self.voltageObj.m_BasicHeader.utc
                     height = self.voltageObj.heightList
                     nsubplot = self.voltageObj.nChannels
                     indexPlot = self.indexPlot
                     if not(self.__isPlotConfig):
                         self.setup(indexPlot,nsubplot,winTitle,colormap,showColorbar,showPowerProfile,XAxisAsTime)
                         self.__isPlotConfig = True
                     if not(self.__isPlotIni):
                         if titleList == None:
                             titleList = []
                             thisDatetime = datetime.datetime.fromtimestamp(timedata)
                             txtdate = "Date: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                             for i in range(nsubplot):
                                 titleList.append("Channel: %d %s" %(i, txtdate))
                         if xlabelList == None:
                             xlabelList = []
                             for i in range(nsubplot):
                                 xlabelList.append("")
                         if ylabelList == None:
                             ylabelList = []
                             for i in range(nsubplot):
                                 ylabelList.append("")
                         if xmin == None: xmin = 0
                         if xmax == None: xmax = 23
                         if ymin == None: ymin = min(self.voltageObj.heightList)
                         if ymax == None: ymax = max(self.voltageObj.heightList)
                         if zmin == None: zmin = 0
                         if zmax == None: zmax = 50
                         self.initPlot(xmin,xmax,ymin,ymax,zmin,zmax,titleList,xlabelList,ylabelList,timezone,npoints)
                         self.__isPlotIni = True
                     self.colorplotObj.setFigure(indexPlot)
                     if timezone == 'lt':
                         timedata = timedata - time.timezone
                     for index in range(nsubplot):
                         data = databuffer[index,:]
                         self.colorplotObj.plot(subplot=index+1,x=timedata,y=height,z=data)
                     self.colorplotObj.refresh()

schainpy/Processing/JRONoise.py +22 -35

             import numpy
-            from Model.Spectra import Spectra
-            def hildebrand_sekhon(Data, navg):
+            def hildebrand_sekhon(data, navg):
                 """
                 This method is for the objective determination of de noise level in Doppler spectra. This
                 implementation technique is based on the fact that the standard deviation of the spectral
                 densities is equal to the mean spectral density for white Gaussian noise
                 Inputs:
                     Data    :    heights
                     navg    :    numbers of averages
                 Return:
                     -1        :    any error
                     anoise    :    noise's level
                 """
-                divisor = 8
+                dataflat = data.reshape(-1)
-                ratio = 7 / divisor
+                dataflat.sort()
-                data = Data.reshape(-1)
+                npts = dataflat.size #numbers of points of the data
-                npts = data.size #numbers of points of the data
                 if npts < 32:
                     print "error in noise - requires at least 32 points"
                     return -1.0
+                dataflat2 = numpy.power(dataflat,2)
+                cs = numpy.cumsum(dataflat)
+                cs2 = numpy.cumsum(dataflat2)
                 # data sorted in ascending order
-                nmin = int(npts/divisor + ratio);
+                nmin = int((npts + 7.)/8)
-                s = 0.0
-                s2 = 0.0
-                data2 = data[:npts]
-                data2.sort()
-                for i in range(nmin):
-                    s  += data2[i]
-                    s2 += data2[i]**2;
-                icount = nmin
-                iflag = 0
                 for i in range(nmin, npts):
-                    s  += data2[i];
+                    s = cs[i]
-                    s2 += data2[i]**2
+                    s2 = cs2[i]
-                    icount=icount+1;
+                    p  = s / float(i);
-                    p  = s / float(icount);
                     p2 = p**2;
-                    q  = s2 / float(icount) - p2;
+                    q  = s2 / float(i) - p2;
                     leftc = p2;
                     rightc = q * float(navg);
+                    R2 = leftc/rightc
-                    if leftc > rightc:
-                        iflag = 1; #No weather signal
                     # Signal detect: R2 < 1 (R2 = leftc/rightc)
-                    if(leftc < rightc):
+                    if R2 < 1:
-                        if iflag:
+                        npts_noise = i
-                            break
+                        break
-                anoise = 0.0;
-                for j in range(i):
+                anoise = numpy.average(dataflat[0:npts_noise])
-                    anoise += data2[j];
-                anoise = anoise / float(i);
                 return anoise;
             def sorting_bruce(Data, navg):
                 sortdata = numpy.sort(Data)
                 lenOfData = len(Data)
                 nums_min = lenOfData/10
                 if (lenOfData/10) > 0:
                     nums_min = lenOfData/10
                 else:
                     nums_min = 0
                 rtest = 1.0 + 1.0/navg
                 sum = 0.
                 sumq = 0.
                 j = 0
                 cont = 1
                 while((cont==1)and(j<lenOfData)):
                     sum += sortdata[j]
                     sumq += sortdata[j]**2
                     j += 1
                     if j > nums_min:
                         if ((sumq*j) <= (rtest*sum**2)):
                             lnoise = sum / j
                         else:
                             j = j - 1
                             sum  = sum - sordata[j]
                             sumq =  sumq - sordata[j]**2
                             cont = 0
                     if j == nums_min:
                         lnoise = sum /j
                 return lnoise
             class Noise:
                 """
                 Clase que implementa los metodos necesarios para deternimar el nivel de ruido en un Spectro Doppler
                 """
                 data = None
                 noise = None
                 dim = None
                 def __init__(self, data=None):
                     """
                     Inicializador de la clase Noise para la la determinacion del nivel de ruido en un Spectro Doppler.
                     Inputs:
                         data: Numpy array de la forma nChan x nHeis x nProfiles
                     Affected:
                         self.noise
                     Return:
                         None
                     """
                     self.data = data
                     self.dim = None
                     self.nChannels = None
                     self.noise = None
                 def setNoise(self, data):
                     """
                     Inicializador de la clase Noise para la la determinacion del nivel de ruido en un Spectro Doppler.
                     Inputs:
                         data: Numpy array de la forma nChan x nHeis x nProfiles
                     Affected:
                         self.noise
                     Return:
                         None
                     """
                     if data == None:
                         raise ValueError, "The data value is not defined"
                     shape = data.shape
                     self.dim = len(shape)
                     if self.dim == 3:
                         nChan, nProfiles, nHeis = shape
                     elif self.dim == 2:
                         nChan, nHeis = shape
                     else:
                         raise ValueError, ""
                     self.nChannels = nChan
                     self.data = data.copy()
                     self.noise = numpy.zeros(nChan)
                     return 1
                 def byHildebrand(self, navg=1):
                     """
                     Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
                     Return:
                         noiselevel
                     """
                     daux = None
                     for channel in range(self.nChannels):
                         daux = self.data[channel,:,:]
                         self.noise[channel] = hildebrand_sekhon(daux, navg)
                     return self.noise
                 def byWindow(self, heiIndexMin, heiIndexMax, freqIndexMin, freqIndexMax):
                     """
                     Determina el ruido del canal utilizando la ventana indicada con las coordenadas:
                     (heiIndexMIn, freqIndexMin) hasta (heiIndexMax, freqIndexMAx)
                     Inputs:
                         heiIndexMin: Limite inferior del eje de alturas
                         heiIndexMax: Limite superior del eje de alturas
                         freqIndexMin: Limite inferior del eje de frecuencia
                         freqIndexMax: Limite supoerior del eje de frecuencia
                     """
                     data = self.data[:, heiIndexMin:heiIndexMax, freqIndexMin:freqIndexMax]
                     for channel in range(self.nChannels):
                         daux = data[channel,:,:]
                         self.noise[channel] = numpy.average(daux)
                     return self.noise
                 def bySort(self,navg = 1):
                     daux = None
                     for channel in range(self.nChannels):
                         daux = self.data[channel,:,:]
                         self.noise[channel] = sorting_bruce(daux, navg)
                     return self.noise
   No newline at end of file

schainpy/Processing/SpectraProcessor.py +13 -10

             '''
             Created on Feb 7, 2012
             @author $Author$
             @version $Id$
             '''
             import os, sys
             import numpy
+            import time
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Model.Spectra import Spectra
             from IO.SpectraIO import SpectraWriter
             from Graphics.SpectraPlot import Spectrum
             from JRONoise import Noise
             class SpectraProcessor:
                 '''
                 classdocs
                 '''
                 dataInObj = None
                 dataOutObj = None
                 noiseObj = None
                 integratorObjList = []
                 decoderObjList = []
                 writerObjList = []
                 plotterObjList = []
                 integratorObjIndex = None
                 decoderObjIndex = None
                 writerObjIndex = None
                 plotterObjIndex = None
                 buffer = None
                 profIndex = 0
                 nFFTPoints = None
                 nChannels = None
                 nHeights = None
                 nPairs = None
                 pairList = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.integratorObjIndex = None
                     self.decoderObjIndex = None
                     self.writerObjIndex = None
                     self.plotterObjIndex = None
                     self.integratorObjList = []
                     self.decoderObjList = []
                     self.writerObjList = []
                     self.plotterObjList = []
                     self.noiseObj = Noise()
                     self.buffer = None
                     self.profIndex = 0
                 def setup(self, dataInObj=None, dataOutObj=None, nFFTPoints=None, pairList=None):
                     if dataInObj == None:
                         raise ValueError, ""
                     if nFFTPoints == None:
                         raise ValueError, ""
                     self.dataInObj = dataInObj
                     if dataOutObj == None:
                         dataOutObj = Spectra()
                     self.dataOutObj = dataOutObj
                     self.noiseObj = Noise()
                     ##########################################
                     self.nFFTPoints = nFFTPoints
                     self.nChannels = self.dataInObj.nChannels
                     self.nHeights = self.dataInObj.nHeights
                     self.pairList = pairList
                     if pairList != None:
                         self.nPairs = len(pairList)
                     else:
                         self.nPairs = 0
                     self.dataOutObj.heightList = self.dataInObj.heightList
                     self.dataOutObj.channelIndexList = self.dataInObj.channelIndexList
                     self.dataOutObj.m_BasicHeader = self.dataInObj.m_BasicHeader.copy()
                     self.dataOutObj.m_ProcessingHeader = self.dataInObj.m_ProcessingHeader.copy()
                     self.dataOutObj.m_RadarControllerHeader = self.dataInObj.m_RadarControllerHeader.copy()
                     self.dataOutObj.m_SystemHeader = self.dataInObj.m_SystemHeader.copy()
                     self.dataOutObj.dataType = self.dataInObj.dataType
                     self.dataOutObj.nPairs = self.nPairs
                     self.dataOutObj.nChannels = self.nChannels
                     self.dataOutObj.nProfiles = self.nFFTPoints
                     self.dataOutObj.nHeights = self.nHeights
                     self.dataOutObj.nFFTPoints = self.nFFTPoints
                     #self.dataOutObj.data = None
                     self.dataOutObj.m_SystemHeader.numChannels = self.nChannels
                     self.dataOutObj.m_SystemHeader.nProfiles = self.nFFTPoints
                     self.dataOutObj.m_ProcessingHeader.totalSpectra = self.nChannels + self.nPairs
                     self.dataOutObj.m_ProcessingHeader.profilesPerBlock = self.nFFTPoints
                     self.dataOutObj.m_ProcessingHeader.numHeights = self.nHeights
                     self.dataOutObj.m_ProcessingHeader.shif_fft = True
                     spectraComb = numpy.zeros( (self.nChannels+self.nPairs)*2,numpy.dtype('u1'))
                     k = 0
                     for i in range( 0,self.nChannels*2,2 ):
                         spectraComb[i]   = k
                         spectraComb[i+1] = k
                         k += 1
                     k *= 2
                     if self.pairList != None:
                         for pair in self.pairList:
                             spectraComb[k]   = pair[0]
                             spectraComb[k+1] = pair[1]
                             k += 2
                     self.dataOutObj.m_ProcessingHeader.spectraComb = spectraComb
                     return self.dataOutObj
                 def init(self):
                     self.integratorObjIndex = 0
                     self.decoderObjIndex = 0
                     self.writerObjIndex = 0
                     self.plotterObjIndex = 0
                     if self.dataInObj.type == "Voltage":
                         if self.buffer == None:
                             self.buffer = numpy.zeros((self.nChannels,
                                                        self.nFFTPoints,
                                                        self.nHeights),
                                                       dtype='complex')
                         self.buffer[:,self.profIndex,:] = self.dataInObj.data
                         self.profIndex += 1
                         if self.profIndex == self.nFFTPoints:
                             self.__getFft()
                             self.dataOutObj.flagNoData = False
                             self.buffer = None
                             self.profIndex = 0
                             return
                         self.dataOutObj.flagNoData = True
                         return
                     #Other kind of data
                     if self.dataInObj.type == "Spectra":
                         self.dataOutObj.copy(self.dataInObj)
                         self.dataOutObj.flagNoData = False
                         return
                     raise ValueError, "The datatype is not valid"
                 def __getFft(self):
                     """
                     Convierte valores de Voltaje a Spectra
                     Affected:
                         self.dataOutObj.data_spc
                         self.dataOutObj.data_cspc
                         self.dataOutObj.data_dc
                         self.dataOutObj.heightList
                         self.dataOutObj.m_BasicHeader
                         self.dataOutObj.m_ProcessingHeader
                         self.dataOutObj.m_RadarControllerHeader
                         self.dataOutObj.m_SystemHeader
                         self.profIndex
                         self.buffer
                         self.dataOutObj.flagNoData
                         self.dataOutObj.dataType
                         self.dataOutObj.nPairs
                         self.dataOutObj.nChannels
                         self.dataOutObj.nProfiles
                         self.dataOutObj.m_SystemHeader.numChannels
                         self.dataOutObj.m_ProcessingHeader.totalSpectra
                         self.dataOutObj.m_ProcessingHeader.profilesPerBlock
                         self.dataOutObj.m_ProcessingHeader.numHeights
                         self.dataOutObj.m_ProcessingHeader.spectraComb
                         self.dataOutObj.m_ProcessingHeader.shif_fft
                     """
                     if self.dataInObj.flagNoData:
                         return 0
                     fft_volt = numpy.fft.fft(self.buffer,axis=1)
                     dc = fft_volt[:,0,:]
                     #calculo de self-spectra
                     fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
-                    spc = numpy.abs(fft_volt * numpy.conjugate(fft_volt))
+                    spc = fft_volt * numpy.conjugate(fft_volt)
+                    spc = spc.real
                     blocksize = 0
                     blocksize += dc.size
                     blocksize += spc.size
                     cspc = None
                     pairIndex = 0
                     if self.pairList != None:
                         #calculo de cross-spectra
                         cspc = numpy.zeros((self.nPairs, self.nFFTPoints, self.nHeights), dtype='complex')
                         for pair in self.pairList:
                             cspc[pairIndex,:,:] = numpy.abs(fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:]))
                             pairIndex += 1
                         blocksize += cspc.size
                     self.dataOutObj.data_spc = spc
                     self.dataOutObj.data_cspc = cspc
                     self.dataOutObj.data_dc = dc
                     self.dataOutObj.m_ProcessingHeader.blockSize = blocksize
                     self.dataOutObj.m_BasicHeader.utc = self.dataInObj.m_BasicHeader.utc
-                    self.getNoise()
+            #        self.getNoise()
                 def addWriter(self,wrpath):
                     objWriter = SpectraWriter(self.dataOutObj)
                     objWriter.setup(wrpath)
                     self.writerObjList.append(objWriter)
                 def addPlotter(self,index=None):
                     if index==None:
                         index = self.plotterObjIndex
                     plotObj = Spectrum(self.dataOutObj, index)
                     self.plotterObjList.append(plotObj)
                 def addIntegrator(self,N,timeInterval):
                     objIncohInt = IncoherentIntegration(N,timeInterval)
                     self.integratorObjList.append(objIncohInt)
                 def writeData(self, wrpath):
                     if self.dataOutObj.flagNoData:
                             return 0
                     if len(self.writerObjList) <= self.writerObjIndex:
                         self.addWriter(wrpath)
                     self.writerObjList[self.writerObjIndex].putData()
                     self.writerObjIndex += 1
                 def plotData(self,
                              xmin=None,
                              xmax=None,
                              ymin=None,
                              ymax=None,
                              zmin=None,
                              zmax=None,
                              titleList=None,
                              xlabelList=None,
                              ylabelList=None,
                              winTitle='',
                              colormap="br_green",
                              showColorbar=False,
                              showPowerProfile=False,
                              XAxisAsTime=False,
                              save=False,
-                             index=None):
+                             index=None,
+                             channelList=[]):
                     if self.dataOutObj.flagNoData:
                         return 0
                     if len(self.plotterObjList) <= self.plotterObjIndex:
                         self.addPlotter(index)
                     self.plotterObjList[self.plotterObjIndex].plotData(xmin,
                                                                        xmax,
                                                                        ymin,
                                                                        ymax,
                                                                        zmin,
                                                                        zmax,
                                                                        titleList,
                                                                        xlabelList,
                                                                        ylabelList,
                                                                        winTitle,
                                                                        colormap,
                                                                        showColorbar,
                                                                        showPowerProfile,
                                                                        XAxisAsTime,
-                                                                       save)
+                                                                       save,
+                                                                       channelList)
                     self.plotterObjIndex += 1
                 def integrator(self, N=None, timeInterval=None):
                     if self.dataOutObj.flagNoData:
                             return 0
                     if len(self.integratorObjList) <= self.integratorObjIndex:
                         self.addIntegrator(N,timeInterval)
                     myIncohIntObj = self.integratorObjList[self.integratorObjIndex]
                     myIncohIntObj.exe(data=self.dataOutObj.data_spc,timeOfData=self.dataOutObj.m_BasicHeader.utc)
                     if myIncohIntObj.isReady:
                         self.dataOutObj.data_spc = myIncohIntObj.data
                         self.dataOutObj.nAvg = myIncohIntObj.navg
                         self.dataOutObj.m_ProcessingHeader.incoherentInt *= myIncohIntObj.navg
                         #print "myIncohIntObj.navg: ",myIncohIntObj.navg
                         self.dataOutObj.flagNoData = False
-                        self.getNoise(type="hildebrand")
+                        """Calcular el ruido"""
-            #            self.getNoise(type="sort", parm=16)
+                        self.getNoise()
                     else:
                         self.dataOutObj.flagNoData = True
                     self.integratorObjIndex += 1
-                    """Calcular el ruido"""
-            #        self.getNoise(type="hildebrand", parm=1)
                 def removeDC(self, type):
                     if self.dataOutObj.flagNoData:
                         return 0
                 def removeInterference(self):
                     if self.dataOutObj.flagNoData:
                         return 0
                 def removeSatellites(self):
                     if self.dataOutObj.flagNoData:
                         return 0
                 def getNoise(self, type="hildebrand", parm=None):
                     if parm == None:
                         parm =self.dataOutObj.m_ProcessingHeader.incoherentInt
                     self.noiseObj.setNoise(self.dataOutObj.data_spc)
                     if type == "hildebrand":
                         noise = self.noiseObj.byHildebrand(parm)
                     if type == "window":
                         noise = self.noiseObj.byWindow(parm)
                     if type == "sort":
                         noise = self.noiseObj.bySort(parm)
                     self.dataOutObj.noise = noise
             #        print 10*numpy.log10(noise)
                 def selectChannels(self, channelList, pairList=[]):
                     channelIndexList = []
                     for channel in channelList:
                         if channel in self.dataOutObj.channelList:
                             index = self.dataOutObj.channelList.index(channel)
                             channelIndexList.append(index)
                     pairIndexList = []
                     for pair in pairList:
                         if pair in self.dataOutObj.pairList:
                             index = self.dataOutObj.pairList.index(pair)
                             pairIndexList.append(index)
                     self.selectChannelsByIndex(channelIndexList, pairIndexList)
                 def selectChannelsByIndex(self, channelIndexList, pairIndexList=[]):
                     """
                     Selecciona un bloque de datos en base a canales y pares segun el
                     channelIndexList y el pairIndexList
                     Input:
                         channelIndexList :    lista de indices de los canales a seleccionar por ej.
                                                  Si tenemos los canales
                                                          self.channelList = (2,3,5,7)
                                                 y deseamos escoger los canales (3,7)
                                                 entonces colocaremos el parametro
                                                         channelndexList = (1,3)
                         pairIndexList   :    tupla de indice depares que se desea selecionar por ej.
                                                 Si tenemos los pares :
                                                         ( (0,1), (0,2), (1,3), (2,5) )
                                                 y deseamos seleccionar los pares ((0,2), (2,5))
                                                 entonces colocaremos el parametro
                                                         pairIndexList = (1,3)
                     Affected:
                         self.dataOutObj.data_spc
                         self.dataOutObj.data_cspc
                         self.dataOutObj.data_dc
                         self.dataOutObj.nChannels
                         self.dataOutObj.nPairs
                         self.dataOutObj.m_ProcessingHeader.spectraComb
                         self.dataOutObj.m_SystemHeader.numChannels
                         self.dataOutObj.noise
                     Return:
                         None
                     """
                     if self.dataOutObj.flagNoData:
                         return 0
                     if pairIndexList == []:
                         pairIndexList = numpy.arange(len(self.dataOutObj.pairList))
                     nChannels = len(channelIndexList)
                     nPairs = len(pairIndexList)
                     blocksize = 0
                     #self spectra
                     spc = self.dataOutObj.data_spc[channelIndexList,:,:]
                     blocksize += spc.size
                     cspc = None
                     if pairIndexList != []:
                         cspc = self.dataOutObj.data_cspc[pairIndexList,:,:]
                         blocksize += cspc.size
                     #DC channel
                     dc = None
                     if self.dataOutObj.m_ProcessingHeader.flag_dc:
                         dc = self.dataOutObj.data_dc[channelIndexList,:]
                         blocksize += dc.size
                     #Almacenar las combinaciones de canales y cros espectros
                     spectraComb = numpy.zeros( (nChannels+nPairs)*2,numpy.dtype('u1'))
                     i = 0
                     for spcChannel in channelIndexList:
                         spectraComb[i]   = spcChannel
                         spectraComb[i+1] = spcChannel
                         i += 2
                     if pairList != None:
                         for pair in pairList:
                             spectraComb[i]   = pair[0]
                             spectraComb[i+1] = pair[1]
                             i += 2
                     #######
                     self.dataOutObj.data_spc = spc
                     self.dataOutObj.data_cspc = cspc
                     self.dataOutObj.data_dc = dc
                     self.dataOutObj.nChannels = nChannels
                     self.dataOutObj.nPairs = nPairs
                     self.dataOutObj.channelIndexList = channelIndexList
                     self.dataOutObj.m_ProcessingHeader.spectraComb = spectraComb
                     self.dataOutObj.m_ProcessingHeader.totalSpectra = nChannels + nPairs
                     self.dataOutObj.m_SystemHeader.numChannels = nChannels
                     self.dataOutObj.nChannels = nChannels
                     self.dataOutObj.m_ProcessingHeader.blockSize = blocksize
                     if cspc == None:
                         self.dataOutObj.m_ProcessingHeader.flag_dc = False
                     if dc == None:
                         self.dataOutObj.m_ProcessingHeader.flag_cpsc = False
                 def selectHeightsByValue(self, minHei, maxHei):
                     """
                     Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
                     minHei <= height <= maxHei
                     Input:
                         minHei    :    valor minimo de altura a considerar
                         maxHei    :    valor maximo de altura a considerar
                     Affected:
                         Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
                     Return:
                         None
                     """
                     if self.dataOutObj.flagNoData:
                         return 0
                     if (minHei < self.dataOutObj.heightList[0]) or (minHei > maxHei):
                         raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
                     if (maxHei > self.dataOutObj.heightList[-1]):
                         raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
                     minIndex = 0
                     maxIndex = 0
                     data = self.dataOutObj.heightList
                     for i,val in enumerate(data):
                         if val < minHei:
                             continue
                         else:
                             minIndex = i;
                             break
                     for i,val in enumerate(data):
                         if val <= maxHei:
                             maxIndex = i;
                         else:
                             break
                     self.selectHeightsByIndex(minIndex, maxIndex)
                 def selectHeightsByIndex(self, minIndex, maxIndex):
                     """
                     Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
                     minIndex <= index <= maxIndex
                     Input:
                         minIndex    :    valor minimo de altura a considerar
                         maxIndex    :    valor maximo de altura a considerar
                     Affected:
                         self.dataOutObj.data_spc
                         self.dataOutObj.data_cspc
                         self.dataOutObj.data_dc
                         self.dataOutObj.heightList
                         self.dataOutObj.nHeights
                         self.dataOutObj.m_ProcessingHeader.numHeights
                         self.dataOutObj.m_ProcessingHeader.blockSize
                         self.dataOutObj.m_ProcessingHeader.firstHeight
                         self.dataOutObj.m_RadarControllerHeader.numHeights
                     Return:
                         None
                     """
                     if self.dataOutObj.flagNoData:
                         return 0
                     if (minIndex < 0) or (minIndex > maxIndex):
                         raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
                     if (maxIndex >= self.dataOutObj.nHeights):
                         raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
                     nChannels = self.dataOutObj.nChannels
                     nPairs = self.dataOutObj.nPairs
                     nProfiles = self.dataOutObj.nProfiles
                     dataType = self.dataOutObj.dataType
                     nHeights = maxIndex - minIndex + 1
                     blockSize = 0
                     #self spectra
                     spc = self.dataOutObj.data_spc[:,:,minIndex:maxIndex+1]
                     blockSize += spc.size
                     #cross spectra
                     cspc = None
                     if self.dataOutObj.data_cspc != None:
                         cspc = self.dataOutObj.data_cspc[:,:,minIndex:maxIndex+1]
                         blockSize += cspc.size
                     #DC channel
                     dc = self.dataOutObj.data_dc[:,minIndex:maxIndex+1]
                     blockSize += dc.size
                     self.dataOutObj.data_spc = spc
                     if cspc != None:
                         self.dataOutObj.data_cspc = cspc
                     self.dataOutObj.data_dc = dc
                     firstHeight = self.dataOutObj.heightList[minIndex]
                     self.dataOutObj.nHeights = nHeights
                     self.dataOutObj.m_ProcessingHeader.blockSize = blockSize
                     self.dataOutObj.m_ProcessingHeader.numHeights = nHeights
                     self.dataOutObj.m_ProcessingHeader.firstHeight = firstHeight
                     self.dataOutObj.m_RadarControllerHeader.numHeights = nHeights
                     self.dataOutObj.heightList = self.dataOutObj.heightList[minIndex:maxIndex+1]
             class IncoherentIntegration:
                 integ_counter = None
                 data = None
                 navg = None
                 buffer = None
                 nIncohInt = None
                 def __init__(self, N = None, timeInterval = None):
                     """
                     N
                     timeInterval - interval time [min], integer value
                     """
                     self.data = None
                     self.navg = None
                     self.buffer = None
                     self.timeOut = None
                     self.exitCondition = False
                     self.isReady = False
                     self.nIncohInt = N
                     self.integ_counter = 0
                     if timeInterval!=None:
                         self.timeIntervalInSeconds = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
                     if ((timeInterval==None) and (N==None)):
                          print 'N = None ; timeInterval = None'
                          sys.exit(0)
                     elif timeInterval == None:
                         self.timeFlag = False
                     else:
                         self.timeFlag = True
                 def exe(self,data,timeOfData):
                     """
                     data
                     timeOfData [seconds]
                     """
                     if self.timeFlag:
                         if self.timeOut == None:
                             self.timeOut = timeOfData + self.timeIntervalInSeconds
                         if timeOfData < self.timeOut:
                             if self.buffer == None:
                                 self.buffer = data
                             else:
                                 self.buffer = self.buffer + data
                             self.integ_counter += 1
                         else:
                             self.exitCondition = True
                     else:
                         if self.integ_counter < self.nIncohInt:
                             if self.buffer == None:
                                 self.buffer = data
                             else:
                                 self.buffer = self.buffer + data
                             self.integ_counter += 1
                         if self.integ_counter == self.nIncohInt:
                             self.exitCondition = True
                     if self.exitCondition:
                         self.data = self.buffer
                         self.navg = self.integ_counter
                         self.isReady = True
                         self.buffer = None
                         self.timeOut = None
                         self.integ_counter = 0
                         self.exitCondition = False
                         if self.timeFlag:
                             self.buffer = data
                             self.timeOut = timeOfData + self.timeIntervalInSeconds
                     else:
                         self.isReady = False
   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