From 1997872d9e6c6cf99302ba85c6d0c1ac8006bfeb 2012-10-30 21:40:46
From: Daniel Valdez <daniel.suarez@jro.igp.gob.pe>
Date: 2012-10-30 21:40:46
Subject: [PATCH] Nueva version para graficos Scope, RTI, Spectra. Se hicieron pruebas con los experimentos EwDRIFTS, MST, IMAGING

---

diff --git a/schainpy2/Graphics/schainPlot.py b/schainpy2/Graphics/schainPlot.py
index febfb8e..e39a220 100644
--- a/schainpy2/Graphics/schainPlot.py
+++ b/schainpy2/Graphics/schainPlot.py
@@ -25,33 +25,28 @@ class Figure:
     figuretitle = ""
     xrangestep = None
     
-    def __init__(self,idfigure, nframes, wintitle, xw=600, yw=800, overplot=0, driver='plplot', colorbar= True, colormap=None, *args):
+    def __init__(self,idfigure, nframes, wintitle, xw=600, yw=800, overplot=0, driver='plplot', colormap=None, colorbar= True, *args):
+        
+        self.drvObj = Driver(driver, idfigure, xw, yw, wintitle, overplot, colormap, colorbar)
+        self.driver = driver
         self.idfigure = idfigure
-        self.nframes = nframes
-        self.wintitle = wintitle
         self.xw = xw
         self.yw = yw
+        self.nframes = nframes
+        self.wintitle = wintitle
+        self.colormap = colormap
         self.overplot = overplot
         self.colorbar = colorbar
-        self.colormap = colormap
-        #esta seccion deberia ser dinamica de acuerdo a len(args)
-        self.showGraph1 = args[0]
-        self.showGraph2 = args[1]  
-        
-        self.drvObj = Driver(driver, idfigure, xw, yw, wintitle, overplot, colorbar, colormap)
+#        self.showGraph1 = args[0]
+#        self.showGraph2 = args[1]  
         
         self.drvObj.driver.setFigure()
         self.drvObj.driver.setColormap(colormap)
         
+        
     
     def __openDriver(self):
         self.drvObj.driver.openDriver()
-    
-#    def __openFigure(self):
-#        nrows, ncolumns = self.getSubplots()
-#        self.drvObj.driver.openFigure()
-#        self.drvObj.driver.setTitleFig(title)
-#        self.drvObj.driver.setSubPlots(nrows, ncolumns)
         
     def __initFigure(self):
         nrows, ncolumns = self.getSubplots()
@@ -60,10 +55,12 @@ class Figure:
         self.drvObj.driver.setSubPlots(nrows, ncolumns)
     
     def __isOutOfXRange(self,x):
-        
-        if ((x>=self.xmin) and (x<self.xmax)):
+        try:
+            if ((x>=self.xmin) and (x<self.xmax)):
+                return 0
+        except:
             return 0
-
+        
         return 1
     
     def changeXRange(self,x):
@@ -110,7 +107,7 @@ class Figure:
             self.__isConfig = True
         
         if not(self.__isOutOfXRange(x)):
-            self.__changeXRange(x)
+            self.changeXRange(x)
             
             if self.__isFigureOpen:
                 self.driverObj.closePage()
@@ -163,7 +160,9 @@ class Figure:
                     figuretitle=None,
                     xrangestep=None, 
                     save=False, 
-                    gpath='./'):
+                    gpath='./',
+                    clearData=False,
+                    *args):
 
         
         if figuretitle == None:
@@ -190,10 +189,6 @@ class Figure:
                 return 0
             
             self.__isFigureOpen = False
-            
-#            if self.__isFigureOpen:
-#                self.driverObj.closePage()
-#                self.__isFigureOpen = False
         
         if not(self.__isFigureOpen):
 
@@ -202,24 +197,30 @@ class Figure:
             self.__isFigureOpen = True
         
             for channel in channelList:
+                if len(args) != 0: value = args[0][channel]
+                else: value = args
+                
                 frameObj = self.frameObjList[channel]
-                frameObj.init(xmin=self.xmin,
-                              xmax=self.xmax,
-                              ymin=self.ymin,
-                              ymax=self.ymax,
-                              minvalue=self.minvalue,
-                              maxvalue=self.maxvalue,
-                              deltax=self.deltax,
-                              deltay=self.deltay)
+                frameObj.init(self.xmin,
+                              self.xmax,
+                              self.ymin,
+                              self.ymax,
+                              self.minvalue,
+                              self.maxvalue,
+                              self.deltax,
+                              self.deltay,
+                              self.colorbar,
+                              value)
         
         for channel in channelList:
             dataCh = data[channel,:]
             frameObj = self.frameObjList[channel]
-#            frameObj.clearData()
             frameObj.plot(x, y, dataCh)
             
-#            frameObj.refresh()
+
         self.__refresh()
+        if clearData == True:
+            self.__isFigureOpen = False
             
 
     
@@ -253,10 +254,12 @@ class Frame:
         return xi, yi, xw, yw
     
     
-    def init(self, xmin, xmax, ymin, ymax, minvalue, maxvalue, deltax=None, deltay=None):   
+    def init(self, xmin, xmax, ymin, ymax, minvalue, maxvalue, deltax=None, deltay=None, colorbar=False, *args):   
          
         for plotObj in self.plotObjList:
-            plotObj.plotBox(xmin, xmax, ymin, ymax, minvalue, maxvalue, deltax, deltay)
+            plotObj.setBox(xmin, xmax, ymin, ymax, minvalue, maxvalue, deltax, deltay, colorbar, *args)
+            plotObj.plotBox()
+
 
 
 class Plot:
@@ -272,6 +275,9 @@ class Plot:
     szchar = None
     idframe = None
     idplot = None
+    colorbar = None
+    cbxpos = None
+    cbypos = None
     
     def __init__(self, drvObj, idframe, idplot, xi, yi, xw, yw):
         self.drvObj = drvObj
@@ -282,13 +288,8 @@ class Plot:
         self.xw = xw
         self.yw = yw
 
-    def plotBox(self, xmin, xmax, ymin, ymax, minvalue, maxvalue):
-        self.xmin = xmin
-        self.xmax = xmax
-        self.ymin = ymin
-        self.ymax = ymax
-        self.minvalue = minvalue
-        self.maxvalue = maxvalue
+
+    def plotBox(self):
         
         self.drvObj.driver.plotBox(self.idframe, 
                                    self.xpos, 
@@ -306,6 +307,9 @@ class Plot:
                                    self.timefmt)
         
         self.drvObj.driver.setPlotLabels(self.xlabel, self.ylabel, self.title)
+        
+        if self.colorbar:
+            self.drvObj.driver.plotColorbar(self.minvalue, self.maxvalue, self.cbxpos,self.cbypos)
     
     def plotPcolor(self, x, y, z, deltax, deltay, getGrid):
         
diff --git a/schainpy2/Graphics/schainPlotLib.py b/schainpy2/Graphics/schainPlotLib.py
index 29e751a..c1f8e4c 100644
--- a/schainpy2/Graphics/schainPlotLib.py
+++ b/schainpy2/Graphics/schainPlotLib.py
@@ -152,6 +152,9 @@ class PlplotDriver:
         if getGrid:
             self.__xg, self.__yg = self.__getGrid(x, y, deltax, deltay)
         
+        if deltax == None: deltax = x[-1] - x[0]
+#        if deltay == None: deltay = y[-1] - y[-2]
+        
         xmin = x[0] 
         xmax = xmin + deltax
         
diff --git a/schainpy2/Graphics/schainPlotTypes.py b/schainpy2/Graphics/schainPlotTypes.py
index 1536d4d..5005855 100644
--- a/schainpy2/Graphics/schainPlotTypes.py
+++ b/schainpy2/Graphics/schainPlotTypes.py
@@ -2,7 +2,171 @@ import numpy
 import datetime
 import time
 from schainPlot import *
-#from schainPlotLib import Driver
+
+class SpcFigure(Figure):
+    overplot = 0
+    xw = 800
+    yw = 650
+    showprofile = False
+    
+    def __init__(self, idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile):
+        Figure.__init__(self,idfigure, nframes, wintitle, self.xw, self.yw, self.overplot, driver, colormap, colorbar)
+        
+        self.showprofile = showprofile
+    
+    def getSubplots(self):
+        ncolumns = int(numpy.sqrt(self.nframes)+0.9)
+        nrows = int(self.nframes*1./ncolumns + 0.9)
+        
+        return nrows, ncolumns
+    
+    def setParms(self, data, x, y, xmin, xmax, ymin, ymax, minvalue, maxvalue, *args):
+        
+        if xmin == None: xmin = numpy.min(x)
+        if xmax == None: xmax = numpy.max(x)
+        if ymin == None: ymin = numpy.min(y)
+        if ymax == None: ymax = numpy.max(y)
+        if minvalue == None: minvalue = 20.
+        if maxvalue == None: maxvalue = 90.
+        
+        self.xmin = xmin
+        self.xmax = xmax
+        self.minrange = ymin
+        self.maxrange = ymax
+        self.ymin = ymin
+        self.ymax = ymax
+        self.minvalue = minvalue
+        self.maxvalue = maxvalue
+        
+    
+    def changeXRange(self, *args):
+        pass
+    
+    def createFrames(self):
+        for frame in range(self.nframes):
+            frameObj = SpcFrame(self.drvObj,frame + 1, self.colorbar, self.showprofile)
+            self.frameObjList.append(frameObj)
+    
+class SpcFrame(Frame):
+    def __init__(self,drvObj,idframe,colorbar,showprofile):
+        self.drvObj = drvObj
+        self.idframe = idframe
+        self.nplots = 1
+        
+        if showprofile:
+            self.nplots += 1
+        
+        self.colorbar = colorbar
+        self.showprofile = showprofile
+        self.createPlots()
+    
+    def createPlots(self):
+        plotObjList = []
+        idplot = 0
+        xi, yi, xw, yw = self.getScreenPos(idplot)
+        plotObj = SpcPlot(self.drvObj, self.idframe, idplot, xi, yi, xw, yw, self.colorbar)
+        plotObjList.append(plotObj)
+        
+        if self.showprofile:
+            idplot = 1
+            xi, yi, xw, yw = self.getScreenPos(idplot)
+            type = "pwbox"
+            title = ""
+            xlabel = "dB"
+            ylabel = ""
+            plotObj = Plot1D(self.drvObj, self.idframe, idplot, xi, yi, xw, yw, type, title, xlabel, ylabel)
+            plotObjList.append(plotObj)
+        
+        self.plotObjList = plotObjList
+    
+    def getScreenPosMainPlot(self):
+        xi = 0.15
+        
+        if self.showprofile:
+            xw = 0.65     
+        
+        else:
+            xw = 0.75 
+        
+        if self.colorbar:
+            xw = xw - 0.06
+        
+        yi = 0.20; yw = 0.75
+            
+        return xi, yi, xw, yw
+    
+    def getScreenPosGraph1(self):
+        if self.colorbar:
+            xi = 0.65 + 0.08
+        else:
+            xi = 0.75 + 0.05
+        
+        xw = xi + 0.2
+        
+        yi = 0.2; yw = 0.75
+        
+        return xi, yi, xw, yw
+    
+    def plot(self,x, y, data):
+        plotObj = self.plotObjList[0]
+        plotObj.plot(x,y,data)
+        
+        if self.showprofile:
+            plotObj = self.plotObjList[1]
+            plotObj.plot(data,y)
+
+class SpcPlot(Plot):
+    
+    getGrid = True
+    
+    def __init__(self, drvObj, idframe, idplot, xi, yi, xw, yw, colorbar):
+        self.drvObj = drvObj
+        self.idframe = idframe
+        self.idplot = idplot
+        self.xi = xi
+        self.yi = yi
+        self.xw = xw
+        self.yw = yw
+        self.colorbar = colorbar
+        
+        if self.colorbar:
+            cbxi = xw + 0.03
+            cbxw = cbxi + 0.03
+            cbyi = yi
+            cbyw = yw
+            self.cbxpos = [cbxi,cbxw]
+            self.cbypos = [cbyi,cbyw]
+        
+        self.xpos = [self.xi,self.xw]
+        self.ypos = [self.yi,self.yw]
+        self.xaxisastime = False
+        self.timefmt = None
+        self.xopt = "bcnst"
+        self.yopt = "bcnstv"
+        
+        self.szchar = 0.8
+        self.strforchannel = "Channel %d"%self.idframe
+        self.xlabel = "m/s"
+        self.ylabel = "Range (Km)"
+    
+    def setBox(self, xmin, xmax, ymin, ymax, minvalue, maxvalue, *args):
+        self.xmin = xmin
+        self.xmax = xmax
+        self.ymin = ymin
+        self.ymax = ymax
+        self.minvalue = minvalue
+        self.maxvalue = maxvalue
+        self.colorbar = args[2]
+        self.title = "%s - %s"%(self.strforchannel,args[3])
+        
+        
+    
+    def plot(self, x, y, data):
+        z = data
+        deltax = None
+        deltay = None
+        self.plotPcolor(x, y, z, deltax, deltay, self.getGrid)
+        self.getGrid = False
 
 
 class RTIFigure(Figure):
@@ -19,18 +183,11 @@ class RTIFigure(Figure):
     xrangestepinsecs = None
     
     
-    def __init__(self, idfigure, nframes, wintitle, driver, colormap="br_green", colorbar= True, showprofile=False):
-        self.idfigure = idfigure
-        self.nframes = nframes
-        self.wintitle = wintitle
-        self.colormap = colormap
-        self.colorbar = colorbar
+    def __init__(self, idfigure, nframes, wintitle, driver, colormap="br_green", colorbar= True, showprofile=False):        
+        Figure.__init__(self,idfigure, nframes, wintitle, self.xw, self.yw, self.overplot, driver, colormap, colorbar)
+        
         self.showprofile = showprofile
-        self.driver = driver
-        self.drvObj = Driver(self.driver, self.idfigure, self.xw, self.yw, self.wintitle, self.overplot, self.colormap, self.colorbar)
-        self.drvObj.driver.setFigure()
-        self.drvObj.driver.setColormap(colormap)
-    
+        
     def getSubplots(self):
         nrows = self.nframes 
         ncolumns = 1
@@ -41,7 +198,7 @@ class RTIFigure(Figure):
         self.starttime = xmin
         self.endtime = xmax
         
-        cdatetime = datetime.datetime.utcfromtimestamp(x) #siempre en localtime
+        cdatetime = datetime.datetime.utcfromtimestamp(x) 
         
         mindatetime = datetime.datetime(cdatetime.year,cdatetime.month,cdatetime.day,self.starttime.hour,self.starttime.minute,self.starttime.second)
         if ((xrangestep == 0) or (xrangestep == None)):
@@ -83,11 +240,10 @@ class RTIFigure(Figure):
         self.maxvalue = maxvalue
         self.xrangestep = xrangestep
         self.deltax = deltax
-        
-    
+
     def changeXRange(self,x):
         
-        cdatetime = datetime.datetime.utcfromtimestamp(x) #siempre en localtime
+        cdatetime = datetime.datetime.utcfromtimestamp(x) 
         
         if ((cdatetime.time()>=self.starttime) and (cdatetime.time()<self.endtime)):
             if self.xrangestep == 1:
@@ -99,19 +255,15 @@ class RTIFigure(Figure):
             if self.xrangestep == 3:
                 mindatetime = datetime.datetime(cdatetime.year,cdatetime.month,cdatetime.day,cdatetime.hour,cdatetime.minute,cdatetime.second)
 
-#            mindatetime = datetime.datetime(cdatetime.year,cdatetime.month,cdatetime.day,self.starttime.hour,self.starttime.minute,self.starttime.second)
             self.xmin = time.mktime(mindatetime.timetuple()) - time.timezone
             self.xmax = self.xmin + self.xrangestepinsecs
             
-            self.figuretitle = "%s: %s - %s"%(self.figuretitle,
+            self.figuretitle = "%s %s : %s"%(self.figuretitle,
                                               datetime.datetime.utcfromtimestamp(self.xmin).strftime("%d-%b-%Y %H:%M:%S"), 
                                               datetime.datetime.utcfromtimestamp(self.xmax).strftime("%d-%b-%Y %H:%M:%S"))
-        
-        
             return 1
         
         return 0
-        
     
     def createFrames(self):
         for frame in range(self.nframes):
@@ -136,23 +288,26 @@ class RTIFrame(Frame):
         
         idplot = 0
         xi, yi, xw, yw = self.getScreenPos(idplot)
+        
         plotObj = RTIPlot(self.drvObj, self.idframe, idplot, xi, yi, xw, yw, self.colorbar)
         plotObjList.append(plotObj)
         
         if self.showprofile:
             idplot = 1
             xi, yi, xw, yw = self.getScreenPos(idplot)
-            plotObj = Plot1D(self.drvObj, self.idframe, idplot, xi, yi, xw, yw)
+            type = "pwbox"
+            title = ""
+            xlabel = "dB"
+            ylabel = ""
+            plotObj = Plot1D(self.drvObj, self.idframe, idplot, xi, yi, xw, yw, type, title, xlabel, ylabel)
             plotObjList.append(plotObj)
         
         self.plotObjList = plotObjList
 
-    def getScreenPosMainPlot(self):#cada Frame determina las coordenadas de los plots
+    def getScreenPosMainPlot(self):
         xi = 0.07
-        
         if self.showprofile:
             xw = 0.65     
-        
         else:
             xw = 0.9 
         
@@ -165,7 +320,7 @@ class RTIFrame(Frame):
     
     def getScreenPosGraph1(self):
         if self.colorbar:
-            xi = 0.65 + 0.05
+            xi = 0.65 + 0.08
         else:
             xi = 0.9 + 0.05
         
@@ -176,9 +331,6 @@ class RTIFrame(Frame):
         return xi, yi, xw, yw
     
     def plot(self, currenttime, range, data):
-#        for plotObj in self.plotObjList:
-#            plotObj.plot(currenttime, range, data)
-            
         plotObj = self.plotObjList[0]
         plotObj.plot(currenttime,range,data)
         
@@ -227,7 +379,7 @@ class RTIPlot(Plot):
         self.ylabel = "Range (Km)"
 
     
-    def plotBox(self, xmin, xmax, ymin, ymax, minvalue, maxvalue, deltax=None, deltay=None):
+    def setBox(self, xmin, xmax, ymin, ymax, minvalue, maxvalue, deltax=None, deltay=None, colorbar=True, *args):
         self.xmin = xmin
         self.xmax = xmax
         self.ymin = ymin
@@ -236,28 +388,7 @@ class RTIPlot(Plot):
         self.maxvalue = maxvalue
         self.deltax = deltax
         self.deltay = deltay
-        
-        self.drvObj.driver.plotBox(self.idframe, 
-                                   self.xpos, 
-                                   self.ypos, 
-                                   self.xmin, 
-                                   self.xmax, 
-                                   self.ymin, 
-                                   self.ymax, 
-                                   self.minvalue, 
-                                   self.maxvalue, 
-                                   self.xopt, 
-                                   self.yopt, 
-                                   self.szchar, 
-                                   self.xaxisastime, 
-                                   self.timefmt)
-        
-        self.drvObj.driver.setPlotLabels(self.xlabel, self.ylabel, self.title)
-        
-        if self.colorbar:
-            self.drvObj.driver.plotColorbar(minvalue, maxvalue, self.cbxpos,self.cbypos)
-            
-
+        self.colorbar = colorbar
     
     def plot(self, currenttime, range, data):
         
@@ -330,7 +461,11 @@ class ScopeFrame(Frame):
         plotObjList = []
         for idplot in range(self.nplots):
             xi, yi, xw, yw = self.getScreenPos(idplot)
-            plotObj = Plot1D(self.drvObj, self.idframe, idplot, xi, yi, xw, yw)
+            type = "scopebox"
+            title = "Channel %d"%self.idframe
+            xlabel = "range (Km)"
+            ylabel = "intensity"
+            plotObj = Plot1D(self.drvObj, self.idframe, idplot, xi, yi, xw, yw, type, title, xlabel, ylabel)
             plotObjList.append(plotObj)
         self.plotObjList = plotObjList
 #            self.plotObjList.append(plotObj)
@@ -341,8 +476,8 @@ class ScopeFrame(Frame):
             
 
 class Plot1D(Plot):
-    
-    def __init__(self, drvObj, idframe, idplot, xi, yi, xw, yw):
+#    type, title, xlabel, ylabel
+    def __init__(self, drvObj, idframe, idplot, xi, yi, xw, yw, type, title, xlabel, ylabel):
         self.drvObj = drvObj
         self.idframe = idframe
         self.idplot = idplot
@@ -357,10 +492,31 @@ class Plot1D(Plot):
         self.xopt = "bcnst"
         self.yopt = "bcnstv"
         self.szchar = 1.0
-        self.title = "Channel %d"%self.idframe
-        self.xlabel = "x-axis"
-        self.ylabel = "y-axis"
+        self.type = type
+        self.title = title
+        self.xlabel = xlabel
+        self.ylabel = ylabel
+            
 
+    
+    def setBox(self, xmin, xmax, ymin, ymax, minvalue, maxvalue, *args):
+        if self.type == "pwbox":
+            self.xmin = minvalue
+            self.xmax = maxvalue
+            self.ymin = ymin
+            self.ymax = ymax
+            self.minvalue = minvalue
+            self.maxvalue = maxvalue
+            
+        else:
+            self.xmin = xmin
+            self.xmax = xmax
+            self.ymin = ymin
+            self.ymax = ymax
+            self.minvalue = minvalue
+            self.maxvalue = maxvalue
+            
+        self.colorbar = False
 
     def plot(self,x,y):
         if y.dtype == "complex128":
diff --git a/schainpy2/Processing/SpectraProcessor.py b/schainpy2/Processing/SpectraProcessor.py
index dd48641..8d7304d 100644
--- a/schainpy2/Processing/SpectraProcessor.py
+++ b/schainpy2/Processing/SpectraProcessor.py
@@ -7,13 +7,13 @@ $Id$
 import os, sys
 import numpy
 import time
-
+import datetime
 path = os.path.split(os.getcwd())[0]
 sys.path.append(path)
 
 from Data.JROData import Spectra
 from IO.SpectraIO import SpectraWriter
-#from Graphics.SpectraPlot import Spectrum
+from Graphics.schainPlotTypes import SpcFigure
 #from JRONoise import Noise
 
 class SpectraProcessor:
@@ -36,36 +36,6 @@ class SpectraProcessor:
     writerObjIndex = None
     
     profIndex = 0 # Se emplea cuando el objeto de entrada es un Voltage
-    
-#    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):
@@ -75,8 +45,10 @@ class SpectraProcessor:
         
         self.integratorObjIndex = None
         self.writerObjIndex = None
+        self.plotObjIndex = None
         self.integratorObjList = []
         self.writerObjList = []
+        self.plotObjList = []
         self.noiseObj = None
         self.buffer = None
         self.profIndex = 0
@@ -99,71 +71,13 @@ class SpectraProcessor:
             
         self.dataOutObj = dataOutObj
         
-#        self.noiseObj = Noise() #aun no se incluye el objeto 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.nHeights = self.dataInObj.nHeights
-#        self.dataOutObj.nHeights = self.nHeights
-#        self.dataOutObj.heightList = self.dataInObj.heightList
-#        
         
         self.integratorObjIndex = 0
         self.writerObjIndex = 0
-        
+        self.plotObjIndex = 0
         if self.dataInObj.type == "Voltage":
             
             if self.buffer == None:
@@ -266,6 +180,76 @@ class SpectraProcessor:
         objIncohInt = IncoherentIntegration(N,timeInterval)
         self.integratorObjList.append(objIncohInt)
     
+    def addSpc(self, idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile):
+        spcObj = SpcFigure(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
+        self.plotObjList.append(spcObj)
+    
+    def plotSpc(self, idfigure=None,
+                    xmin=None,
+                    xmax=None,
+                    ymin=None,
+                    ymax=None,
+                    minvalue=None,
+                    maxvalue=None,
+                    wintitle='',
+                    driver='plplot',
+                    colormap='br_greeen',
+                    colorbar=True,
+                    showprofile=False,
+                    save=False,
+                    gpath=None):
+        
+        if self.dataOutObj.flagNoData:
+            return 0
+        
+        nframes = len(self.dataOutObj.channelList)
+        
+        if len(self.plotObjList) <= self.plotObjIndex:
+            self.addSpc(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
+            
+        x = numpy.arange(self.dataOutObj.nFFTPoints)
+                
+        y = self.dataOutObj.heightList
+        
+        channelList = self.dataOutObj.channelList
+        
+        data = 10.*numpy.log10(self.dataOutObj.data_spc[channelList,:,:])    
+#        noisedB = 10.*numpy.log10(noise)
+        noisedB = numpy.arange(len(channelList)+1)
+        noisedB = noisedB *1.2
+        titleList = []
+        for i in range(len(noisedB)):
+            title = "%.2f"%noisedB[i]
+            titleList.append(title)
+        
+        thisdatetime = datetime.datetime.fromtimestamp(self.dataOutObj.dataUtcTime)
+        dateTime = "%s"%(thisdatetime.strftime("%d-%b-%Y %H:%M:%S"))
+        figuretitle = "Spc Radar Data: %s"%dateTime
+        
+        cleardata = True
+        
+        plotObj = self.plotObjList[self.plotObjIndex]
+        
+        plotObj.plotPcolor(data, 
+                           x, 
+                           y, 
+                           channelList, 
+                           xmin, 
+                           xmax, 
+                           ymin, 
+                           ymax,
+                           minvalue, 
+                           maxvalue, 
+                           figuretitle, 
+                           None,
+                           save, 
+                           gpath,
+                           cleardata,
+                           titleList)
+        
+        self.plotObjIndex += 1
+    
+    
     def writeData(self, wrpath, blocksPerFile):
         if self.dataOutObj.flagNoData:
                 return 0
@@ -292,7 +276,6 @@ class SpectraProcessor:
             self.dataOutObj.data_spc = myIncohIntObj.data
             self.dataOutObj.nAvg = myIncohIntObj.navg
             self.dataOutObj.m_ProcessingHeader.incoherentInt = self.dataInObj.m_ProcessingHeader.incoherentInt*myIncohIntObj.navg
-            #print "myIncohIntObj.navg: ",myIncohIntObj.navg
             self.dataOutObj.flagNoData = False
             
             """Calcular el ruido"""
diff --git a/schainpy2/Processing/VoltageProcessor.py b/schainpy2/Processing/VoltageProcessor.py
index e69fdc1..3756fd5 100644
--- a/schainpy2/Processing/VoltageProcessor.py
+++ b/schainpy2/Processing/VoltageProcessor.py
@@ -54,8 +54,8 @@ class VoltageProcessor:
         # No necesita copiar en cada init() los atributos de dataInObj
         # la copia deberia hacerse por cada nuevo bloque de datos
 
-    def addRti(self, idfigure, nframes, wintitle, driver, colorbar, colormap, showprofile):
-        rtiObj = RTIFigure(idfigure, nframes, wintitle, driver, colorbar, colormap, showprofile)
+    def addRti(self, idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile):
+        rtiObj = RTIFigure(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
         self.plotObjList.append(rtiObj)
 
     def plotRti(self, idfigure=None,
@@ -89,8 +89,6 @@ class VoltageProcessor:
 #        if timezone == "lt":
         currenttime = self.dataOutObj.dataUtcTime - time.timezone
         
-            
-        
         range = self.dataOutObj.heightList
         
         channelList = self.dataOutObj.channelList
@@ -103,6 +101,8 @@ class VoltageProcessor:
         
         plotObj = self.plotObjList[self.plotObjIndex]
         
+        cleardata = False
+        
         plotObj.plotPcolor(data, 
                            currenttime, 
                            range, 
@@ -116,7 +116,8 @@ class VoltageProcessor:
                            figuretitle, 
                            xrangestep,
                            save, 
-                           gpath)
+                           gpath,
+                           cleardata)
         
         self.plotObjIndex += 1