dicom 0.5 → 0.6

data/lib/DRead.rb

@@ -11,31 +11,45 @@ module DICOM
   # Class for reading the data from a DICOM file:
   class DRead
 
-    attr_reader :success,:names,:tags,:types,:lengths,:values,:raw,:levels,:explicit,:file_endian,:msg
+    attr_reader :success, :names, :tags, :types, :lengths, :values, :raw, :levels, :explicit, :file_endian, :msg
 
     # Initialize the DRead instance.
-    def initialize(file_name=nil, opts={})
+    def initialize(string=nil, options={})
       # Process option values, setting defaults for the ones that are not specified:
-      @lib =  opts[:lib] || DLibrary.new
-      @sys_endian = opts[:sys_endian] || false
+      @lib =  options[:lib] || DLibrary.new
+      @sys_endian = options[:sys_endian] || false
+      @bin = options[:bin]
+      @transfer_syntax = options[:syntax]
       # Initiate the variables that are used during file reading:
-      init_variables()
+      init_variables
 
-      # Test if file is readable and open it to the @file variable:
-      open_file(file_name)
-
-      # Read the initial header of the file:
-      if @file == nil
-        # File is not readable, so we return:
-        return
+      # Are we going to read from a file, or read from a binary string:
+      if @bin
+        # Read from the provided binary string:
+        @str = string
       else
+        # Read from file:
+        open_file(string)
+        # Read the initial header of the file:
+        if @file == nil
+          # File is not readable, so we return:
+          return
+        else
+          # Extract the content of the file to a binary string:
+          @str = @file.read
+          @file.close
+        end
+      end
+      # Create a Stream instance to handle the decoding of content from this binary string:
+      @stream = Stream.new(@str, @file_endian, @explicit)
+      # Do not check for header information when supplied a (network) binary string:
+      unless @bin
         # Read and verify the DICOM header:
-        header = check_header()
-        # If the file didnt have the expected header, we will attempt to read data elements from the very start of the file:
+        header = check_header
+        # If the file didnt have the expected header, we will attempt to read
+        # data elements from the very start file:
         if header == false
-          @file.close()
-          @file = File.new(file_name, "rb")
-          @header_length = 0
+          @stream.skip(-132)
         elsif header == nil
           # Not a valid DICOM file, return:
           return
@@ -46,12 +60,10 @@ module DICOM
       # (Data element information is stored in arrays by the method process_data_element)
       data_element = true
       while data_element != false do
-        data_element = process_data_element()
+        data_element = process_data_element
       end
 
       # Post processing:
-      # Close the file as we are finished reading it:
-      @file.close()
       # Assume file has been read successfully:
       @success = true
       # Check if the last element was read out correctly (that the length of its data (@raw.last.length)
@@ -59,12 +71,65 @@ module DICOM
       # We only run this test if the last element has a positive expectation value, obviously.
       if @lengths.last.to_i > 0
         if @raw.last.length != @lengths.last
-          @msg += ["Error! The data content read from file does not match the length specified for the tag #{@tags.last}. It seems this is either an invalid or corrupt DICOM file. Returning."]
+          @msg << "Error! The data content read from file does not match the length specified for the tag #{@tags.last}. It seems this is either an invalid or corrupt DICOM file. Returning."
           @success = false
           return
         end
       end
-    end # of method initialize
+    end # of initialize
+
+
+    # Extract an array of binary strings
+    # (this is typically used if one intends to transmit the DICOM file through a network connection)
+    def extract_segments(size)
+      # For this purpose we are not interested to include header or meta information.
+      # We must therefore find the position of the first tag which is not a meta information tag.
+      pos = first_non_meta
+      # Start position:
+      if pos == 0
+        start = 0
+      else
+        # First byte after the integrated length of the previous tag is our start:
+        start = @integrated_lengths[pos-1]
+      end
+      # Iterate through the tags and monitor the integrated_lengths values to determine
+      # when we need to start a new segment.
+      segments = Array.new
+      last_pos = pos
+      @tags.each_index do |i|
+        # Have we passed the size limit?
+        if (@integrated_lengths[i] - start) > size
+          # We either need to stop the current segment at the previous tag, or if
+          # this is a long tag (typically image data), we need to split its data
+          # and put it in several segments.
+          if (@integrated_lengths[i] - @integrated_lengths[i-1]) > size
+            # This element's value needs to be split up into several segments.
+            # How many segments are needed to fit this element?
+            number = ((@integrated_lengths[i] - start).to_f / size.to_f).ceil
+            number.times do
+              # Extract data and add to segments:
+              last_pos = (start+size-1)
+              segments << @stream.string[start..last_pos]
+              # Update start position for next segment:
+              start = last_pos + 1
+            end
+          else
+            # End the current segment at the last data element, then start the new segment with this element.
+            last_pos = @integrated_lengths[i-1]
+            segments << @stream.string[start..last_pos]
+            # Update start position for next segment:
+            start = last_pos + 1
+          end
+        end
+      end
+      # After running the above iteration, it is possible that we have some data elements remaining
+      # at the end of the file who's length are beneath the size limit, and thus has not been put into a segment.
+      if (last_pos + 1) < @stream.string.length
+        # Add the remaining data elements to a segment:
+        segments << @stream.string[start..@stream.string.length]
+      end
+      return segments
+    end
 
 
     # Following methods are private:
@@ -72,40 +137,40 @@ module DICOM
 
 
     # Checks the initial header of the DICOM file.
-    def check_header()
+    def check_header
       # According to the official DICOM standard, a DICOM file shall contain 128
       # consequtive (zero) bytes followed by 4 bytes that spell the string 'DICM'.
       # Apparently, some providers seems to skip this in their DICOM files.
-      bin1 = @file.read(128)
-      @header_length += 128
-      # Next 4 bytes should spell 'DICM':
-      bin2 = @file.read(4)
-      @header_length += 4
-      # Check if this binary was successfully read (if not, this short file is not a valid DICOM file and we will return):
-      if bin2
-        dicm = bin2.unpack('a' * 4).join
-      else
+      # Check that the file is long enough to contain a valid header:
+      if @str.length < 132
+        # This does not seem to be a valid DICOM file and so we return.
         return nil
-      end
-      if dicm != 'DICM' then
-        # Header is not valid (we will still try to read it is a DICOM file though):
-        @msg += ["Warning: The specified file does not contain the official DICOM header. Will try to read the file anyway, as some sources are known to skip this header."]
-        # As the file is not conforming to the DICOM standard, it is possible that it does not contain a
-        # transfer syntax element, and as such, we attempt to choose the most probable encoding values here:
-        @explicit = false
-        return false
       else
-        # Header is valid:
-        return true
+        @stream.skip(128)
+        # Next 4 bytes should spell "DICM":
+        identifier = @stream.decode(4, "STR")
+        @header_length += 132
+        if identifier != "DICM" then
+          # Header is not valid (we will still try to read it is a DICOM file though):
+          @msg << "Warning: The specified file does not contain the official DICOM header. Will try to read the file anyway, as some sources are known to skip this header."
+          # As the file is not conforming to the DICOM standard, it is possible that it does not contain a
+          # transfer syntax element, and as such, we attempt to choose the most probable encoding values here:
+          @explicit = false
+          @stream.explicit = false
+          return false
+        else
+          # Header is valid:
+          return true
+        end
       end
-    end # of method check_header
+    end
 
 
     # Governs the process of reading data elements from the DICOM file.
-    def process_data_element()
+    def process_data_element
       #STEP 1: ------------------------------------------------------
       # Attempt to read data element tag, but abort if we have reached end of file:
-      tag = read_tag()
+      tag = read_tag
       if tag == false
         # End of file, no more elements.
         return false
@@ -155,102 +220,83 @@ module DICOM
       # Set the hiearchy level of this data element:
       set_level(level_type, length, tag, name)
       # Transfer the gathered data to arrays and return true:
-      @names += [name]
-      @tags += [tag]
-      @types += [type]
-      @lengths += [length]
-      @values += [value]
-      @raw += [raw]
+      @names << name
+      @tags << tag
+      @types << type
+      @lengths << length
+      @values << value
+      @raw << raw
       return true
-    end # of method process_data_element
+    end # of process_data_element
 
 
     # Reads and returns the data element's TAG (4 first bytes of element).
-    def read_tag()
-      bin1 = @file.read(2)
-      bin2 = @file.read(2)
-      # Do not proceed if we have reached end of file:
-      if bin2 == nil
-        return false
-      end
-      # Add the length of the data element tag. If this was the first element read from file, we need to add the header length too:
+    def read_tag
+      tag = @stream.decode_tag
+      # Do not proceed if we have reached end of file (tag is nil):
+      return false unless tag
+      # Tag was valid, so we add the length of the data element tag.
+      # If this was the first element read from file, we need to add the header length too:
       if @integrated_lengths.length == 0
         # Increase the array with the length of the header + the 4 bytes:
-        @integrated_lengths += [@header_length + 4]
+        @integrated_lengths << (@header_length + 4)
       else
         # For the remaining elements, increase the array with the integrated length of the previous elements + the 4 bytes:
-        @integrated_lengths += [@integrated_lengths[@integrated_lengths.length-1] + 4]
-      end
-      # Unpack the blobs:
-      tag1 = bin1.unpack('h*')[0].reverse.upcase
-      tag2 = bin2.unpack('h*')[0].reverse.upcase
-      # Whether DICOM file is big or little endian, the first 0002 group is always little endian encoded.
-      # In case of big endian system:
-      if @sys_endian
-        # Rearrange the numbers (# This has never been tested btw.):
-        tag1 = tag1[2..3]+tag1[0..1]
-        tag2 = tag2[2..3]+tag2[0..1]
+        @integrated_lengths << (@integrated_lengths[@integrated_lengths.length-1] + 4)
       end
       # When we shift from group 0002 to another group we need to update our endian/explicitness variables:
-      if tag1 != "0002" and @switched == false
-        switch_syntax()
-      end
-      # Perhaps we need to rearrange the tag strings?
-      if not @endian
-        # Need to rearrange the first and second part of each string:
-        tag1 = tag1[2..3]+tag1[0..1]
-        tag2 = tag2[2..3]+tag2[0..1]
+      if tag[0..3] != "0002" and @switched == false
+        switch_syntax
       end
-      # Join the tag group & element part together to form the final, complete string:
-      return tag1+","+tag2
-    end # of method read_tag
+      return tag
+    end
 
 
-    # Reads and returns data element TYPE (VR) (2 bytes) and data element LENGTH (Varying length).
+    # Reads and returns data element TYPE (VR) (2 bytes) and data element LENGTH (Varying length; 2-6 bytes).
     def read_type_length(type,tag)
       # Structure will differ, dependent on whether we have explicit or implicit encoding:
+      pre_skip = 0
+      bytes = 0
       # *****EXPLICIT*****:
       if @explicit == true
         # Step 1: Read VR (if it exists)
         unless tag == "FFFE,E000" or tag == "FFFE,E00D" or tag == "FFFE,E0DD"
           # Read the element's type (2 bytes - since we are not dealing with an item related element):
-          bin = @file.read(2)
+          type = @stream.decode(2, "STR")
           @integrated_lengths[@integrated_lengths.length-1] += 2
-          type = bin.unpack('a*').join
         end
         # Step 2: Read length
         # Three possible structures for value length here, dependent on element type:
         case type
           when "OB","OW","SQ","UN"
             # 6 bytes total:
-            # Two empty first:
-            bin = @file.read(2)
-            @integrated_lengths[@integrated_lengths.length-1] += 2
+            # Two empty bytes first:
+            pre_skip = 2
             # Value length (4 bytes):
-            bin = @file.read(4)
-            @integrated_lengths[@integrated_lengths.length-1] += 4
-            length = bin.unpack(@ul)[0]
+            bytes = 4
           when "()"
             # 4 bytes:
             # For elements "FFFE,E000", "FFFE,E00D" and "FFFE,E0DD"
-            bin = @file.read(4)
-            @integrated_lengths[@integrated_lengths.length-1] += 4
-            length = bin.unpack(@ul)[0]
+            bytes = 4
           else
             # 2 bytes:
             # For all the other element types, value length is 2 bytes:
-            bin = @file.read(2)
-            @integrated_lengths[@integrated_lengths.length-1] += 2
-            length = bin.unpack(@us)[0]
+            bytes = 2
         end
       else
         # *****IMPLICIT*****:
-        # No VR (retrieved from library based on the data element's tag)
-        # Reading value length (4 bytes):
-        bin = @file.read(4)
-        @integrated_lengths[@integrated_lengths.length-1] += 4
-        length = bin.unpack(@ul)[0]
+        # Value length (4 bytes):
+        bytes = 4
+      end
+      # Handle skips and read out length value:
+      @stream.skip(pre_skip)
+      if bytes == 2
+        length = @stream.decode(bytes, "US") # (2)
+      else
+        length = @stream.decode(bytes, "UL") # (4)
       end
+      # Update integrated lengths array:
+      @integrated_lengths[@integrated_lengths.length-1] += (pre_skip + bytes)
       # For encapsulated data, the element length will not be defined. To convey this,
       # the hex sequence 'ff ff ff ff' is used (-1 converted to signed long, 4294967295 converted to unsigned long).
       if length == 4294967295
@@ -261,110 +307,36 @@ module DICOM
         @msg += ["Warning: Odd number of bytes in data element's length occured. This is a violation of the DICOM standard, but program will attempt to read the rest of the file anyway."]
       end
       return [type, length]
-    end # of method read_type_length
+    end # of read_type_length
 
 
     # Reads and returns data element VALUE (Of varying length - which is determined at an earlier stage).
     def read_value(type, length)
-      # Read the data:
-      bin = @file.read(length)
+      # Extract the binary data:
+      bin = @stream.extract(length)
       @integrated_lengths[@integrated_lengths.size-1] += length
-      # Decoding of content will naturally depend on what kind of content (VR) we have.
-      case type
-
-        # Normally the "number elements" will contain just one number, but in some cases, they contain
-        # multiple numbers. In these cases we will read each number and store them all in a string separated by "/".
-        # Unsigned long: (4 bytes)
-        when "UL"
-          if length <= 4
-            data = bin.unpack(@ul)[0]
-          else
-            data = bin.unpack(@ul).join("/")
-          end
-
-        # Signed long: (4 bytes)
-        when "SL"
-          if length <= 4
-            data = bin.unpack(@sl)[0]
-          else
-            data = bin.unpack(@sl).join("/")
-          end
-
-        # Unsigned short: (2 bytes)
-        when "US"
-          if length <= 2
-            data = bin.unpack(@us)[0]
-          else
-            data = bin.unpack(@us).join("/")
-          end
-
-        # Signed short: (2 bytes)
-        when "SS"
-          if length <= 2
-            data = bin.unpack(@ss)[0]
-          else
-            data = bin.unpack(@ss).join("/")
-          end
-
-        # Floating point single: (4 bytes)
-        when "FL"
-          if length <= 4
-            data = bin.unpack(@fs)[0]
-          else
-            data = bin.unpack(@fs).join("/")
-          end
-
-        # Floating point double: (8 bytes)
-        when "FD"
-          if length <= 8
-            data = bin.unpack(@fd)[0]
-          else
-            data = bin.unpack(@fd).join("/")
-          end
-
-        # The data element contains a tag as its value (4 bytes):
-        when "AT"
-          # Bytes read in following order: 1 0 , 3 2 (And Hex nibbles read in this order: Hh)
-          # NB! This probably needs to be modified when dealing with something other than little endian.
-          # Value is unpacked to a string in the format GGGGEEEE.
-          data = (bin.unpack("xHXhX2HXh").join + bin.unpack("x3HXhX2HXh").join).upcase
-          #data = (bin.unpack("xHXhX2HXh").join + "," + bin.unpack("x3HXhX2HXh").join).upcase
-
-        # We have a number of VRs that are decoded as string:
-        when 'AE','AS','CS','DA','DS','DT','IS','LO','LT','PN','SH','ST','TM','UI','UT' #,'VR'
-          data = bin.unpack('a*').join
-
-        # NB!
-        # FOLLOWING ELEMENT TYPES WILL NOT BE DECODED.
-        # DECODING OF PIXEL DATA IS MOVED TO DOBJECT FOR PERFORMANCE REASONS.
-
-        # Unknown information, header element is not recognized from local database:
-        when "UN"
-          #data=bin.unpack('H*')[0]
-
-        # Other byte string, 1-byte integers
-        when "OB"
-          #data = bin.unpack('H*')[0]
-
-        # Other float string, 4-byte floating point numbers
-        when "OF"
-          # NB! This element type has not been tested yet with an actual DICOM file.
-          #data = bin.unpack(@fs)
-
-        # Image data:
-        # Other word string, 2-byte integers
-        when "OW"
-          # empty
-
-        # Unknown VR:
+      # Decode data?
+      # Some data elements (like those containing image data, compressed data or unknown data),
+      # will not be decoded here.
+      unless type == "OW" or type == "OB" or type == "OF" or type == "UN"
+        # "Rewind" and extract the value from this binary data:
+        @stream.skip(-length)
+        # Decode data:
+        value = @stream.decode(length, type)
+        if not value.is_a?(Array)
+          data = value
         else
-          @msg += ["Warning: Element type #{type} does not have a reading method assigned to it. Please check the validity of the DICOM file."]
-          #data = bin.unpack('H*')[0]
-      end # of case type
-
+          # If the returned value is not a string, it is an array of multiple elements,
+          # which need to be joined to a string with the separator "\":
+          data = value.join("\\")
+        end
+      else
+        # No decoded data:
+        data = nil
+      end
       # Return the data:
       return [data, bin]
-    end # of method read_value
+    end # of read_value
 
 
     # Sets the level of the current element in the hiearchy.
@@ -389,9 +361,9 @@ module DICOM
         @current_level = @current_level + 1
         # If length of sequence/item is specified, we must note this length + the current element position in the arrays:
         if length.to_i != 0
-          @hierarchy += [[length,@integrated_lengths.last]]
+          @hierarchy << [length, @integrated_lengths.last]
         else
-          @hierarchy += [type]
+          @hierarchy << type
         end
       end
       # Need to check whether a previous sequence or item has ended, if so the level must be decreased by one:
@@ -406,14 +378,14 @@ module DICOM
       if @hierarchy.size > 0
         # Do not perform this check for Pixel Data Items or Sequence Delimitation Items:
         # (If performed, it will give false errors for the case when we have Encapsulated Pixel Data)
-        check_level_end() unless name == "Pixel Data Item" or tag == "FFFE,E0DD"
+        check_level_end unless name == "Pixel Data Item" or tag == "FFFE,E0DD"
       end
-    end # of method set_level
+    end # of set_level
 
 
     # Checks how far we've read in the DICOM file to determine if we have reached a point
     # where sub-levels are ending. This method is recursive, as multiple sequences/items might end at the same point.
-    def check_level_end()
+    def check_level_end
       # The test is only meaningful to perform if we are not expecting an 'end of sequence/item' element to signal the level-change.
       if (@hierarchy.last).is_a?(Array)
         described_length = (@hierarchy.last)[0]
@@ -427,7 +399,7 @@ module DICOM
           if (@hierarchy.size > 1)
             @hierarchy = @hierarchy[0..(@hierarchy.size-2)]
             # There might be numerous levels that ends at this particular point, so we need to do a recursive repeat to check.
-            check_level_end()
+            check_level_end
           else
             @hierarchy = Array.new()
           end
@@ -439,7 +411,7 @@ module DICOM
           end
         end
       end
-    end # of method check_level_end
+    end
 
 
     # Tests if the file is readable and opens it.
@@ -450,115 +422,78 @@ module DICOM
             if File.size(file) > 8
               @file = File.new(file, "rb")
             else
-              @msg += ["Error! File is too small to contain DICOM information. Returning. (#{file})"]
+              @msg << "Error! File is too small to contain DICOM information. Returning. (#{file})"
             end
           else
-            @msg += ["Error! File is a directory. Returning. (#{file})"]
+            @msg << "Error! File is a directory. Returning. (#{file})"
           end
         else
-          @msg += ["Error! File exists but I don't have permission to read it. Returning. (#{file})"]
+          @msg << "Error! File exists but I don't have permission to read it. Returning. (#{file})"
         end
       else
-        @msg += ["Error! The file you have supplied does not exist. Returning. (#{file})"]
+        @msg << "Error! The file you have supplied does not exist. Returning. (#{file})"
       end
-    end # of method open_file
+    end
 
 
     # Changes encoding variables as the file reading proceeds past the initial 0002 group of the DICOM file.
-    def switch_syntax()
-      # The information read from the Transfer syntax element (if present), needs to be processed:
-      process_transfer_syntax()
+    def switch_syntax
+      # Get the transfer syntax string, unless it has already been provided by keyword:
+      unless @transfer_syntax
+        ts_pos = @tags.index("0002,0010")
+        if ts_pos
+          @transfer_syntax = @values[ts_pos].rstrip
+        else
+          @transfer_syntax = "1.2.840.10008.1.2" # Default is implicit, little endian
+        end
+      end
+      # Query the library with our particular transfer syntax string:
+      result = @lib.process_transfer_syntax(@transfer_syntax)
+      # Result is a 3-element array: [Validity of ts, explicitness, endianness]
+      unless result[0]
+        @msg+=["Warning: Invalid/unknown transfer syntax! Will try reading the file, but errors may occur."]
+      end
+      @rest_explicit = result[1]
+      @rest_endian = result[2]
       # We only plan to run this method once:
       @switched = true
       # Update endian, explicitness and unpack variables:
       @file_endian = @rest_endian
+      @stream.set_endian(@rest_endian)
       @explicit = @rest_explicit
-      if @sys_endian == @file_endian
-        @endian = true
-      else
-        @endian = false
-      end
-      set_unpack_strings()
+      @stream.explicit = @rest_explicit
     end
 
 
-    # Checks the Transfer Syntax UID element and updates class variables to prepare for correct reading of DICOM file.
-    # A lot of code here is duplicated in DWrite class. Should move as much of this code as possible to DLibrary I think.
-    def process_transfer_syntax()
-      ts_pos = @tags.index("0002,0010")
-      if ts_pos != nil
-        ts_value = @raw[ts_pos].unpack('a*').join.rstrip
-        valid = @lib.check_ts_validity(ts_value)
-        if not valid
-          @msg+=["Warning: Invalid/unknown transfer syntax! Will try reading the file, but errors may occur."]
+    # Find the position of the first tag which is not a group "0002" tag:
+    def first_non_meta
+      i = 0
+      go = true
+      while go == true and i < @tags.length do
+        tag = @tags[i]
+        if tag[0..3] == "0002"
+          i += 1
+        else
+          go = false
         end
-        case ts_value
-          # Some variations with uncompressed pixel data:
-          when "1.2.840.10008.1.2"
-            # Implicit VR, Little Endian
-            @rest_explicit = false
-            @rest_endian = false
-          when "1.2.840.10008.1.2.1"
-            # Explicit VR, Little Endian
-            @rest_explicit = true
-            @rest_endian = false
-          when "1.2.840.10008.1.2.1.99"
-            # Deflated Explicit VR, Little Endian
-            @msg += ["Warning: Transfer syntax 'Deflated Explicit VR, Little Endian' is untested. Unknown if this is handled correctly!"]
-            @rest_explicit = true
-            @rest_endian = false
-          when "1.2.840.10008.1.2.2"
-            # Explicit VR, Big Endian
-            @rest_explicit = true
-            @rest_endian = true
-          else
-            # For everything else, assume compressed pixel data, with Explicit VR, Little Endian:
-            @rest_explicit = true
-            @rest_endian = false
-        end # of case ts_value
-      end # of if ts_pos != nil
-    end # of method process_syntax
-
-
-    # Sets the unpack format strings that will be used for numbers depending on endianness of file/system.
-    def set_unpack_strings
-      if @endian
-        # System endian equals file endian:
-        # Native byte order.
-        @by = "C*" # Byte (1 byte)
-        @us = "S*" # Unsigned short (2 bytes)
-        @ss = "s*" # Signed short (2 bytes)
-        @ul = "I*" # Unsigned long (4 bytes)
-        @sl = "l*" # Signed long (4 bytes)
-        @fs = "e*" # Floating point single (4 bytes)
-        @fd = "E*" # Floating point double ( 8 bytes)
-      else
-        # System endian not equal to file endian:
-        # Network byte order.
-        @by = "C*"
-        @us = "n*"
-        @ss = "n*" # Not correct (gives US)
-        @ul = "N*"
-        @sl = "N*" # Not correct (gives UL)
-        @fs = "g*"
-        @fd = "G*"
       end
+      return i
     end
 
 
     # Initiates the variables that are used during file reading.
-    def init_variables()
+    def init_variables
       # Variables that hold data that will be available to the DObject class.
       # Arrays that will hold information from the elements of the DICOM file:
-      @names = Array.new()
-      @tags = Array.new()
-      @types = Array.new()
-      @lengths = Array.new()
-      @values = Array.new()
-      @raw = Array.new()
-      @levels = Array.new()
+      @names = Array.new
+      @tags = Array.new
+      @types = Array.new
+      @lengths = Array.new
+      @values = Array.new
+      @raw = Array.new
+      @levels = Array.new
       # Array that will holde any messages generated while reading the DICOM file:
-      @msg = Array.new()
+      @msg = Array.new
       # Variables that contain properties of the DICOM file:
       # Variable to keep track of whether the image pixel data in this file are compressed or not, and if it exists at all:
       # Default explicitness of start of DICOM file::
@@ -571,10 +506,10 @@ module DICOM
       # Variables used internally when reading through the DICOM file:
       # Array for keeping track of how many bytes have been read from the file up to and including each data element:
       # (This is necessary for tracking the hiearchy in some DICOM files)
-      @integrated_lengths = Array.new()
+      @integrated_lengths = Array.new
       @header_length = 0
       # Array to keep track of the hierarchy of elements (this will be used to determine when a sequence or item is finished):
-      @hierarchy = Array.new()
+      @hierarchy = Array.new
       @hierarchy_error = false
       # Explicitness of the remaining groups after the initial 0002 group:
       @rest_explicit = false
@@ -582,14 +517,6 @@ module DICOM
       @rest_endian = false
       # When the file switch from group 0002 to a later group we will update encoding values, and this switch will keep track of that:
       @switched = false
-      # Use a "relationship endian" variable to guide reading of file:
-      if @sys_endian == @file_endian
-        @endian = true
-      else
-        @endian = false
-      end
-      # Set which format strings to use when unpacking numbers:
-      set_unpack_strings
       # A length variable will be used at the end to check whether the last element was read correctly, or whether the file endend unexpectedly:
       @data_length = 0
       # Keeping track of the data element's level while reading through the file:
@@ -598,7 +525,9 @@ module DICOM
       @undef = "UNDEFINED"
       # Items contained under the pixel data element may contain data directly, so we need a variable to keep track of this:
       @enc_image = false
+      # Assume header size is zero bytes until otherwise is determined:
+      @header_length = 0
     end
 
-  end # End of class
-end # End of module
+  end # of class
+end # of module