Source Code for Module SDS

  1  '''
 
  2  Created on 12/10/2010
 
  3  
 
  4  @author: Luis
 
  5  ''' 
  6  from Utils import utils 
  7  import struct 
  8  
 
  9 -class SDS(): 
 10      '''
 
 11      This class is in charge of SDS extraction from a linear buffer.
 
 12      SDS objects are returned as a Python table (list of rows) of n dimensions.
 
 13      ''' 
 14  
 
 15 -    def __init__(self,): 
 16          '''
 
 17          Constructor        
 
 18          ''' 
 19          self.schema="{http://schemas.hdfgroup.org/hdf4/h4}" #Etree uses full schema name spaces 
 20          #self.linear_buffer=buffer 
 
 21          self.tools=utils() 
 22          self.SDS_array=[] #This array will store our final array 
 23          self.loopsc=[] 
 24  
 
 25  
 
 26  
 
 27  
 
 28 -    def Extract(self,node,linear_buffer): 
 29          '''
 
 30          Dump a single SDS object into a Python table, the method returns the object as a n dimensional Table.
 
 31          The parameter 'node' has to be an ElemenTree node of an "SDS" XML tag. 
 
 32          This tag contains the necessary meta data to extract and reconstruct the SDS object.
 
 33  
 
 34          ''' 
 35          self.SDS_array=[] 
 36  
 
 37          
 
 38          bufferData=linear_buffer.getvalue() 
 39          
 
 40          SDS_dimension_sizes = node.find(self.schema + "dataDimensionSizes").text.split(" ") 
 41          try: 
 42              SDS_allocatedDimensionSizes=node.find(self.schema + "allocatedDimensionSizes").text.split(" ") 
 43          except: 
 44              SDS_allocatedDimensionSizes=None 
 45          
 
 46          SDS_datum=node.find(self.schema + "datum") 
 47          offset_increase=0 
 48  
 
 49  
 
 50          if self.tools.getXMLattribute(SDS_datum,"dataType"): 
 51              mapped_type=SDS_datum.attrib["dataType"] 
 52          else: 
 53              print "This SDS has no data type" 
 54              return None 
 55          
 
 56          if self.tools.getXMLattribute(SDS_datum,"byteOrder"): 
 57              byte_order=SDS_datum.attrib["byteOrder"] 
 58          else: 
 59              byte_order="littleEndian" 
 60          
 
 61          #returns the unpack representation of this data type
 
 62          py_format,data_offset,py_endianness=self.tools.getPythonFormat(mapped_type,byte_order) 
 63          
 
 64          try: 
 65              SDS_fastestVaryingDimensionIndex=int(node.find(self.schema + "arrayData").attrib["fastestVaryingDimensionIndex"]) 
 66          except: 
 67              SDS_fastestVaryingDimensionIndex=0 
 68          
 
 69          DimensionOffsets=[] 
 70          
 
 71          if SDS_allocatedDimensionSizes==None: 
 72              for dimension in  range(len(SDS_dimension_sizes)): 
 73                  DimensionOffsets.append(int(SDS_dimension_sizes[dimension])) 
 74          else: 
 75              for dimension in  range(len(SDS_allocatedDimensionSizes)): 
 76                  DimensionOffsets.append(int(SDS_dimension_sizes[dimension]))             
 77          
 
 78          dim_attrib=node.findall(self.schema + "dimensionRef") 
 79          for dim in range(len(SDS_dimension_sizes)): 
 80              self.SDS_array.append(["Dim " + str(dim) + " " + dim_attrib[dim].attrib["name"],"Size: "+ str(SDS_dimension_sizes[dim]),"Type: "+ mapped_type]) 
 81              
 
 82              
 
 83          
 
 84          if SDS_fastestVaryingDimensionIndex==0:             
 85              offset_increase=DimensionOffsets[0] 
 86              column_offset=0 
 87              loops=1 
 88              for dim in DimensionOffsets[1:]: 
 89                  loops*=dim 
 90              data_offset=offset_increase*data_offset          
 91              for dim in range(loops): 
 92                  self.SDS_array.append(struct.unpack_from(py_endianness+str(offset_increase)+py_format,bufferData,column_offset)) 
 93                  column_offset+=(data_offset) 
 94          else: 
 95              
 
 96              offset_increase=DimensionOffsets[len(DimensionOffsets)-1] 
 97              column_offset=0 
 98              loops=1 
 99              for dim in DimensionOffsets[:-1]: 
100                  loops*=dim 
101              self.loopsc.append([loops,py_format]) 
102              data_offset=offset_increase*data_offset  
103              for dim in range(loops): 
104                  self.SDS_array.append(struct.unpack_from(py_endianness+str(offset_increase)+py_format,bufferData,column_offset)) 
105                  column_offset+=(data_offset) 
106  
 
107              
 
108          return self.SDS_array #This is a Table 
109