dicom 0.3 → 0.4

data/lib/DRead.rb

@@ -1,197 +1,100 @@
+#    Copyright 2008-2009 Christoffer Lerv�g
+
+# Some notes about this DICOM file reading class:
+# In addition to reading files that are compliant to DICOM 3 Part 10,
+# the philosophy of this library is to have maximum compatibility,
+# and thus it will read most 'DICOM' files that deviate from the standard.
+# While reading files, this class will also analyse the hierarchy of elements
+# for those DICOM files that feature sequences and items, enabling the user
+# to take advantage of this information for advanced querying of the 
+# DICOM object afterwards.
+
 module DICOM
   # Class for reading the data from a DICOM file:
   class DRead
 
-    attr_reader :success
+    attr_reader :success,:names,:labels,:types,:lengths,:values,:raw,:levels,:explicit,:file_endian,:msg
 
     # Initialize the DRead instance.
-    def initialize(file_name=nil, lib=nil)
-      @a=0
-      @b=0
-      # Variables that hold data that will be returned to the person/procedure using this class:
-      # Arrays that will hold information from the DICOM file:
-      @names = Array.new()
-      @labels = Array.new()
-      @types = Array.new()
-      @lengths = Array.new()
-      @values = Array.new()
-      @raw = Array.new()
-      @levels = Array.new()
-      # Keeping track of how many bytes have been read from the file up to and including each tag:
-      # This is necessary for tracking the hiearchy in some DICOM files.
-      @integrated_lengths = Array.new()
-      @header_length = 0
-      # Keep track of the hierarchy of tags (this will be used to determine when a sequence or item is finished):
-      @hierarchy = Array.new()
-      @hierarchy_error = false
-      # Array that will holde any messages generated while reading the DICOM file:
-      @msg = Array.new()
-      # Explicitness (explicit (true) by default):
-      @explicit = true
-      # Explicitness of the remaining groups after the first group:
-      @rest_explicit = true
-      # Variable to keep track of whether the current sequence being read have length specified or not:
-      @sq_length = false
-      # Variable to keep track of whether the image pixel data in this file are compressed or not, and if it exists at all:
-      @compression = false
-      # Pixel data is color or greyscale?
-      @color = false
-      # Default endianness of start of DICOM files is little endian:
-      @file_endian=false
+    def initialize(file_name=nil, opts={})
+      # Process option values, setting defaults for the ones that are not specified:
+      @lib =  opts[:lib] || DLibrary.new
+      @sys_endian = opts[:sys_endian] || false
       
-      # Variables used internally when reading the dicom file:
-      # If tag does not exist in the library it is unknown:
-      @unknown = false
-      # Check endianness of the system (false if little endian):
-      @sys_endian=check_sys_endian()
-      # Endianness of the remaining groups after the first group:
-      @rest_endian=false
-      # Use a "relationship endian" variable to guide reading of file (true if they are equal):
-      if @sys_endian == @file_endian
-        @endian = true
-      else
-        @endian = false
-      end
-      # A length variable will be used at the end to check whether the last tag was read correctly, or whether the file endend unexpectedly:
-      @data_length = 0
-      # Variable used to tell whether file was read succesfully or not:
-      @success = false
-      # Keeping track of the tag level while reading through the file:
-      @current_level = 0
-
-      # Open file for binary reading:
-      begin
-        @file = File.new(file_name, "rb")
-      rescue
-        @msg += ["Error! Could not open file: "+ file_name + " Returning."]
-        return
-      end
-
-      # Load the library class (DICOM dictionary):
-      if lib != nil
-        # Library already specified by user:
-        @lib = lib
-      else
-        @lib = DLibrary.new()
-      end
+      # Initiate the variables that are used during file reading:
+      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:
-      header=check_header()
-      if header == false
-        @file.close()
-        @file = File.new(file_name, "rb")
-        @header_length = 0
-      elsif header == nil
-        # Reading the file did not succeed, and we need to abort.
-        @msg += ["Error! Could not read: "+ file_name + " It might be a directory. Returning."]
+      if @file == nil
+        # File is not readable, so we return:
         return
+      else
+        # Read and verify the DICOM header:
+        header = check_header()
+        # If there was no header, we will attempt to read tags from the very start of the file:
+        if header == false
+          @file.close()
+          @file = File.new(file_name, "rb")
+          @header_length = 0
+        end
       end
-
-      # Initiate the process to read tags:
+      
+      # Run a loop to read the tags:
+      # (Tag information is stored in arrays by the method process_tag)
       tag = true
-      temp_check=true
-      while tag != false and temp_check== true do
-        tag=process_tag()
-        # Store the tag information in arrays:
-        if tag != false
-          @names+=[tag[0]]
-          @labels+=[tag[1]]
-          @types+=[tag[2]]
-          @lengths+=[tag[3]]
-          @values+=[tag[4]]
-          @raw+=[tag[5]]
-        end
+      while tag != false do
+        tag = process_tag()
       end
-      @success = true
-      # Check the status of the pixel data:
-      check_pixel_status()
-      # Index of last element in tag arrays:
-      @lastIndex=@names.length-1
+      
+      # Post processing:
       # Close the file as we are finished reading it:
       @file.close()
-      # Check if the last tag was read out correctly (that the length of its data corresponds to that expected by the length specified in the DICOM file):
-      if @data_length != @lengths[@lastIndex]
-        @msg += ["Error! The data content read from file does not match the length specified for the tag "+ @labels[@lastIndex] + ". It seems this is not a valid DICOM file. Returning."]
-        @success = false
-        return
+      # Assume file has been read successfully:
+      @success = true
+      # Check if the last tag was read out correctly (that the length of its data (@raw.last.length)
+      # corresponds to that expected by the length specified in the DICOM file (@lengths.last)).
+      # We only run this test if the last tag 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 #{@labels.last}. It seems this is either an invalid or corrupt DICOM file. Returning."]
+          @success = false
+          return
+        end
       end
-    end
+    end # of method initialize
 
 
-    # Returns the relevant information gathered from the read dicom procedure.
-    def return_data()
-      return [@names,@labels,@types,@lengths,@values,@raw,@levels,@compression,@color,@explicit, @file_endian, @msg]
-    end
+    # Following methods are private:
+    private
 
 
     # Checks the initial header of the DICOM file.
     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'.
+      # consequtive (zero) bytes followed by 4 bytes that spell the string 'DICM'.
       # Apparently, some providers seems to skip this in their DICOM files.
-      # First 128 bytes should be zeroes:
-      begin
-        bin1=@file.read(128)
-        @header_length += 128
-      rescue
-        # The file could not be read. Most likely because the file name variable supplied to this instance was in fact a directory.
-        return nil
-      end
-      str_header1=bin1.unpack('a' * 128).to_s
+      bin1 = @file.read(128)
+      @header_length += 128
+      #filler = bin1.unpack('a' * 128).to_s
       # Next 4 bytes should spell 'DICM':
-      bin2=@file.read(4)
+      bin2 = @file.read(4)
       @header_length += 4
-      str_header2=bin2.unpack('a' * 4).to_s
-      # If we dont have this expected header, we will still try to read it is a DICOM file.
-      if str_header2 != 'DICM' then
-        @msg+=["Warning: The specified file does not contain the official DICOM header."]
-        @msg+=["Will try to read the file anyway, as some sources are known to skip the formal DICOM header."]
-        # Some DICOM files skips group 2, which defines the structure of the DICOM file.
-        # This has only been observed in files that also skips the above part of the DICOM header.
-        # Check for skipped group 0002:
-        group_label=bin1.unpack('h4').to_s.reverse.upcase
-        if (group_label.include? "2")
-          #Assume the file starts with a group 0002 tag, as "normal".
-          # Assume a default transfer syntax: Implicit, Little Endian.
-          @explicit = false
-          @rest_explicit = false
-          @file_endian = false
-          @rest_endian = false
-          @compression = false
-        else
-          # Assume a default transfer syntax: Implicit, Little Endian.
-          # (Turns out I use the same settings as above, which makes this somewhat silly, but I'll leave it like this for now in case of any changes later)
-          @explicit = false
-          @rest_explicit = false
-          @file_endian = false
-          @rest_endian = false
-          @compression = false
-          @msg+=["Warning: Group '0002' Transfer Syntax does not exist. Assuming Implicit VR, Little Endian."]
-        end
+      dicm = bin2.unpack('a' * 4).to_s
+      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 tag, and as such, we attempt to choose the most probable encoding values here:
+        @explicit = false
         return false
       else
+        # Header is valid:
         return true
       end
-    end
-
-
-    # Checks the status of the pixel data that has been read from the DICOM file: whether it exists at all and if its greyscale or color.
-    # Modifies instance variable @color if color image is detected and instance variable @compression if no pixel data is detected.
-    def check_pixel_status()
-      # Check if pixel data is present:
-      pixel_pos = @labels.index("7FE0,0010")
-      if pixel_pos == nil
-        @compression = nil
-        return
-      end
-      # Check for color image:
-      col_string = get_value("0028,0004")
-      if col_string != false
-        if (col_string.include? "RGB") or (col_string.include? "COLOR") or (col_string.include? "COLOUR")
-          @color = true
-        end
-      end
-    end
+    end # of method check_header
 
 
     # Governs the process of reading tags in the DICOM file.
@@ -199,106 +102,73 @@ module DICOM
     #going on here in all cases. Perhaps some day I will get the courage to have a go at it again.)
     def process_tag()
       #STEP 1: ------------------------------------------------------
-      # Read the tag label, but do not continue if the method signals that we have reached end of file:
-      label=read_label()
+      # Attempt to read tag label, but abort if we have reached end of file:
+      label = read_label()
       if label == false
+        # End of file, no more tags.
         return false
-      end
-      # Retrieve the tag name and type based on the label we have read from file:
+      end    
+      # STEP 2: ------------------------------------------------------
+      # Access library to retrieve the tag name and VR from the label we have read:
       lib_data = @lib.get_name_vr(label)
       name = lib_data[0]
       vr = lib_data[1]
-      if vr == "UN"
-        @unknown = true
-      else
-        @unknown = false
-      end
-      # STEP 2: ----------------------------------------------------
-      # Continue reading the tag information: Byte type and length.
+      # (Note: VR will be overwritten if the DICOM file contains VR)
+      
+      # STEP 3: ----------------------------------------------------
+      # Read tag VR (if it exists) and the length value:
       tag_info = read_type_length(vr,label)
       type = tag_info[0]
+      level_type = type
       length = tag_info[1]
-      # For sequence type tag, check if the tag have length specified:
-      if type == "SQ"
-        if length == "UNDEFINED" or length.to_i == 0
-          @sq_length = false
-        else
-          @sq_length = true
-        end
-      end
-      # If length is undefined, do not continue to read tag data:
-      if length == "UNDEFINED"
-        if label == "7FE0,0010"
-          data = "(Encapsulated pixel data)"
-          name = "Encapsulated image(s)"
-          type = "SQ"
-        elsif type == "SQ" or type == "()"
-          # Do not change name of tag.
-          data = "(Encapsulated tags)"
-        else
-          data = "(Encapsulated data)"
-          name = "Encapsulated information"
-        end
-        # Set hiearchy level:
-        set_level(type, length, label)
-        return [name,label,type,length,data]
-      end
-      # Add the length of the content of the tag to the last element in the integrated_lengths array:
-      # (but not if it is a sequence or item, as in this case the length of the tag is its sub-tags)
-      if length.to_i != 0 and type != "SQ" and type != "()"
-        @integrated_lengths[@integrated_lengths.size-1] += length
-      end
-      # Set hiearchy level:
-      set_level(type, length, label)
-      # Some special handling for item related tags, which may result in returning without reading data:
-      if type == "()"
-        # If length is zero, just return:
-        if length == 0
-          type = ""
-          data = nil
-          @data_length = 0
-          return [name,label,type,length,data]
-        else
-          # If there is content, this may, in the case of an image, be the image data.
-          # Must insert the image's type here.
-          # Some times when this tag has a length, it does not have content in itself, but instead
-          # have content in a number of subtags.
-          if @sq_length != true
-            # Treat the item as containing image data:
-            type = "OW" # A more general approach should be implemented here.
-            # For this special case, where item contains the data itself, instead of in sub-tags,
-            # we declare that there is to be no sub-level after all.
-            # This handling is not particularly obvious or elegant, and perhaps in the future I will
-            # be able to rewrite this whole process_tag method to something more sane.
-            @current_level = @current_level - 1
-          end
-        end
-      end
-      # STEP 3: ----------------------------------------
-      # Finally read the tag data.
-      tag_data = read_data(type,length)
-      value = tag_data[0]
-      raw = tag_data[1]
-      # Check for the Transfer Syntax UID tag, and process it:
-      if label == "0002,0010"
-        process_syntax(value)
-      end
-      if type == "SQ" or type == "()"
-        @data_length = length # To avoid false errors. In time perhaps a better way of handling this will be found.
+      
+      # STEP 4: ----------------------------------------
+      # Reading value of tag.
+      # Special handling needed for items in encapsulated image data:
+      if @enc_image and label == "FFFE,E000"
+        # The first item appearing after the image tag is a 'normal' item, the rest hold image data.
+        # Note that the first item will contain data if there are multiple images, and so must be read.
+        type = "OW" # how about alternatives like OB?
+        # Modify name of item if this is an item that holds pixel data:
+        if @labels.last != "7FE0,0010"
+          name = "Pixel Data Item"
+        end
+      end
+      # Read the value of the tag (if it contains data, and it is not a sequence or ordinary item):
+      if length.to_i > 0 and type != "SQ" and type != "()"
+        # Read the tag data:
+        tag_data = read_data(type,length)
+        value = tag_data[0]
+        raw = tag_data[1]
       else
-        @data_length = raw.length
-      end
-      return [name,label,type,length,value,raw]
-    end
-    # END READ TAG
+        # No tag data.
+        # Special case: Check if pixel data tag is sequenced:
+        if label == "7FE0,0010"
+          # Change name and type of pixel data tag if it does not contain data itself:
+          name = "Encapsulated Pixel Data"
+          level_type = "SQ"
+          @enc_image = true
+        end
+      end # of if length.to_i > 0
+      # Set the hiearchy level of this tag:
+      set_level(level_type, length, label, name)
+      # Transfer the gathered data to arrays and return true:
+      @names += [name]
+      @labels += [label]
+      @types += [type]
+      @lengths += [length]
+      @values += [value]
+      @raw += [raw]
+      return true
+    end # of method process_tag
 
 
     # Reads and returns TAG LABEL (4 first bytes of tag).
     def read_label()
-      bin1=@file.read(2)
-      bin2=@file.read(2)
-      # Check if we have reached end of file before proceeding:
-      if bin1 == nil or bin2 == nil
+      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 tag label. If this was the first label read from file, we need to add the header length too:
@@ -310,236 +180,195 @@ module DICOM
         @integrated_lengths += [@integrated_lengths[@integrated_lengths.length-1] + 4]
       end
       # Unpack the blobs:
-      label1=bin1.unpack('h*').to_s.reverse.upcase
-      label2=bin2.unpack('h*').to_s.reverse.upcase
-      # Special treatment of tags that are of the first "0002" group:
+      label1 = bin1.unpack('h*').to_s.reverse.upcase
+      label2 = bin2.unpack('h*').to_s.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:
+        # Rearrange the numbers (# This has never been tested btw.):
         label1 = label1[2..3]+label1[0..1]
         label2 = label2[2..3]+label2[0..1]
-        # Has this been verified? Suspect unintended consequence.
       end
-      # Process the label, by considering the endian-ness relationship, if are past the initial "0002" group:
-      if label1 != "0002"
-        # As we are past the initial little endian part of the file, update the file properties:
-        @file_endian = @rest_endian
-        @explicit = @rest_explicit
-        #Update the endian-relationship variable:
-        if @sys_endian == @file_endian
-          @endian = true
-        else
-          @endian = false
-        end
-        # Do we need to rearrange?
-        if @endian
-          # No action needed
-        else
-          # Need to rearrange the first and second part of each string:
-          label1 = label1[2..3]+label1[0..1]
-          label2 = label2[2..3]+label2[0..1]
-        end
+      # When we shift from group 0002 to another group we need to update our endian/explicitness variables:
+      if label1 != "0002" and @switched == false
+        switch_syntax()
       end
-      # Join the label group and label element together to the final string:
-      label=label1+","+label2
-      # Return the label:
-      return label
-    end
-    # END TAG LABEL
+      # Perhaps we need to rearrange the labels?:
+      if not @endian
+        # Need to rearrange the first and second part of each string:
+        label1 = label1[2..3]+label1[0..1]
+        label2 = label2[2..3]+label2[0..1]
+      end
+      # Join the label group and label element together to the final string and return:
+      return label1+","+label2
+    end # of method read_label
 
 
     # Reads and returns TAG TYPE (2 bytes) and TAG LENGTH (Varying length).
     def read_type_length(type,label)
-      # Structure will differ, dependent on whether we have explicit or implicit type of file:
-      # EXPLICIT:
+      # Structure will differ, dependent on whether we have explicit or implicit encoding:
+      # *****EXPLICIT*****:
       if @explicit == true
-        # It seems we need to have a special case for item labels in the explicit scenario:
-        if label == "FFFE,E000" or label == "FFFE,E00D" or label == "FFFE,E0DD"
-          bin=@file.read(4)
-          @integrated_lengths[@integrated_lengths.length-1] += 4
-          length = get_SL(bin)
-        else
+        # Step 1: Read VR (if it exists)
+        unless label == "FFFE,E000" or label == "FFFE,E00D" or label == "FFFE,E0DD"
           # Read tag type field (2 bytes - since we are not dealing with an item related tag):
-          bin=@file.read(2)
+          bin = @file.read(2)
           @integrated_lengths[@integrated_lengths.length-1] += 2
-          type=bin.unpack('a*').to_s
+          type = bin.unpack('a*').to_s
         end
-        # Two (three) possible structures for value length here, dependent on tag type:
+        # Step 2: Read length
+        # Three possible structures for value length here, dependent on tag type:
         case type
-        when "OB","OW","SQ","UN"
-          # Two empty bytes should occur here, according to the standard:
-          bin=@file.read(2)
-          @integrated_lengths[@integrated_lengths.length-1] += 2
-          # Read value length (4 bytes):
-          bin=@file.read(4)
-          @integrated_lengths[@integrated_lengths.length-1] += 4
-          length=get_SL(bin)
-        when "()"
-          #An empty entry for the item related tags (As it has already been processed).
-        else
-          # For all the other tag types: Read value length (2 bytes):
-          bin=@file.read(2)
-          @integrated_lengths[@integrated_lengths.length-1] += 2
-          length=get_US(bin)
+          when "OB","OW","SQ","UN"
+            # 6 bytes total:
+            # Two empty first:
+            bin = @file.read(2)
+            @integrated_lengths[@integrated_lengths.length-1] += 2
+            # Value length (4 bytes):
+            bin = @file.read(4)
+            @integrated_lengths[@integrated_lengths.length-1] += 4
+            length = bin.unpack(@ul)[0]
+          when "()"
+            # 4 bytes:
+            # For labels "FFFE,E000", "FFFE,E00D" and "FFFE,E0DD"
+            bin = @file.read(4)
+            @integrated_lengths[@integrated_lengths.length-1] += 4
+            length = bin.unpack(@ul)[0]
+          else
+            # 2 bytes:
+            # For all the other tag types, value length is 2 bytes:
+            bin = @file.read(2)
+            @integrated_lengths[@integrated_lengths.length-1] += 2
+            length = bin.unpack(@us)[0]
         end
       else
-        #IMPLICIT:
-        # Read value length (4 bytes):
-        bin=@file.read(4)
+        # *****IMPLICIT*****:
+        # No VR (retrieved from library based on the tag's label)
+        # Reading value length (4 bytes):
+        bin = @file.read(4)
         @integrated_lengths[@integrated_lengths.length-1] += 4
-        length = get_SL(bin)
+        length = bin.unpack(@ul)[0]
       end
       # For encapsulated data, the tag length will not be defined. To convey this,
-      # the hex sequence 'ff ff ff ff' is used (-1 converted to signed long).
-      if length == -1
-        length = "UNDEFINED"
+      # the hex sequence 'ff ff ff ff' is used (-1 converted to signed long, 4294967295 converted to unsigned long).
+      if length == 4294967295
+        length = @undef
       elsif length%2 >0
         # According to the DICOM standard, all tag lengths should be an even number.
         # If it is not, it may indicate a file that is not standards compliant or it might even not be a DICOM file.
-        @msg+=["Warning: Odd number of bytes in tag length occured. This is a violation of the DICOM standard, but program will attempt to continue reading the rest of the file."]
+        @msg += ["Warning: Odd number of bytes in tag length occured. This is a violation of the DICOM standard, but program will still attempt to read the rest of the file."]
       end
-      return [type,length]
-    end
-    # END BYTE TYPE and TAG LENGTH
+      return [type, length]
+    end # of method read_type_length
 
 
-    # Reads and returns TAG DATA (Varying length - determined at an earlier stage).
+    # Reads and returns TAG DATA (Of varying length - which is determined at an earlier stage).
     def read_data(type, length)
-      # Treatment dependent on what type of information we are dealing with.
+      # Read the data:
+      bin = @file.read(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 these numbers tags will contain just one number, but in some cases,
-      # they contain multiple numbers. In such cases we will read each number and store
-      # them all in a string separated by "/".
-      # Unsigned long: (4 bytes)
-      when "UL"
-        bin = @file.read(length)
-        if length <= 4
-          data = get_UL(bin)
-        else
-          data = process_numbers(length, type, bin)
-        end
-
-      # Signed long: (4 bytes)
-      when "SL"
-        bin = @file.read(length)
-        if length <= 4
-          data = get_SL(bin)
-        else
-          data = process_numbers(length, type, bin)
-        end
+        # Normally the "number tags" will contain just one number, but in some cases,
+        # they contain multiple numbers. In such 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
 
-      # Unsigned short: (2 bytes)
-      when "US"
-        bin = @file.read(length)
-        if length <= 2
-          data = get_US(bin)
-        else
-          data = process_numbers(length, type, bin)
-        end
+        # Signed long: (4 bytes)
+        when "SL"
+          if length <= 4
+            data = bin.unpack(@sl)[0]
+          else
+            data = bin.unpack(@sl).join("/")
+          end
 
-      # Signed short: (2 bytes)
-      when "SS"
-        bin = @file.read(length)
-        if length <= 2
-          data = get_SS(bin)
-        else
-          data = process_numbers(length, type, bin)
-        end
+        # Unsigned short: (2 bytes)
+        when "US"
+          if length <= 2
+            data = bin.unpack(@us)[0]
+          else
+            data = bin.unpack(@us).join("/")
+          end
 
-      # Floating point double: (8 bytes)
-      when "FD"
-        bin = @file.read(length)
-        if length <= 8
-          data = get_FD(bin)
-        else
-          data = process_numbers(length, type, bin)
-        end
+        # Signed short: (2 bytes)
+        when "SS"
+          if length <= 2
+            data = bin.unpack(@ss)[0]
+          else
+            data = bin.unpack(@ss).join("/")
+          end
 
-      # Unknown information, header element is not recognised from local database:
-      when "UN"
-        bin=@file.read(length)
-        data=bin.unpack('H*')[0]
-
-      # A tag that contains items/elements (sequence of elements):
-      when "SQ"
-        # The tag has no content in itself, the file starts directly on a new tag adress.
-        data="(Sequence of Elements)"
-
-      # Item tag:
-      when "()"
-        # Tag may have a length, but no content belonging to this tag itself. They are to be read
-        # for this item's subtags.
-        data = "(Sequence of Tags)"
-
-      # The tag contains a tag adress (4 bytes):
-      when "AT"
-        if length != 4
-          @msg+=["Warning: Unexpected tag length, expected 4 bytes for tag type 'AT'!"]
-        end
-        temp=Array.new(4)
-        4.times do |i|
-          bin=@file.read(1)
-          temp[i]=bin.unpack('H*')[0]
-        end
-        # Put together, mix up the order to get it correct:
-        data=temp[1].to_s+temp[0].to_s+"."+temp[3].to_s+temp[2].to_s
-        # This has not been tested with other than Little endian system/file:
-        if @file_endian or @system_endian
-          @msg+=["Warning: Handling for tag type 'AT' has not been verified for other than default endianness."]
-        end
+        # Floating point single: (4 bytes)
+        when "FL"
+          if length <= 4
+            data = bin.unpack(@fs)[0]
+          else
+            data = bin.unpack(@fs).join("/")
+          end
 
-      # Binary data, used sometimes when we have encapsulated images:
-      when "OB"
-        bin=@file.read(length)
-        data=bin.unpack('H*')[0]
-
-      # Image data:
-      when "OW"
-        # We need to know what kind of bith depth the pixel data is saved with:
-        bit_depth=get_value('0028,0100')
-        # Proceed to read the image binary data:
-        bin=@file.read(length)
-        # Number of bytes used per pixel will determine how to unpack this:
-        case bit_depth
-        when 8
-          data=get_BYTE(bin) # Byte/Character/Fixnum (1 byte)
-        when 16
-          data=get_US(bin) # Unsigned short (2 bytes)
-        when 12
-          # 12 BIT SIMPLY NOT WORKING YET!
-          # This one is a bit more tricky to extract.
-          # I havent really given this priority so far as 12 bit image data is rather rare.
-          @msg+=["Warning: Bit depth 12 is not working correctly at this time!"]
-          data=Array.new(length)
-          (length).times do |i|
-            hex=bin.unpack('H3')
-            hex4="0"+hex[0]
-            num=hex[0].unpack('v')
-            data[i]=num
+        # Floating point double: (8 bytes)
+        when "FD"
+          if length <= 8
+            data = bin.unpack(@fd)[0]
+          else
+            data = bin.unpack(@fd).join("/")
           end
-        else
-          raise "Bit depth "+bit_depth.to_s+" has not received implementation in this procedure yet."
-        end
 
-      # For everything else, assume string type information:
-      when 'AE','AS','CS','DA','DS','DT','IS','LO','LT','PN','SH','ST','TM','UI','UT' #,'VR'
-        bin=@file.read(length)
-        data=bin.unpack('a*').to_s
-      else
-        @msg+=["Warning: Tag type "+type+" does not have a reading method assigned to it. Please update the source code."]
-        bin=@file.read(length)
-        data=bin.unpack('H*')[0]
-      end
+        # The tag contains a tag label (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.
+          # Tag label 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*').to_s
+          
+        # NB! 
+        # FOLLOWING TAG TYPES WILL NOT BE DECODED.
+        # DECODING OF PIXEL DATA IS MOVED TO DOBJECT FOR PERFORMANCE REASONS.
+        
+        # Unknown information, header element is not recognised 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 tag 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:
+        else
+          @msg += ["Warning: Tag type #{type} does not have a reading method assigned to it. Please contact the author."]
+          #data = bin.unpack('H*')[0]
+      end # of case type
       
       # Return the data:
-      return [data,bin]
-    end
-    # END TAG DATA
+      return [data, bin]
+    end # of method read_data
 
 
     # Sets the level of the current tag in the hiearchy.
     # The default (top) level is zero.
-    def set_level(type, length, label)
+    def set_level(type, length, label, name)
       # Set the level of this tag:
       @levels += [@current_level]
       # Determine if there is a level change for the following tag:
@@ -550,7 +379,7 @@ module DICOM
       # not in its sub-tags, we should not increase the level. (This is fixed in the process_tag method.)
       if type == "SQ"
         increase = true
-      elsif label =="FFFE,E000"
+      elsif name == "Item"
         increase = true
       else
         increase = false
@@ -574,9 +403,11 @@ module DICOM
       # If it is an array (of length and position), then we need to check the integrated_lengths array
       # to see if the current sub-level has expired.
       if @hierarchy.size > 0
-        check_level_end()
+        # 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 label == "FFFE,E0DD"
       end
-    end
+    end # of method set_level
     
     
     # Checks how far we've read in the DICOM file to determine if we have reached a point
@@ -607,266 +438,166 @@ module DICOM
           end
         end
       end
-    end
+    end # of method check_level_end
 
 
-    # Returns the (processed) value of a DICOM tag based on an input tag label, category name or array index.
-    def get_value(id)
-      # Assume we have been fed a tag label:
-      pos=@labels.index(id)
-      # If this does not give a hit, assume we have been fed a tag name:
-      if pos==nil
-        pos=@names.index(id)
-      end
-      # If we still dont have a hit, check if it is a valid number within the array range:
-      if pos == nil 
-        if (id.is_a? Integer)
-          if id >= 0 and id <= @lastIndex
-            # The id supplied is a valid position, return its corresponding value:
-            return @values[id]
+    # Tests if the file is readable and opens it.
+    def open_file(file)
+      if File.exist?(file)
+        if File.readable?(file)
+          if not File.directory?(file)
+            if File.size(file) > 8
+              @file = File.new(file, "rb")
+            else
+              @msg += ["Error! File is too small to contain DICOM information. Returning. (#{file})"]
+            end
           else
-            return false
+            @msg += ["Error! File is a directory. Returning. (#{file})"]
           end
         else
-          return false
+          @msg += ["Error! File exists but I don't have permission to read it. Returning. (#{file})"]
         end
       else
-        # We have a valid position, return the value:
-        return @values[pos]
+        @msg += ["Error! The file you have supplied does not exist. Returning. (#{file})"]
       end
-    end
+    end # of method open_file
 
 
-    # Process a series of numbers to return a string containing all the numbers separated with the separator "/" between the numbers.
-    def process_numbers(length, type, bin)
-      size = bin.length
-      data=""
-      case type
-      when "UL"
-        temp1 = get_UL(bin)
-      when "SL"
-        temp1 = get_SL(bin)
-      when "US"
-        temp1 = get_US(bin)
-      when "SS"
-        temp1 = get_SS(bin)
-      when "FD"
-        temp1 = get_FD(bin)
-      else
-        @msg+=["Warning: Type "+type+"not supported in method process_numbers()."]
-      end
-      remain = (length-size)/size
-      remain.times do
-        bin = @file.read(size)
-        case type
-        when "UL"
-          temp2 = get_UL(bin)
-        when "SL"
-          temp2 = get_SL(bin)
-        when "US"
-          temp2 = get_US(bin)
-        when "SS"
-          temp2 = get_SS(bin)
-        when "FD"
-          temp2 = get_FD(bin)
-        else
-          @msg+=["Warning: Type "+type+"not supported in method process_numbers()."]
-        end
-        data = temp1.to_s+"/"+temp2.to_s
-        temp1 = data
-      end
-      return data
-    end
-
-    # Returns a byte integer (1 byte), from the supplied variable.
-    def get_BYTE(bin)
-      # If bin contains several numbers, unpack and return in an array. If just one number, return the number:
-      elements = bin.size
-      if @endian
-        # Native byte order:
-        if elements > 1
-          num=bin.unpack('C*')
-        else
-          num=bin.unpack('C*')[0]
-        end
-      else
-        # Network byte order: (Unknown what to use here)
-        @msg+=["Warning: Method get_BYTE not tested with this endian yet!"]
-        if elements > 1
-          num=bin.unpack('C*')
-        else
-          num=bin.unpack('C*')[0]
-        end
-      end
-      return num
-    end
-
-
-    # Returns a unsigned short (2 bytes), from the supplied variable.
-    def get_US(bin)
-      # If bin contains several numbers, unpack and return in an array. If just one number, return the number:
-      elements = bin.size/2
-      if @endian
-        # Native byte order:
-        if elements > 1
-          num=bin.unpack('S*') # or v (little endian (?))
-        else
-          num=bin.unpack('S*')[0]
-        end
-      else
-        # Network byte order:
-        if elements > 1
-          num=bin.unpack('n*')
-        else
-          num=bin.unpack('n*')[0]
-        end
-      end
-      return num
-    end
-
-
-    # Returns a signed short (2 bytes), from the supplied variable.
-    def get_SS(bin)
-      elements = bin.size/2
-      # If bin contains several numbers, unpack and return in an array. If just one number, return the number:
-      if @endian
-        # Native byte order
-        if elements > 1
-          num=bin.unpack('s*')
-        else
-          num=bin.unpack('s*')[0]
-        end
-      else
-        # Unknown what unpack code to use here:
-        if elements > 1
-          num=bin.unpack('s*') 
-        else
-          num=bin.unpack('s*')[0] 
-        end
-        @msg+=["Warning: Oppositve endian for signed short is not working yet!"]
-      end
-      return num
-    end
-
-
-    # Returns an unsigned long (4 bytes), from the supplied variable.
-    def get_UL(bin)
-      elements = bin.size/4
-      # If bin contains several numbers, unpack and return in an array. If just one number, return the number:
-      if @endian
-        # Unsigned native integer:
-        if elements > 1
-          num=bin.unpack('I*')
-        else
-          num=bin.unpack('I*')[0]
-        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 tag (if present), needs to be processed:
+      process_transfer_syntax()
+      # We only plan to run this method once:
+      @switched = true
+      # Update endian, explicitness and unpack variables:
+      @file_endian = @rest_endian
+      @explicit = @rest_explicit
+      if @sys_endian == @file_endian
+        @endian = true
       else
-        # Unsigned long in network byte order:
-        if elements > 1
-          num=bin.unpack('N*')
-        else
-          num=bin.unpack('N*')[0]
-        end
+        @endian = false
       end
-      return num
+      set_unpack_strings()
     end
 
 
-    # Returns a signed long (4 bytes), from the supplied variable.
-    def get_SL(bin)
-      elements = bin.size/4
-      # If bin contains several numbers, unpack and return in an array. If just one number, return the number:
-      if @endian
-        # Signed native long integer:
-        if elements > 1
-          num=bin.unpack('l*')
-        else
-          num=bin.unpack('l*')[0]
-        end
-      else
-        @msg+=["Warning: Oppositve endian for signed long is not working yet!"]
-        if elements > 1
-          num=bin.unpack('l*')
-        else
-          num=bin.unpack('l*')[0]
-        end
-      end
-      return num
-    end
+    # Checks the Transfer Syntax UID tag 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 = @labels.index("0002,0010")
+      if ts_pos != nil
+        ts_value = @raw[ts_pos].unpack('a*').to_s.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."]
+        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
 
 
-    # Returns a floating point double (8 bytes), from the supplied variable.
-    def get_FD(bin)
-      elements = bin.size/8
-      # If bin contains several numbers, unpack and return in an array. If just one number, return the number:
+    # Sets the unpack format strings that will be used for numbers depending on endianness of file/system.
+    def set_unpack_strings
       if @endian
-        # Double in little-endian byte order:
-        if elements > 1
-          num=bin.unpack('E*')
-        else
-          num=bin.unpack('E*')[0]
-        end
+        # 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
-        # Double in network byte order:
-        if elements > 1
-          num=bin.unpack('G*')
-        else
-          num=bin.unpack('G*')[0]
-        end
+        # 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 num
     end
 
 
-    # Checks the Transfer Syntax UID tag and updates class variables to prepare for correct reading of DICOM file.
-    def process_syntax(value)
-      ts = value.rstrip
-      valid = @lib.check_transfer_syntax(ts)
-      if not valid
-        @msg+=["Warning: Invalid/unknown transfer syntax! Will try reading the file, but errors may occur."]
-      end
-      case ts
-      # Some variations with uncompressed pixel data:
-      when "1.2.840.10008.1.2"
-        # Implicit VR, Little Endian
-        @rest_explicit = false
-        @rest_endian = false
-        @compression = false
-      when "1.2.840.10008.1.2.1"
-        # Explicit VR, Little Endian
-        @rest_explicit = true
-        @rest_endian = false
-        @compression = 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
-        @compression = false
-      when "1.2.840.10008.1.2.2"
-        # Explicit VR, Big Endian
-        @rest_explicit = true
-        @rest_endian = true
-        @compression = false
+    # Initiates the variables that are used during file reading.
+    def init_variables()
+      # Variables that hold data that will be available to the DObject class.
+      # Arrays that will hold information from the tags of the DICOM file:
+      @names = Array.new()
+      @labels = 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()
+      # 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::
+      @explicit = true
+      # Default endianness of start of DICOM files is little endian:
+      @file_endian = false
+      # Variable used to tell whether file was read succesfully or not:
+      @success = false
+      
+      # 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 tag:
+      # (This is necessary for tracking the hiearchy in some DICOM files)
+      @integrated_lengths = Array.new()
+      @header_length = 0
+      # Array to keep track of the hierarchy of tags (this will be used to determine when a sequence or item is finished):
+      @hierarchy = Array.new()
+      @hierarchy_error = false
+      # Explicitness of the remaining groups after the initial 0002 group:
+      @rest_explicit = false
+      # Endianness of the remaining groups after the first group:
+      @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
-        # For everything else, assume compressed pixel data, with Explicit VR, Little Endian:
-        @rest_explicit = true
-        @rest_endian = false
-        @compression = true
+        @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 tag was read correctly, or whether the file endend unexpectedly:
+      @data_length = 0
+      # Keeping track of the tag level while reading through the file:
+      @current_level = 0
+      # This variable's string will be inserted as the length of items/sq that dont have a specified length:
+      @undef = "UNDEFINED"
+      # Items contained under the pixel data tag may contain data directly, so we need a variable to keep track of this:
+      @enc_image = false
     end
 
-
-    # Checks the endianness of the system. Returns false if little endian, true if big endian.
-    def check_sys_endian()
-      x = 0xdeadbeef
-      endian_type = {
-        Array(x).pack("V*") => false, #:little
-        Array(x).pack("N*") => true   #:big 
-      }
-      return endian_type[Array(x).pack("L*")] 
-    end
-
-
-  end # End of class.
-end # End of module.
+  end # End of class
+end # End of module