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

                 plplot.plsfnam(filename)
                 plplot.plcpstrm(curr_strm,0)
                 plplot.plreplot()
-                plplot.plclear()
                 plplot.plend1()
                 plplot.plsstrm(curr_strm)
                 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")
             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 == "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
                 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)
-            class SpectraPlot:
+            class PcolorPlot:
                 pcolorObjDic = {}
                 colorbarObjDic = {}
                 pwprofileObjDic = {}
                     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)
                     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
                     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
                         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
                         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
             #        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
                                             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:
                         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)
                         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()

schainpy/Graphics/SpectraPlot.py +75 -31

                     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,
                              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 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

                     self.linearplotObj.refresh()
             class RTI:
                 colorplotObj = None

schainpy/Processing/JRONoise.py +22 -35

@@ -1,7 +1,6
1	import numpy	1	import numpy
2	from Model.Spectra import Spectra
3		2
4	def hildebrand_sekhon(Data, navg):	3	def hildebrand_sekhon(data, navg):
5	"""	4	"""
6	This method is for the objective determination of de noise level in Doppler spectra. This	5	This method is for the objective determination of de noise level in Doppler spectra. This
7	implementation technique is based on the fact that the standard deviation of the spectral	6	implementation technique is based on the fact that the standard deviation of the spectral
@@ -16,51 +15,39 def hildebrand_sekhon(Data, navg):
16	anoise : noise's level	15	anoise : noise's level
17	"""	16	"""
18		17
19	divisor = 8	18	dataflat = data.reshape(-1)
20	ratio = 7 / divisor	19	dataflat.sort()
21	data = Data.reshape(-1)	20	npts = dataflat.size #numbers of points of the data
22	npts = data.size #numbers of points of the data
23		21
24	if npts < 32:	22	if npts < 32:
25	print "error in noise - requires at least 32 points"	23	print "error in noise - requires at least 32 points"
26	return -1.0	24	return -1.0
27		25
		26	dataflat2 = numpy.power(dataflat,2)
		27
		28	cs = numpy.cumsum(dataflat)
		29	cs2 = numpy.cumsum(dataflat2)
		30
28	# data sorted in ascending order	31	# data sorted in ascending order
29	nmin = int(npts/~~divisor~~ + ~~ratio~~);	32	nmin = int((npts + 7.)/8)
30	s = 0.0
31	s2 = 0.0
32	data2 = data[:npts]
33	data2.sort()
34
35	for i in range(nmin):
36	s += data2[i]
37	s2 += data2[i]**2;
38
39	icount = nmin
40	iflag = 0
41		33
42	for i in range(nmin, npts):	34	for i in range(nmin, npts):
43	s += ~~data2~~[i];	35	s = cs[i]
44	s2 += ~~data~~2[i]**2	36	s2 = cs2[i]
45	icount=icount+1;	37	p = s / float(i);
46	p = s / float(icount);
47	p2 = p**2;	38	p2 = p**2;
48	q = s2 / float(i~~count~~) - p2;	39	q = s2 / float(i) - p2;
49	leftc = p2;	40	leftc = p2;
50	rightc = q * float(navg);	41	rightc = q * float(navg);
51		42	R2 = leftc/rightc
52	if leftc > rightc:	43
53	iflag = 1; #No weather signal
54	# Signal detect: R2 < 1 (R2 = leftc/rightc)	44	# Signal detect: R2 < 1 (R2 = leftc/rightc)
55	if(~~leftc~~ < ~~rightc~~):	45	if R2 < 1:
56	if i~~flag~~:	46	npts_noise = i
57	break	47	break
58		48
59	anoise = 0.0;	49
60	for j in range(i):	50	anoise = numpy.average(dataflat[0:npts_noise])
61	anoise += data2[j];
62
63	anoise = anoise / float(i);
64		51
65	return anoise;	52	return anoise;
66		53

schainpy/Processing/SpectraProcessor.py +13 -10

             '''
             import os, sys
             import numpy
+            import time
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
                         self.buffer[:,self.profIndex,:] = self.dataInObj.data
                         self.profIndex += 1
                         if self.profIndex == self.nFFTPoints:
                             self.__getFft()
                             self.dataOutObj.flagNoData = False
                         self.dataOutObj.m_ProcessingHeader.spectraComb
                         self.dataOutObj.m_ProcessingHeader.shif_fft
                     """
                     if self.dataInObj.flagNoData:
                         return 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
                     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)
                              showPowerProfile=False,
                              XAxisAsTime=False,
                              save=False,
-                             index=None):
+                             index=None,
+                             channelList=[]):
                     if self.dataOutObj.flagNoData:
                         return 0
                                                                        showColorbar,
                                                                        showPowerProfile,
                                                                        XAxisAsTime,
-                                                                       save)
+                                                                       save,
+                                                                       channelList)
                     self.plotterObjIndex += 1
                         #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):

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