From cd80c0608691b6d3c21b1b739654494ba5db446f 2012-02-07 19:20:16
From: Daniel Valdez <daniel.suarez@jro.igp.gob.pe>
Date: 2012-02-07 19:20:16
Subject: [PATCH] En esta version se corrigieron los bugs de lectura, la lectura se ha implementado para modo offline, el script TestReader.py es un ejemplo que muestra como debe hacerse la lectura de rawdata usando estas librerias.

---

diff --git a/schainpy/IO/Header.py b/schainpy/IO/Header.py
index e3de902..0b3009a 100644
--- a/schainpy/IO/Header.py
+++ b/schainpy/IO/Header.py
@@ -1,3 +1,5 @@
+import numpy
+
 class PROCFLAG:    
     COHERENT_INTEGRATION = numpy.uint32(0x00000001)
     DECODE_DATA = numpy.uint32(0x00000002) 
diff --git a/schainpy/IO/Voltage.py b/schainpy/IO/Voltage.py
index c6bfa0e..4faf9df 100644
--- a/schainpy/IO/Voltage.py
+++ b/schainpy/IO/Voltage.py
@@ -16,8 +16,6 @@ from Data import DataReader
 from Data import DataWriter
 
 class VoltageReader(DataReader):
-    # Este flag indica que la data leida no es continua
-    __jumpDataFlag = False
     
     __idFile = 0
     
@@ -39,7 +37,7 @@ class VoltageReader(DataReader):
     
     __maxTimeStep = 5 
     
-    __flagResetProcessing = 0
+    flagResetProcessing = 0
     
     __flagIsNewFile = 0
     
@@ -55,18 +53,18 @@ class VoltageReader(DataReader):
     
     basicHeaderSize = 24
     
-    objBasicHeader = BasicHeader()
+    basicHeaderObj = BasicHeader()
     
-    objSystemHeader = SystemHeader()
+    systemHeaderObj = SystemHeader()
     
-    objRadarControllerHeader = RadarControllerHeader()
+    radarControllerHeaderObj = RadarControllerHeader()
     
-    objProcessingHeader = ProcessingHeader()
+    processingHeaderObj = ProcessingHeader()
     
     __buffer = 0
     
     __buffer_id = 9999
-    m_Voltage= Voltage()
+    #m_Voltage= Voltage()
 
                     
     def __init__(self):
@@ -76,19 +74,19 @@ class VoltageReader(DataReader):
         if fp == None:
             fp = self.__fp
             
-        self.objSystemHeader.read(fp)
+        self.systemHeaderObj.read(fp)
     
     def __rdRadarControllerHeader(self,fp=None):
         if fp == None:
             fp = self.__fp
             
-        self.objRadarControllerHeader.read(fp)
+        self.radarControllerHeaderObj.read(fp)
         
     def __rdProcessingHeader(self,fp=None):
         if fp == None:
             fp = self.__fp
             
-        self.objProcessingHeader.read(fp)
+        self.processingHeaderObj.read(fp)
         
     def __searchFiles(self,path, startDateTime, endDateTime, set=None, expLabel = "", ext = "*.r"):
         
@@ -168,14 +166,14 @@ class VoltageReader(DataReader):
         if endUTSeconds==None:
             endUTSeconds = self.endUTCSeconds
             
-        objBasicHeader = BasicHeader()
+        basicHeaderObj = BasicHeader()
         
-        if not(objBasicHeader.read(fp)):
+        if not(basicHeaderObj.read(fp)):
             return 0
         
         fp.close()
         
-        if not ((startUTSeconds <= objBasicHeader.utc) and (endUTSeconds >= objBasicHeader.utc)):
+        if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds >= basicHeaderObj.utc)):
             return 0
         
         return 1
@@ -185,7 +183,7 @@ class VoltageReader(DataReader):
         if fp == None:
             fp = self.__fp
             
-        self.objBasicHeader.read(fp)
+        self.basicHeaderObj.read(fp)
     
     def __readFirstHeader(self):
         
@@ -193,9 +191,9 @@ class VoltageReader(DataReader):
         self.__rdSystemHeader()
         self.__rdRadarControllerHeader()
         self.__rdProcessingHeader()
-        self.firstHeaderSize = self.objBasicHeader.size
+        self.firstHeaderSize = self.basicHeaderObj.size
         
-        data_type=int(numpy.log2((self.objProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
+        data_type=int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
         if data_type == 0:
             tmp=numpy.dtype([('real','<i1'),('imag','<i1')])
         elif data_type == 1:
@@ -212,9 +210,8 @@ class VoltageReader(DataReader):
             print 'no define data type'
             tmp = 0
         
-        self.__flagIsNewFile = 0
         self.__dataType = tmp
-        self.__sizeOfFileByHeader = self.objProcessingHeader.dataBlocksPerFile * self.objProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.objProcessingHeader.dataBlocksPerFile - 1)        
+        self.__sizeOfFileByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)        
 
     def __setNextFileOnline(self):
         return 0
@@ -235,7 +232,7 @@ class VoltageReader(DataReader):
             fp = open(filename,'rb')
             
             currentSize = fileSize - fp.tell()
-            neededSize = self.objProcessingHeader.blockSize + self.firstHeaderSize
+            neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize
             
             if (currentSize < neededSize):
                 continue
@@ -261,20 +258,27 @@ class VoltageReader(DataReader):
     
     def __setNewBlock(self):
         
+        if self.__flagIsNewFile:
+            return 1
+        
         currentSize = self.fileSize - self.__fp.tell()
-        neededSize = self.objProcessingHeader.blockSize + self.basicHeaderSize
+        neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
         
         # Bloque Completo
         if (currentSize >= neededSize):
             self.__readBasicHeader()
             return 1
         
-        self.__setNextFile()
+        if not(self.__setNextFile()):
+            return 0
+        
         self.__readFirstHeader()
         
-        deltaTime = self.objBasicHeader.utc - self.__lastUTTime # check this
+        deltaTime = self.basicHeaderObj.utc - self.__lastUTTime # check this
+        
+        self.flagResetProcessing = 0
         if deltaTime > self.__maxTimeStep:
-            self.__flagResetProcessing = 1
+            self.flagResetProcessing = 1
             
         return 1
     
@@ -285,11 +289,13 @@ class VoltageReader(DataReader):
         seteado a 0
         """
         
-        pts2read = self.objProcessingHeader.profilesPerBlock*self.objProcessingHeader.numHeights*self.objSystemHeader.numChannels
+        pts2read = self.processingHeaderObj.profilesPerBlock*self.processingHeaderObj.numHeights*self.systemHeaderObj.numChannels
         
         data = numpy.fromfile(self.__fp,self.__dataType,pts2read)
         
-        data = data.reshape((self.objProcessingHeader.profilesPerBlock, self.objProcessingHeader.numHeights, self.objSystemHeader.numChannels))
+        data = data.reshape((self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.numHeights, self.systemHeaderObj.numChannels))
+        
+        self.__flagIsNewFile = 0
         
         self.__buffer = data
         
@@ -297,14 +303,17 @@ class VoltageReader(DataReader):
         
     def readNextBlock(self):
 
-        self.__setNewBlock()
+        if not(self.__setNewBlock()):
+            return 0
              
         self.__readBlock()
         
-        self.__lastUTTime = self.objBasicHeader.utc
+        self.__lastUTTime = self.basicHeaderObj.utc
+        
+        return 1
  
     def __hasNotDataInBuffer(self):
-        if self.__buffer_id >= self.objProcessingHeader.profilesPerBlock:
+        if self.__buffer_id >= self.processingHeaderObj.profilesPerBlock:
             return 1
         
         return 0
@@ -315,6 +324,7 @@ class VoltageReader(DataReader):
         lectura es necesario hacer una nueva lectura de los bloques de datos
         "__readBlock"
         """
+        self.flagResetProcessing = 0
         
         if self.__hasNotDataInBuffer():            
             self.readNextBlock() 
@@ -324,11 +334,11 @@ class VoltageReader(DataReader):
             return None
         
         data = self.__buffer[self.__buffer_id,:,:]
-        
+        #time = timeblock + n*ipp
         #print self.__buffer_id
         
         self.__buffer_id += 1
-            
+        
         #call setData - to Data Object
     
         return data