dicom 0.4 → 0.5

data/lib/DLibrary.rb

@@ -1,10 +1,10 @@
-#    Copyright 2008-2009 Christoffer Lerv�g
+#    Copyright 2008-2009 Christoffer Lervag
 
 module DICOM
   # Class which holds the methods that interact with the DICOM dictionary.
   class DLibrary
 
-    attr_reader :de_label, :de_vr, :de_name, :uid_value, :uid_name, :uid_type, :pi_type, :pi_description
+    attr_reader :de_tag, :de_vr, :de_name, :uid_value, :uid_name, :uid_type, :pi_type, :pi_description
 
     # Initialize the DRead instance.
     def initialize()
@@ -12,8 +12,8 @@ module DICOM
       # Load the dictionary:
       dict = Dictionary.new()
       # Data elements:
-      de = dict.load_tags()
-      @de_label = de[0]
+      de = dict.load_data_elements()
+      @de_tag = de[0]
       @de_vr = de[1]
       @de_name = de[2]
       # Photometric Interpretation:
@@ -28,37 +28,37 @@ module DICOM
     end
 
 
-    # Returns data element name and value representation from library if tag is recognised, else it returns "Unknown Name" and "UN".
-    def get_name_vr(label)
-      pos = get_pos(label)
+    # Returns data element name and value representation from library if data element is recognized, else it returns "Unknown Name" and "UN".
+    def get_name_vr(tag)
+      pos = get_pos(tag)
       if pos != nil
         name = @de_name[pos]
         vr = @de_vr[pos][0]
       else
-        # For the labels that are not recognised, we need to do some additional testing to see if it is one of the special cases:
-        # Split label in group and element:
-        group = label[0..3]
-        element = label[5..8]
+        # For the tags that are not recognised, we need to do some additional testing to see if it is one of the special cases:
+        # Split tag in group and element:
+        group = tag[0..3]
+        element = tag[5..8]
         # Check for group length:
         if element == "0000"
           name = "Group Length"
           vr = "UL"
         end
         # Source Image ID's: (Retired)
-        if label[0..6] == "0020,31"
+        if tag[0..6] == "0020,31"
           pos = get_pos("0020,31xx")
           name = @de_name[pos]
           vr = @de_vr[pos][0]
         end
         # Group 50xx (retired) and 60xx:
-        if label[0..1] == "50" or label[0..1] == "60"
-          pos = get_pos(label[0..1]+"xx"+label[4..8])
+        if tag[0..1] == "50" or tag[0..1] == "60"
+          pos = get_pos(tag[0..1]+"xx"+tag[4..8])
           if pos != nil
             name = @de_name[pos]
             vr = @de_vr[pos][0]
           end
         end
-        # If none of the above checks yielded a result, the label is unknown:
+        # If none of the above checks yielded a result, the tag is unknown:
         if name == nil
           name = "Unknown Name"
           vr = "UN"
@@ -68,17 +68,40 @@ module DICOM
     end
 
 
+    # Returns the tag that matches the supplied data element name,
+    # or if a tag is supplied, return that tag.
+    def get_tag(value)
+      tag = false
+      # The supplied value should be a string:
+      if value.is_a?(String)
+        # Is it a tag?
+        # A tag is a string with 9 characters, where the 5th character should be a comma.
+        if value[4..4] == ',' and value.length == 9
+          # This is a tag.
+          # (Here it is possible to have some further logic to check the validity of the string as a tag.)
+          tag = value
+        else
+          # We have presumably been dealt a name. Search the dictionary to see if we can identify
+          # it along with its corresponding tag:
+          pos = @de_name.index(value)
+          tag = @de_tag[pos] unless pos == nil
+        end
+      end
+      return tag
+    end
+
+
     # Checks whether a given string is a valid transfer syntax or not.
-    def check_ts_validity(label)
-      res = false
-      pos = @uid_value.index(label)
+    def check_ts_validity(value)
+      result = false
+      pos = @uid_value.index(value)
       if pos != nil
         if pos >= 1 and pos <= 34
           # Proved valid:
-          res = true
+          result = true
         end
       end
-      return res
+      return result
     end
 
 
@@ -94,8 +117,8 @@ module DICOM
       end
       return name
     end
-    
-    
+
+
     # Checks if the supplied transfer syntax indicates the presence of pixel compression or not.
     def get_compression(value)
       res = false
@@ -115,8 +138,8 @@ module DICOM
     private
 
     # Returns the position of the supplied data element name in the Dictionary array.
-    def get_pos(label)
-      pos = @de_label.index(label)
+    def get_pos(tag)
+      pos = @de_tag.index(tag)
       return pos
     end
 

data/lib/DObject.rb

@@ -1,4 +1,4 @@
-#    Copyright 2008-2009 Christoffer Lerv�g
+#    Copyright 2008-2009 Christoffer Lervag
 #
 #    This program is free software: you can redistribute it and/or modify
 #    it under the terms of the GNU General Public License as published by
@@ -29,7 +29,8 @@ module DICOM
   # Class for handling the DICOM contents:
   class DObject
 
-    attr_reader :read_success, :write_success, :modality
+    attr_reader :read_success, :write_success, :modality, :errors,
+                      :names, :tags, :types, :lengths, :values, :raw, :levels
 
     # Initialize the DObject instance.
     def initialize(file_name=nil, opts={})
@@ -38,20 +39,20 @@ module DICOM
       @lib =  opts[:lib]  || DLibrary.new
       # Default verbosity is true:
       @verbose = true if @verbose == nil
-      
+
       # Initialize variables that will be used for the DICOM object:
       @names = Array.new()
-      @labels = 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()
-      # Array to keep track of sequences/structure of the dicom tags:
+      @errors = Array.new()
+      # Array to keep track of sequences/structure of the dicom elements:
       @sequence = Array.new()
-      # Index of last element in tag arrays:
+      # Index of last element in data element arrays:
       @last_index=0
       # Structural information (default values):
       @compression = false
@@ -66,11 +67,11 @@ module DICOM
       @sys_endian = check_sys_endian()
       # Set format strings for packing/unpacking:
       set_format_strings()
-      
+
       # If a (valid) file name string is supplied, call the method to read the DICOM file:
-      if file_name != nil and file_name != ""
+      if file_name.is_a?(String) and file_name != ""
         @file = file_name
-        read_file(file_name)
+        read(file_name)
       end
     end # of method initialize
 
@@ -79,13 +80,13 @@ module DICOM
     # This is accomplished by initliazing the DRead class, which loads DICOM information to arrays.
     # For the time being, this method is called automatically when initializing the DObject class,
     # but in the future, when write support is added, this method may have to be called manually.
-    def read_file(file_name)
+    def read(file_name)
       dcm = DRead.new(file_name, :lib => @lib, :sys_endian => @sys_endian)
       # Store the data to the instance variables if the readout was a success:
       if dcm.success
         @read_success = true
         @names = dcm.names
-        @labels = dcm.labels
+        @tags = dcm.tags
         @types = dcm.types
         @lengths = dcm.lengths
         @values = dcm.values
@@ -95,7 +96,7 @@ module DICOM
         @file_endian = dcm.file_endian
         # Set format strings for packing/unpacking:
         set_format_strings(@file_endian)
-        # Index of last element in tag arrays:
+        # Index of last data element in element arrays:
         @last_index=@names.length-1
         # Update status variables for this object:
         check_properties()
@@ -109,13 +110,13 @@ module DICOM
         add_msg(dcm.msg)
       end
     end
-    
-    
+
+
     # Transfers necessary information from the DObject to the DWrite class, which
     # will attempt to write this information to a valid DICOM file.
-    def write_file(file_name)
+    def write(file_name)
       w = DWrite.new(file_name, :lib => @lib, :sys_endian => @sys_endian)
-      w.labels = @labels
+      w.tags = @tags
       w.types = @types
       w.lengths = @lengths
       w.raw = @raw
@@ -129,8 +130,8 @@ module DICOM
         add_msg(w.msg)
       end
     end
-    
-    
+
+
     #################################################
     # START OF METHODS FOR READING INFORMATION FROM DICOM OBJECT:#
     #################################################
@@ -140,14 +141,14 @@ module DICOM
     # Modifies instance variable @color if color image is detected and instance variable @compression if no pixel data is detected.
     def check_properties()
       # Check if pixel data is present:
-      if @labels.index("7FE0,0010") == nil
+      if @tags.index("7FE0,0010") == nil
         # No pixel data in DICOM file:
         @compression = nil
       else
-        @compression = @lib.get_compression(get_value("0002,0010"))
+        @compression = @lib.get_compression(get_value("0002,0010", :silent => true))
       end
       # Set color variable as true if our object contain a color image:
-      col_string = get_value("0028,0004")
+      col_string = get_value("0028,0004", :silent => true)
       if col_string != false
         if (col_string.include? "RGB") or (col_string.include? "COLOR") or (col_string.include? "COLOUR")
           @color = true
@@ -156,10 +157,14 @@ module DICOM
     end
 
 
-    # Returns image data from the provided tag index, performing decompression of data if necessary.
+    # Returns image data from the provided element index, performing decompression of data if necessary.
     def read_image_magick(pos, columns, rows)
+      if pos == false or columns == false or rows == false
+        add_msg("Error: Method read_image_magick() does not have enough data available to build an image object.")
+        return false
+      end
       if @compression != true
-        # Non-compressed, just return the array contained in the particular tag:
+        # Non-compressed, just return the array contained on the particular element:
         image_data=get_pixels(pos)
         image = Magick::Image.new(columns,rows)
         image.import_pixels(0, 0, columns, rows, "I", image_data)
@@ -204,9 +209,9 @@ module DICOM
       image = NArray.int(frames,columns,rows)
       image_temp = NArray.int(columns,rows)
       # Handling of image data will depend on whether we have one or more frames,
-      # and if it is located in one or more tags:
+      # and if it is located in one or more elements:
       if image_pos.size == 1
-        # All of the image data is located in one tag:
+        # All of the image data is located in one element:
         image_data = get_pixels(image_pos[0])
         #image_data = get_image_data(image_pos[0])
         (0..frames-1).each do |i|
@@ -264,7 +269,7 @@ module DICOM
       image_arr = Array.new(frames)
       # Handling of image data will depend on whether we have one or more frames,
       if image_pos.size == 1
-        # All of the image data is located in one tag:
+        # All of the image data is located in one element:
         #image_data = get_image_data(image_pos[0])
         #(0..frames-1).each do |i|
          # image = Magick::Image.new(columns,rows)
@@ -295,14 +300,14 @@ module DICOM
     def get_frames()
       frames = get_value("0028,0008")
       if frames == false
-        # If file does not specify number of tags, assume 1 image frame.
+        # If the DICOM object does not specify the number of frames explicitly, assume 1 image frame.
         frames = 1
       end
       return frames.to_i
     end
-    
-    
-    # Unpacks and returns pixel data from a specified tag position:
+
+
+    # Unpacks and returns pixel data from a specified data element array position:
     def get_pixels(pos)
       pixels = false
       # We need to know what kind of bith depth the pixel data is saved with:
@@ -332,32 +337,32 @@ module DICOM
             raise "Bit depth ["+bit_depth.to_s+"] has not received implementation in this procedure yet. Please contact the author."
         end # of case bit_depth
       else
-        add_msg("Error: DICOM object does not contain bit depth tag (0028,0010).")
+        add_msg("Error: DICOM object does not contain the 'Bit Depth' data element (0028,0010).")
       end # of if bit_depth ..
       return pixels
     end # of method get_pixels
 
 
-    # Returns the index(es) of the tag(s) that contain image data.
+    # Returns the index(es) of the element(s) that contain image data.
     def get_image_pos()
-      image_tag_pos = get_pos("7FE0,0010")
+      image_element_pos = get_pos("7FE0,0010")
       item_pos = get_pos("FFFE,E000")
-      # Proceed only if image tag actually exists:
-      if image_tag_pos == false
+      # Proceed only if an image element actually exists:
+      if image_element_pos == false
         return false
       else
-        # Check if we have item tags:
+        # Check if we have item elements:
         if item_pos == false
-          return image_tag_pos
+          return image_element_pos
         else
-          # Extract item positions that occur after the image tag position:
-          late_item_pos = item_pos.select {|item| image_tag_pos[0] < item}
-          # Check if there are items appearing after the image tag.
+          # Extract item positions that occur after the image element position:
+          late_item_pos = item_pos.select {|item| image_element_pos[0] < item}
+          # Check if there are items appearing after the image element.
           if late_item_pos.size == 0
-            # None occured after the image tag position:
-            return image_tag_pos
+            # None occured after the image element position:
+            return image_element_pos
           else
-            # Determine which of these late item tags contain image data.
+            # Determine which of these late item elements contain image data.
             # Usually, there are frames+1 late items, and all except
             # the first item contain an image frame:
             frames = get_frames()
@@ -369,7 +374,7 @@ module DICOM
                 return false
               end
             else
-              add_msg("Warning: Number of frames tag not found. Method get_image_pos() will return false.")
+              add_msg("Warning: 'Number of Frames' data element not found. Method get_image_pos() will return false.")
               return false
             end
           end
@@ -378,58 +383,81 @@ module DICOM
     end # of method get_image_pos
 
 
-    # Returns an array of the index(es) of the tag(s) in the DICOM file that match the supplied tag label, name or position.
+    # Returns an array of the index(es) of the element(s) in the DICOM file that match the supplied element position, tag or name.
     # If no match is found, the method will return false.
     # Additional options:
-    # :array => myArray - tells the method to search for hits in this specific array of positions instead of searching
-    #                                  through the entire DICOM obhject. If myArray is false, so will the return of this method.
-    #                                  If array is nil (not specified), then the entire DICOM object will be searched.
-    def get_pos(label, opts={})
-      # Process option value:
-      opt_array = opts[:array]
-      if opt_array == false
-        # If the supplied array option equals false, it signals that the user tries to search for a tag 
-        # in an invalid position, and as such, this method should also return false:
-        indexes = false
-      else
-        # Perform search to find indexes:
-        # Array that will contain the positions where the supplied label gives a match:
-        indexes = Array.new()
-        # Either use the supplied array, or we will create an array that contain the indices of the entire DICOM object:
-        if opt_array.is_a?(Array)
-          search_array=opt_array
+    # :array => myArray - tells the method to search for matches in this specific array of positions instead of searching
+    #                                  through the entire DICOM object. If myArray equals false, the method will return false.
+    # :partial => true - get_pos will not only search for exact matches, but will search the names and tags arrays for
+    #                             strings that contain the given search string.
+    def get_pos(query, opts={})
+      # Optional keywords:
+      keyword_array = opts[:array]
+      keyword_partial = opts[:partial]
+      indexes = Array.new()
+      # For convenience, allow query to be a one-element array (its value will be extracted):
+      if query.is_a?(Array)
+        if query.length > 1 or query.length == 0
+          add_msg("Invalid array length supplied to method get_pos.")
+          return false
         else
-          search_array = Array.new(@names.size) {|i| i}
+          query = query[0]
         end
-        # Do the search:
-        search_array.each do |i|
-          if @labels[i] == label
-            indexes += [i]
-          elsif @names[i] == label
-            indexes += [i]
-          elsif label == i
-            indexes += [i]
+      end
+      if keyword_array == false
+        # If the supplied array option equals false, it signals that the user tries to search for an element
+        # in an invalid position, and as such, this method will also return false:
+        add_msg("Warning: Attempted to call get_pos() with query #{query}, but since keyword :array is false I will return false.")
+        indexes = false
+      else
+        # Check if query is a number (some methods want to have the ability to call get_pos() with a number):
+        if query.is_a?(Integer)
+          # Return the position if it is valid:
+          indexes = [query] if query >= 0 and query < @names.length
+        elsif query.is_a?(String)
+          # Either use the supplied array, or search the entire DICOM object:
+          if keyword_array.is_a?(Array)
+            search_array = keyword_array
+          else
+            search_array = Array.new(@names.length) {|i| i}
+          end
+          # Perform search:
+          if keyword_partial == true
+            # Search for partial string matches:
+            partial_indexes = search_array.all_indices_partial_match(@tags, query.upcase)
+            if partial_indexes.length > 0
+              indexes = partial_indexes
+            else
+              indexes = search_array.all_indices_partial_match(@names, query)
+            end
+          else
+            # Search for identical matches:
+            if query[4..4] == ","
+              indexes = search_array.all_indices(@tags, query.upcase)
+            else
+              indexes = search_array.all_indices(@names, query)
+            end
           end
         end
-        # If no hits occured, we will return false instead of an empty array:
-        indexes = false if indexes.size == 0
+        # Policy: If no matches found, return false instead of an empty array:
+        indexes = false if indexes.length == 0
       end
       return indexes
     end # of method get_pos
-    
-    
-    # Dumps the binary content of the Pixel Data tag to file.
+
+
+    # Dumps the binary content of the Pixel Data element to file.
     def image_to_file(file)
       pos = get_image_pos()
       if pos
         if pos.length == 1
-          # Pixel data located in one tag:
+          # Pixel data located in one element:
           pixel_data = get_raw(pos[0])
           f = File.new(file, "wb")
           f.write(pixel_data)
           f.close()
         else
-          # Pixel data located in several tags:
+          # Pixel data located in several elements:
           pos.each_index do |i|
             pixel_data = get_raw(pos[i])
             f = File.new(file + i.to_s, "wb")
@@ -441,159 +469,161 @@ module DICOM
     end # of method image_to_file
 
 
-    # Returns the positions of all tags inside the hierarchy of a sequence or an item.
+    # Returns the positions of all data elements inside the hierarchy of a sequence or an item.
     # Options:
     # :next_only => true - The method will only search immediately below the specified
     # item or sequence (that is, in the level of parent + 1).
-    def children(tag, opts={})
+    def children(element, opts={})
       # Process option values, setting defaults for the ones that are not specified:
       opt_next_only = opts[:next_only] || false
-      # Retrieve position of parent tag which from which we will search:
-      pos = get_pos(tag)
+      value = false
+      # Retrieve array position:
+      pos = get_pos(element)
       if pos == false
-        return false
-      end
-      if pos.size > 1
-        add_msg("Warning: The supplied parent tag gives multiple hits. Search will be applied to all hits. To avoid this behaviour, specify position instead of label.")
-      end
-      # First we need to establish in which positions to perform the search:
-      below_pos = Array.new()
-      pos.each do |p|
-        parent_level = @levels[p]
-        remain_array = @levels[p+1..@levels.size-1]
-        extract = true
-        remain_array.each_index do |i| 
-          if (remain_array[i] > parent_level) and (extract == true)
-            # If search is targetted at any specific level, we can just add this position:
-            if not opt_next_only == true
-              below_pos += [p+1+i]
-            else
-              # As search is restricted to parent level + 1, do a test for this:
-              if remain_array[i] == parent_level + 1
-                below_pos += [p+1+i]
+        add_msg("Warning: Invalid data element provided to method children(). Returning false.")
+      else
+        if pos.size > 1
+          add_msg("Warning: Method children() does not allow a query which yields multiple array hits. Please use array position instead of tag/name. Returning false.")
+        else
+          # Proceed to find the value:
+          # First we need to establish in which positions to perform the search:
+          below_pos = Array.new()
+          pos.each do |p|
+            parent_level = @levels[p]
+            remain_array = @levels[p+1..@levels.size-1]
+            extract = true
+            remain_array.each_index do |i|
+              if (remain_array[i] > parent_level) and (extract == true)
+                # If search is targetted at any specific level, we can just add this position:
+                if not opt_next_only == true
+                  below_pos += [p+1+i]
+                else
+                  # As search is restricted to parent level + 1, do a test for this:
+                  if remain_array[i] == parent_level + 1
+                    below_pos += [p+1+i]
+                  end
+                end
+              else
+                # If we encounter a position who's level is not deeper than the original level, we can not extract any more values:
+                extract = false
               end
             end
-          else
-            # If we encounter a position who's level is not deeper than the original level, we can not extract any more values:
-            extract = false
-          end
-        end
-      end
-      # Positions to search in have been established, now we can perform the actual search:
-      if below_pos.size == 0
-        return false
-      else
-        return below_pos
+          end # of pos.each do..
+          value = below_pos if below_pos.size != 0
+        end # of if pos.size..else..
       end
+      return value
     end # of method below
 
 
-    # Returns the value (processed raw data) of the DICOM tag that matches the supplied tag ID.
-		# The ID may be a tag index, tag name or tag label.
-    def get_value(id)
-      if id == nil
-        add_msg("A tag label, category name or index number must be specified when calling the get_value() method!")
-        return false
+    # Returns the value (processed raw data) of the requested DICOM data element.
+    # Data element may be specified by array position, tag or name.
+    # Options:
+    # :array => true - Allows the query of the value of a tag that occurs more than one time in the
+    #                  DICOM object. Values will be returned in an array with length equal to the number
+    #                  of occurances of the tag. If keyword is not specified, the method returns false in this case.
+    def get_value(element, opts={})
+      opts_array = opts[:array]
+      # As this method is also used internally, we want the possibility of warnings not being raised even if verbose is set to true by the user, to avoid confusion.
+      silent = opts[:silent]
+      value = false
+      # Retrieve array position:
+      pos = get_pos(element)
+      if pos == false
+        add_msg("Warning: Invalid data element provided to method get_value(). Returning false.") unless silent
       else
-        # 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 <= @last_index
-              # The id supplied is a valid position, return its corresponding value:
-              return @values[id]
-            else
-              return false
+        if pos.size > 1
+          if opts_array == true
+            # Retrieve all values into an array:
+            value = []
+            pos.each do |i|
+              value << @values[i]
             end
           else
-            return false
+            add_msg("Warning: Method get_value() does not allow a query which yields multiple array hits. Please use array position instead of tag/name, or use keyword (:array => true). Returning false.") unless silent
           end
         else
-          # We have a valid position, return the value:
-          return @values[pos]
+          value = @values[pos[0]]
         end
       end
+      return value
     end # of method get_value
 
 
-    # Returns the raw data of the DICOM tag that matches the supplied tag ID.
-		# The ID may be a tag index, tag name or tag label.
-    def get_raw(id)
-      if id == nil
-        add_msg("A tag label, category name or index number must be specified when calling the get_raw() method!")
-        return false
+    # Returns the raw data of the requested DICOM data element.
+    # Data element may be specified by array position, tag or name.
+    # Options:
+    # :array => true - Allows the query of the value of a tag that occurs more than one time in the
+    #                  DICOM object. Values will be returned in an array with length equal to the number
+    #                  of occurances of the tag. If keyword is not specified, the method returns false in this case.
+    def get_raw(element, opts={})
+      opts_array = opts[:array]
+      value = false
+      # Retrieve array position:
+      pos = get_pos(element)
+      if pos == false
+        add_msg("Warning: Invalid data element provided to method get_raw(). Returning false.")
       else
-        # 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 <= @last_index
-              # The id supplied is a valid position, return its corresponding value:
-              return @raw[id]
-            else
-              return false
+        if pos.size > 1
+          if opts_array == true
+            # Retrieve all values into an array:
+            value = []
+            pos.each do |i|
+              value << @raw[i]
             end
           else
-            return false
+            add_msg("Warning: Method get_raw() does not allow a query which yields multiple array hits. Please use array position instead of tag/name, or use keyword (:array => true). Returning false.")
           end
         else
-          # We have a valid position, return the value:
-          return @raw[pos]
+          value = @raw[pos[0]]
         end
       end
+      return value
     end # of method get_raw
-    
-    
-    # Returns the position of (possible) parents of the specified tag in the hierarchy structure of the DICOM object.
-    def parents(tag)
-      # Get array position:
-      pos = get_pos(tag)
+
+
+    # Returns the position of (possible) parents of the specified data element in the hierarchy structure of the DICOM object.
+    def parents(element)
+      value = false
+      # Retrieve array position:
+      pos = get_pos(element)
       if pos == false
-        parents = false
+        add_msg("Warning: Invalid data element provided to method parents(). Returning false.")
       else
-        # Extracting first value in array pos:
-        pos = pos[0]
-        # Get level of our tag:
-        level = @levels[pos]
-        # If tag is top level it can obviously have no parents:
-        if level == 0
-          parents = false
+        if pos.length > 1
+          add_msg("Warning: Method parents() does not allow a query which yields multiple array hits. Please use array position instead of tag/name. Returning false.")
         else
-          # Search backwards, and record the position every time we encounter an
-          # upwards change in the level number.
-          parents = Array.new()
-          prev_level = level
-          search_arr = @levels[0..pos-1].reverse
-          search_arr.each_index do |i|
-            if search_arr[i] < prev_level
-              parents += [search_arr.length-i-1]
-              prev_level = search_arr[i]
+          # Proceed to find the value:
+          # Get the level of our element:
+          level = @levels[pos[0]]
+          # Element can obviously only have parents if it is not a top level element:
+          unless level == 0
+            # Search backwards, and record the position every time we encounter an upwards change in the level number.
+            parents = Array.new()
+            prev_level = level
+            search_arr = @levels[0..pos[0]-1].reverse
+            search_arr.each_index do |i|
+              if search_arr[i] < prev_level
+                parents += [search_arr.length-i-1]
+                prev_level = search_arr[i]
+              end
             end
-          end
-          # When tag has several generations of parents, we want its top parent to be first in the returned array:
-          parents = parents.reverse
-        end # of if level == 0
-      end # of if pos == false..else
-      return parents
+            # When the element has several generations of parents, we want its top parent to be first in the returned array:
+            parents = parents.reverse
+            value = parents if parents.length > 0
+          end # of if level == 0
+        end # of if pos.length..else..
+      end
+      return value
     end # of method parents
-    
-    
+
+
     ##############################################
     ####### START OF METHODS FOR PRINTING INFORMATION:######
     ##############################################
 
 
-    # Prints information of all tags stored in the DICOM object.
+    # Prints the information of all elements stored in the DICOM object.
     # This method is kept for backwards compatibility.
     # Instead of calling print_all() you may use print(true) for the same functionality.
     def print_all()
@@ -601,98 +631,86 @@ module DICOM
     end
 
 
-    # Prints the tag information of the specified tags (index, [hierarchy level, tree visualisation,] label, name, type, length, value)
-    # The supplied variable may be a single position, an array of positions, or true - which will make the method print all tags in object.
-    # Tag(s) may be specified by position, label or name.
-    # Options:
-    # :levels => true - will make the method print the level numbers for each tag.
-    # tree => true - will make the method print a tree structure for the tags.
-    # :file => true - will make the method print to file instead of printing to screen.
+    # Prints the information of the specified elements: Index, [hierarchy level, tree visualisation,] tag, name, type, length, value
+    # The supplied variable may be a single position, an array of positions, or true - which will make the method print all elements.
+    # Optional arguments:
+    # :levels => true - method will print the level numbers for each element.
+    # :tree => true -   method will print a tree structure for the elements.
+    # :file => true -    method will print to file instead of printing to screen.
     def print(pos, opts={})
       # Process option values, setting defaults for the ones that are not specified:
       opt_levels = opts[:levels] || false
       opt_tree = opts[:tree] || false
-      opt_file = opts[:file] || false   
-      # Convert to array if number:
+      opt_file = opts[:file] || false
+      # If pos is false, abort, and inform the user:
+      if pos == false
+        add_msg("Warning: Method print() was supplied false instead of a valid position. Aborting print.")
+        return
+      end
       if not pos.is_a?(Array) and pos != true
-        pos_valid = get_pos(pos)
+        # Convert to array if number:
+        pos_valid = [pos]
       elsif pos == true
-        # Create an array of positions which a
-        pos_valid = Array.new(@names.length)
-        # Fill in indices:
-        pos_valid.each_index do |i|
-          pos_valid[i]=i
-        end
-      else   
-        # Check that the supplied array contains valid positions:
-        pos_valid = Array.new()
-        pos.each_index do |i|
-          if pos[i] >= 0 and pos[i] <= @names.length
-            pos_valid += [pos[i]]
-          end
-        end
-      end   
-      # Continue only if we have valid positions:
-      if pos_valid == false
-        return
-      elsif pos_valid.size == 0
-        return
+        # Create a complete array of indices:
+        pos_valid = Array.new(@names.length) {|i| i}
+      else
+        # Use the supplied array of numbers:
+        pos_valid = pos
       end
-      # We have valid positions and are ready to start process the tags:
       # Extract the information to be printed from the object arrays:
       indices = Array.new()
       levels = Array.new()
-      labels = Array.new()
+      tags = Array.new()
       names = Array.new()
       types = Array.new()
       lengths = Array.new()
       values = Array.new()
       # There may be a more elegant way to do this.
       pos_valid.each do |pos|
-        labels += [@labels[pos]]
+        tags += [@tags[pos]]
         levels += [@levels[pos]]
         names += [@names[pos]]
         types += [@types[pos]]
         lengths += [@lengths[pos].to_s]
         values += [@values[pos].to_s]
-      end   
+      end
       # We have collected the data that is to be printed, now we need to do some string manipulation if hierarchy is to be displayed:
       if opt_tree
         # Tree structure requested.
         front_symbol = "| "
         tree_symbol = "|_"
-        labels.each_index do |i|
+        tags.each_index do |i|
           if levels[i] != 0
-            labels[i] = front_symbol*(levels[i]-1) + tree_symbol + labels[i]
+            tags[i] = front_symbol*(levels[i]-1) + tree_symbol + tags[i]
           end
         end
       end
       # Extract the string lengths which are needed to make the formatting nice:
-      label_lengths = Array.new()
+      tag_lengths = Array.new()
       name_lengths = Array.new()
       type_lengths = Array.new()
       length_lengths = Array.new()
       names.each_index do |i|
-        label_lengths[i] = labels[i].length
+        tag_lengths[i] = tags[i].length
         name_lengths[i] = names[i].length
         type_lengths[i] = types[i].length
         length_lengths[i] = lengths[i].to_s.length
       end
       # To give the printed output a nice format we need to check the string lengths of some of these arrays:
       index_maxL = pos_valid.max.to_s.length
-      label_maxL = label_lengths.max
+      tag_maxL = tag_lengths.max
       name_maxL = name_lengths.max
       type_maxL = type_lengths.max
       length_maxL = length_lengths.max
-      # Construct the strings, one for each line of output, where each line contain the information of one tag:
-      tags = Array.new()    
-      # Start of loop which formats the tags:
+      # Construct the strings, one for each line of output, where each line contain the information of one data element:
+      elements = Array.new()
+      # Start of loop which formats the element data:
       # (This loop is what consumes most of the computing time of this method)
-      labels.each_index do |i|
+      tags.each_index do |i|
         # Configure empty spaces:
         s = " "
         f0 = " "*(index_maxL-pos_valid[i].to_s.length)
-        f2 = " "*(label_maxL-labels[i].length+1)
+        f2 = " "*(tag_maxL-tags[i].length+1)
         f3 = " "*(name_maxL-names[i].length+1)
         f4 = " "*(type_maxL-types[i].length+1)
         f5 = " "*(length_maxL-lengths[i].to_s.length)
@@ -708,23 +726,23 @@ module DICOM
         else
           value = (values[i])
         end
-        # Insert descriptive text for tags that hold binary data:
+        # Insert descriptive text for elements that hold binary data:
         case types[i]
           when "OW","OB","UN"
             value = "(Binary Data)"
           when "SQ","()"
-            value = "(Encapsulated Elements)"            
+            value = "(Encapsulated Elements)"
         end
-        tags += [f0 + pos_valid[i].to_s + s + lev + s + labels[i] + f2 + names[i] + f3 + types[i] + f4 + f5 + lengths[i].to_s + s + s + value.rstrip]
+        elements += [f0 + pos_valid[i].to_s + s + lev + s + tags[i] + f2 + names[i] + f3 + types[i] + f4 + f5 + lengths[i].to_s + s + s + value.rstrip]
       end
       # Print to either screen or file, depending on what the user requested:
       if opt_file
-        print_file(tags)
+        print_file(elements)
       else
-        print_screen(tags)
-      end # of labels.each do |i|
+        print_screen(elements)
+      end # of tags.each do |i|
     end # of method print
-    
+
 
     # Prints the key structural properties of the DICOM file.
     def print_properties()
@@ -775,14 +793,14 @@ module DICOM
       end
       puts "-------------------------------"
     end # of method print_properties
-    
-    
+
+
     ####################################################
     ### START OF METHODS FOR WRITING INFORMATION TO THE DICOM OBJECT:#
     ####################################################
-    
-    
-    # Reads binary information from file and inserts it in the pixel data tag:
+
+
+    # Reads binary information from file and inserts it in the pixel data element:
     def set_image_file(file)
       # Try to read file:
       begin
@@ -791,104 +809,99 @@ module DICOM
       rescue
         # Reading file was not successful. Register an error message.
         add_msg("Reading specified file was not successful for some reason. No data has been added.")
+        return
       end
       if bin.length > 0
-        pos = @labels.index("7FE0,0010")
-        # Modify tag:
-        set_value(bin, :label => "7FE0,0010", :create => true, :bin => true)
+        pos = @tags.index("7FE0,0010")
+        # Modify element:
+        set_value(bin, "7FE0,0010", :create => true, :bin => true)
       else
         add_msg("Content of file is of zero length. Nothing to store.")
       end # of if bin.length > 0
     end # of method set_image_file
-    
-    
-    # Transfers pixel data from a RMagick object to the pixel data tag:
+
+
+    # Transfers pixel data from a RMagick object to the pixel data element:
     def set_image_magick(magick_obj)
       # Export the RMagick object to a standard Ruby array of numbers:
       pixel_array = magick_obj.export_pixels(x=0, y=0, columns=magick_obj.columns, rows=magick_obj.rows, map="I")
       # Encode this array using the standard class method:
-      set_value(pixel_array, :label => "7FE0,0010", :create => true)
+      set_value(pixel_array, "7FE0,0010", :create => true)
     end
-    
-    
-    # Removes a tag from the DICOM object:
-    def remove_tag(tag)
-      pos = get_pos(tag)
-      if pos != nil
-        # Extract first array number:
-        pos = pos[0]
-        # Update group length:
-        if @labels[pos][5..8] != "0000"
-          change = @lengths[pos]
-          vr = @types[pos]
-          update_group_length(pos, vr, change, -1)
+
+
+    # Removes an element from the DICOM object:
+    def remove(element)
+      pos = get_pos(element)
+      if pos != false
+        if pos.length > 1
+          add_msg("Warning: Method remove() does not allow an element query which yields multiple array hits. Please use array position instead of tag/name. Value NOT removed.")
+        else
+          # Extract first array number:
+          pos = pos[0]
+          # Update group length:
+          if @tags[pos][5..8] != "0000"
+            change = @lengths[pos]
+            vr = @types[pos]
+            update_group_length(pos, vr, change, -1)
+          end
+          # Remove entry from arrays:
+          @tags.delete_at(pos)
+          @levels.delete_at(pos)
+          @names.delete_at(pos)
+          @types.delete_at(pos)
+          @lengths.delete_at(pos)
+          @values.delete_at(pos)
+          @raw.delete_at(pos)
         end
-        # Remove entry from arrays:
-        @labels.delete_at(pos)
-        @levels.delete_at(pos)
-        @names.delete_at(pos)
-        @types.delete_at(pos)
-        @lengths.delete_at(pos)
-        @values.delete_at(pos)
-        @raw.delete_at(pos)
       else
-        add_msg("Tag #{tag} not found in DICOM object.")
+        add_msg("Warning: The data element #{element} could not be found in the DICOM object. Method remove() has no data element to remove.")
       end
     end
-    
-    
-    # Sets the value of a tag, by modifying an existing tag or creating a new tag.
-    # If the supplied value is not binary, it will attempt to encode it to binary itself.
-    def set_value(value, opts={})
+
+
+    # Sets the value of a data element by modifying an existing element or creating a new one.
+    # If the supplied value is not binary, it will attempt to encode the value to binary itself.
+    def set_value(value, element, opts={})
       # Options:
-      label = opts[:label]
-      pos = opts[:pos]
-      create = opts[:create] # =false means no tag creation
+      create = opts[:create] # =false means no element creation
       bin = opts[:bin] # =true means value already encoded
-      # Abort if neither label nor position has been specified:
-      if label == nil and pos == nil
-        add_msg("Valid position not provided; can not modify or create tag. Please use keyword :pos or :label to specify.")
-        return
-      end
-      # If position is specified, check that it is valid.
-      # If label is specified, check that it doesnt correspond to multiple labels:
-      if pos != nil
-        unless pos >= 0 and pos <= @labels.length
-          # This is not a valid position:
-          pos = nil
-        end
-      else
-        pos = get_pos(label)
-        if pos == false
-          pos = nil
-        elsif pos.size > 1
-          pos = 'abort'
-          add_msg("The supplied label is found at multiple locations in the DICOM object. Will not update.")
-        end
-      end # of if pos != nil
-      # Create or modify?
-      if create == false
-        # User wants modification only. Proceed only if we have a valid position:
-        unless pos == nil
-          # Modify tag:
-          modify_tag(value, :bin => bin, :pos => pos)
+      # Retrieve array position:
+      pos = get_pos(element)
+      # We do not support changing multiple data elements:
+      if pos.is_a?(Array)
+        if pos.length > 1
+          add_msg("Warning: Method set_value() does not allow an element query which yields multiple array hits. Please use array position instead of tag/name. Value NOT saved.")
+          return
         end
+      end
+      if pos == false and create == false
+        # Since user has requested an element shall only be updated, we can not do so as the element position is not valid:
+        add_msg("Warning: Invalid data element provided to method set_value(). Value NOT updated.")
+      elsif create == false
+        # Modify element:
+        modify_element(value, pos[0], :bin => bin)
       else
-        # User wants to create (or modify if present). Only abort if multiple hits have been found.
-        unless pos == 'abort'
-          if pos == nil
-            # As we wish to create new tag, we need to find out where to insert it in the tag array:
-            # We will do this by finding the last array position of the last tag that will stay in front of this tag.
-            if @labels.size > 0
+        # User wants to create an element (or modify it if it is already present).
+        unless pos == false
+          # The data element already exist, so we modify instead of creating:
+          modify_element(value, pos[0], :bin => bin)
+        else
+          # We need to create element:
+          tag = @lib.get_tag(element)
+          if tag == false
+            add_msg("Warning: Method set_value() could not create data element, either because data element name was not recognized in the library, or data element tag is invalid (Expected format of tags is 'GGGG,EEEE').")
+          else
+            # As we wish to create a new data element, we need to find out where to insert it in the element arrays:
+            # We will do this by finding the last array position of the last element that will (alphabetically/numerically) stay in front of this element.
+            if @tags.size > 0
               # Search the array:
               index = -1
               quit = false
               while quit != true do
-                if index+1 >= @labels.length # We have reached end of array.
+                if index+1 >= @tags.length # We have reached end of array.
                   quit = true
-                #elsif index+1 == @labels.length
-                  #quit = true
-                elsif label < @labels[index+1] # We are past the correct position.
+                elsif tag < @tags[index+1] # We are past the correct position.
                   quit = true
                 else # Increase index in anticipation of a 'hit'.
                   index += 1
@@ -898,20 +911,11 @@ module DICOM
               # We are dealing with an empty DICOM object:
               index = nil
             end
-            # Before we allow tag creation, do a simple check that the label seems valid:
-            if label.length == 9
-              # Create new tag:
-              create_tag(value, :bin => bin, :label => label, :lastpos => index)
-            else
-              # Label did not pass our check:
-              add_msg("The label you specified (#{label}) does not seem valid. Please use the format 'GGGG,EEEE'.")
-            end
-          else
-            # Modify existing:
-            modify_tag(value, :bin => bin, :pos => pos)
-          end
-        end
-      end # of if create == false
+            # The necessary information is gathered; create new data element:
+            create_element(value, tag, index, :bin => bin)
+          end # of if tag ==..else..
+        end # of unless pos ==..else..
+      end # of if pos ==..and create ==..else..
     end # of method set_value
 
 
@@ -929,28 +933,26 @@ module DICOM
       if (msg.is_a? String)
         msg=[msg]
       end
-      @msg += msg
+      @errors += msg
     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 
+        Array(x).pack("N*") => true   #:big
       }
-      return endian_type[Array(x).pack("L*")] 
+      return endian_type[Array(x).pack("L*")]
     end
-    
-    
-    # Creates a new tag:
-    def create_tag(value, opts={})
+
+
+    # Creates a new data element:
+    def create_element(value, tag, last_pos, opts={})
       bin_only = opts[:bin]
-      label = opts[:label]
-      lastpos = opts[:lastpos]
       # Fetch the VR:
-      info = @lib.get_name_vr(label)
+      info = @lib.get_name_vr(tag)
       vr = info[1]
       name = info[0]
       # Encode binary (if a binary is not provided):
@@ -963,67 +965,64 @@ module DICOM
           # Encode:
           bin = encode(value, vr)
         else
-          add_msg("Error. Unable to encode tag value of unknown type!")
+          add_msg("Error. Unable to encode data element value of unknown type (Value Representation)!")
         end
       end
-      # Put this tag information into the arrays:
+      # Put the information of this data element into the arrays:
       if bin
-        #if bin.length > 0
-          # 4 different scenarios: Array is empty, or: tag is put in front, inside array, or at end of array:
-          if lastpos == nil
-            # We have empty DICOM object:
-            @labels = [label]
-            @levels = [0]
-            @names = [name]
-            @types = [vr]
-            @lengths = [bin.length]
-            @values = [value]
-            @raw = [bin]
-          elsif lastpos == -1
-            # Insert in front of arrays:
-            @labels = [label] + @labels
-            @levels = [0] + @levels # NB! No support for hierarchy at this time!
-            @names = [name] + @names
-            @types = [vr] + @types
-            @lengths = [bin.length] + @lengths
-            @values = [value] + @values
-            @raw = [bin] + @raw
-          elsif lastpos == @labels.length-1
-            # Insert at end arrays:
-            @labels = @labels + [label]
-            @levels = @levels + [0] # Defaulting to level = 0
-            @names = @names + [name]
-            @types = @types + [vr]
-            @lengths = @lengths + [bin.length]
-            @values = @values + [value]
-            @raw = @raw + [bin]
-          else
-            # Insert somewhere inside the array:
-            @labels = @labels[0..lastpos] + [label] + @labels[(lastpos+1)..(@labels.length-1)]
-            @levels = @levels[0..lastpos] + [0] + @levels[(lastpos+1)..(@levels.length-1)] # Defaulting to level = 0
-            @names = @names[0..lastpos] + [name] + @names[(lastpos+1)..(@names.length-1)]
-            @types = @types[0..lastpos] + [vr] + @types[(lastpos+1)..(@types.length-1)]
-            @lengths = @lengths[0..lastpos] + [bin.length] + @lengths[(lastpos+1)..(@lengths.length-1)]
-            @values = @values[0..lastpos] + [value] + @values[(lastpos+1)..(@values.length-1)]
-            @raw = @raw[0..lastpos] + [bin] + @raw[(lastpos+1)..(@raw.length-1)]
-          end
-          # Update last index variable as we have added to our arrays:
-          @last_index += 1
-          # Update group length (as long as it was not a group length tag that was created):
-          pos = @labels.index(label)
-          if @labels[pos][5..8] != "0000"
-            change = bin.length
-            update_group_length(pos, vr, change, 1)
-          end
-        #else
-          #add_msg("Binary does not have a positive length, nothing to save.")
-        #end # of if bin.length > 0
+        # 4 different scenarios: Array is empty, or: element is put in front, inside array, or at end of array:
+        # NB! No support for hierarchy at this time! Defaulting to level = 0.
+        if last_pos == nil
+          # We have empty DICOM object:
+          @tags = [tag]
+          @levels = [0]
+          @names = [name]
+          @types = [vr]
+          @lengths = [bin.length]
+          @values = [value]
+          @raw = [bin]
+        elsif last_pos == -1
+          # Insert in front of arrays:
+          @tags = [tag] + @tags
+          @levels = [0] + @levels
+          @names = [name] + @names
+          @types = [vr] + @types
+          @lengths = [bin.length] + @lengths
+          @values = [value] + @values
+          @raw = [bin] + @raw
+        elsif last_pos == @tags.length-1
+          # Insert at end arrays:
+          @tags = @tags + [tag]
+          @levels = @levels + [0]
+          @names = @names + [name]
+          @types = @types + [vr]
+          @lengths = @lengths + [bin.length]
+          @values = @values + [value]
+          @raw = @raw + [bin]
+        else
+          # Insert somewhere inside the array:
+          @tags = @tags[0..last_pos] + [tag] + @tags[(last_pos+1)..(@tags.length-1)]
+          @levels = @levels[0..last_pos] + [0] + @levels[(last_pos+1)..(@levels.length-1)]
+          @names = @names[0..last_pos] + [name] + @names[(last_pos+1)..(@names.length-1)]
+          @types = @types[0..last_pos] + [vr] + @types[(last_pos+1)..(@types.length-1)]
+          @lengths = @lengths[0..last_pos] + [bin.length] + @lengths[(last_pos+1)..(@lengths.length-1)]
+          @values = @values[0..last_pos] + [value] + @values[(last_pos+1)..(@values.length-1)]
+          @raw = @raw[0..last_pos] + [bin] + @raw[(last_pos+1)..(@raw.length-1)]
+        end
+        # Update last index variable as we have added to our arrays:
+        @last_index += 1
+        # Update group length (as long as it was not a group length element that was created):
+        pos = @tags.index(tag)
+        if @tags[pos][5..8] != "0000"
+          change = bin.length
+          update_group_length(pos, vr, change, 1)
+        end
       else
         add_msg("Binary is nil. Nothing to save.")
       end
-    end # of method create_tag
-    
-    
+    end # of method create_element
+
+
     # Encodes a value to binary (used for inserting values to a DICOM object).
     def encode(value, vr)
       # Our value needs to be inside an array to be encoded:
@@ -1042,7 +1041,7 @@ module DICOM
           bin = value.pack(@fs)
         when "FD"
           bin = value.pack(@fd)
-        when "AT" # (tag label - assumes it has the format GGGGEEEE (no comma separation))
+        when "AT" # (Data element tag: Assume it has the format GGGGEEEE (no comma separation))
           # Encode letter pairs indexes in following order 10 3 2:
           # NB! This may not be encoded correctly on Big Endian files or computers.
           old_format=value[0]
@@ -1051,6 +1050,9 @@ module DICOM
 
         # We have a number of VRs that are encoded as string:
         when 'AE','AS','CS','DA','DS','DT','IS','LO','LT','PN','SH','ST','TM','UI','UT'
+          # In case we are dealing with a number string element, the supplied value might be a number
+          # instead of a string, and as such, we convert to string just to make sure this will work nicely:
+          value[0] = value[0].to_s
           # Odd/even test (num[0]=1 if num is odd):
           if value[0].length[0] == 1
             # Odd (add a zero byte):
@@ -1064,8 +1066,8 @@ module DICOM
           # What bit depth to use when encoding the pixel data?
           bit_depth = get_value("0028,0100")
           if bit_depth == false
-            # Tag not specified:
-            add_msg("Attempted to encode pixel data, but bit depth tag is missing (0028,0100).")
+            # Data element not specified:
+            add_msg("Attempted to encode pixel data, but 'Bit Depth' data element is missing (0028,0100).")
           else
             # 8,12 or 16 bits?
             case bit_depth
@@ -1082,16 +1084,14 @@ module DICOM
             end # of case bit_depth
           end # of if bit_depth..else..
         else # Unsupported VR:
-          add_msg("Tag type #{vr} does not have a dedicated encoding option assigned. Please contact author.")
+          add_msg("Element type #{vr} does not have a dedicated encoding option assigned. Please contact author.")
       end # of case vr
       return bin
     end # of method encode
-    
-    # Modifies existing tag:
-    def modify_tag(value, opts={})
+
+    # Modifies existing data element:
+    def modify_element(value, pos, opts={})
       bin_only = opts[:bin]
-      pos = opts[:pos]
-      pos = pos[0] if pos.is_a?(Array)
       # Fetch the VR and old length:
       vr = @types[pos]
       old_length = @lengths[pos]
@@ -1105,54 +1105,50 @@ module DICOM
           # Encode:
           bin = encode(value, vr)
         else
-          add_msg("Error. Unable to encode tag value of unknown type!")
+          add_msg("Error. Unable to encode data element value of unknown type (Value Representation)!")
         end
       end
       # Update the arrays with this new information:
       if bin
-        #if bin.length > 0
-          # Replace array entries for this tag:
-          #@types[pos] = vr # for the time being there is no logic for updating type.
-          @lengths[pos] = bin.length
-          @values[pos] = value
-          @raw[pos] = bin
-          # Update group length (as long as it was not the group length that was modified):
-          if @labels[pos][5..8] != "0000"
-            change = bin.length - old_length
-            update_group_length(pos, vr, change, 0) 
-          end
-        #else
-          #add_msg("Binary does not have a positive length, nothing to save.")
-        #end
+        # Replace array entries for this element:
+        #@types[pos] = vr # for the time being there is no logic for updating type.
+        @lengths[pos] = bin.length
+        @values[pos] = value
+        @raw[pos] = bin
+        # Update group length (as long as it was not the group length that was modified):
+        if @tags[pos][5..8] != "0000"
+          change = bin.length - old_length
+          update_group_length(pos, vr, change, 0)
+        end
       else
         add_msg("Binary is nil. Nothing to save.")
       end
-    end # of method modify_tag
+    end # of method modify_element
 
 
-    # Prints the selected tags to an ascii text file.
+    # Prints the selected elements to an ascii text file.
     # The text file will be saved in the folder of the original DICOM file,
     # with the original file name plus a .txt extension.
-    def print_file(tags)
+    def print_file(elements)
       File.open( @file + '.txt', 'w' ) do |output|
-        tags.each do | line |
+        elements.each do | line |
           output.print line + "\n"
         end
       end
     end
 
- 
-    # Prints the selected tags to screen.
-    def print_screen(tags)
-      tags.each do | tag |
-        puts tag
+
+    # Prints the selected elements to screen.
+    def print_screen(elements)
+      elements.each do |element|
+        puts element
       end
     end
-    
-    
+
+
     # Sets the modality variable of the current DICOM object, by querying the library with the object's SOP Class UID.
     def set_modality()
-      value = get_value("0008,0016")
+      value = get_value("0008,0016", :silent => true)
       if value == false
         @modality = "Not specified"
       else
@@ -1160,8 +1156,8 @@ module DICOM
         @modality = modality
       end
     end
-    
-    
+
+
     # Sets the format strings that will be used for packing/unpacking numbers depending on endianness of file/system.
     def set_format_strings(file_endian=@file_endian)
       if @file_endian == @sys_endian
@@ -1186,50 +1182,50 @@ module DICOM
         @fd = "G*"
       end
     end
-    
-    
-    # Updates the group length value when a tag has been updated, created or removed:
-    # Variable change holds the change in value length for the updated tag.
-    # (Change should be positive when a tag is removed - it will only be negative when editing a tag to a shorter value)
-    # Variable existance is -1 if tag has been removed, +1 if tag has been added and 0 if it has been updated.
+
+
+    # Updates the group length value when a data element has been updated, created or removed:
+    # The variable change holds the change in value length for the updated data element.
+    # (Change should be positive when a data element is removed - it will only be negative when editing an element to a shorter value)
+    # The variable existance is -1 if data element has been removed, +1 if element has been added and 0 if it has been updated.
     # (Perhaps in the future this functionality might be moved to the DWrite class, it might give an easier implementation)
     def update_group_length(pos, type, change, existance)
       # Find position of relevant group length (if it exists):
-      gl_pos = @labels.index(@labels[pos][0..4] + "0000")
+      gl_pos = @tags.index(@tags[pos][0..4] + "0000")
       existance = 0 if existance == nil
       # If it exists, calculate change:
       if gl_pos
         if existance == 0
-          # Tag has only been updated, so we only need to think about value change:
+          # Element has only been updated, so we only need to think about value change:
           value = @values[gl_pos] + change
         else
-          # Tag has either been created or removed. This means we need to calculate the length of its other parts.
+          # Element has either been created or removed. This means we need to calculate the length of its other parts.
           if @explicit
             # In the explicit scenario it is slightly complex to determine this value:
-            tag_length = 0
+            element_length = 0
             # VR?:
-            unless @labels[pos] == "FFFE,E000" or @labels[pos] == "FFFE,E00D" or @labels[pos] == "FFFE,E0DD"
-              tag_length += 2
+            unless @tags[pos] == "FFFE,E000" or @tags[pos] == "FFFE,E00D" or @tags[pos] == "FFFE,E0DD"
+              element_length += 2
             end
             # Length value:
             case @types[pos]
               when "OB","OW","SQ","UN"
-                if pos > @labels.index("7FE0,0010").to_i and @labels.index("7FE0,0010").to_i != 0
-                  tag_length += 4
+                if pos > @tags.index("7FE0,0010").to_i and @tags.index("7FE0,0010").to_i != 0
+                  element_length += 4
                 else
-                  tag_length += 6
+                  element_length += 6
                 end
               when "()"
-                tag_length += 4
+                element_length += 4
               else
-                tag_length += 2
+                element_length += 2
             end # of case
           else
             # In the implicit scenario it is easier:
-            tag_length = 4
+            element_length = 4
           end
           # Update group length for creation/deletion scenario:
-          change = (4 + tag_length + change) * existance
+          change = (4 + element_length + change) * existance
           value = @values[gl_pos] + change
         end
         # Write the new Group Length value:
@@ -1243,4 +1239,4 @@ module DICOM
 
 
   end # End of class
-end # End of module
+end # End of module