dicom 0.3 → 0.4

data/CHANGELOG

@@ -1,3 +1,27 @@
+=0.4
+
+=== 3rd February, 2009
+
+* Change of syntax: Keywords are now supplied as hash.
+* Method below() renamed to children().
+* Added method parents() which returns the position of all items/sequences that are the parent of
+  the specified tag. This method is only relevant for DICOM tags that exist inside a hierarchy.
+* Simplified the code in class Dictionary: load time is ~ 40 times faster!
+* Improved the code in class DRead: average read time is reduced by ~ 15 %.
+* Improved support for Big Endian DICOM files.
+* Added support for the "FL" (floating point single) value representation.
+* Fixed a small bug with tag 0028,3006 in Dictionary.
+* New method image_to_file() which makes it even easier than before to dump the DICOM pixel data to file.
+* Introducing DWrite class which enables writing DICOM objects to file.
+* Added several methods in DObject class to take advantage of write capability:
+  remove_tag()
+  set_value()
+  set_image_magick()
+  set_image_file()
+  write_file()
+* Introducing the Anonymizer class, which takes advantage of the new write capability in Ruby DICOM
+  to offer a fairly powerful and customizable tool for anonymizing your DICOM files.
+
 = 0.3
 
 === 12th October, 2008
@@ -10,6 +34,8 @@
 * Method print() is able to print to file as well. The text file will be put in the same folder as the DICOM file.
 * New method below(), which lets you specify a sequence or item, and this method will return the position
   of all tags contained in this sequence/item.
+* Method print_properties() have been updated to display more information about the DICOM object.
+
 
 = 0.2
 
@@ -43,7 +69,7 @@ Known issues:
 * 12 bit image data not supported
 * Color images not supported in NArray and RMagick retrieve methods
 * Unpacking compressed image data has basic support but is not properly tested yet.
-* Reading Big Endian files probably has some issues
-* Reading Little Endian files on a Big Endian system probably has issues as well
-* Reading of multiple frame image data is not particularly robust at this time
-* Retrieving images when file contains two or more unrelated images is not handled correctly
+* Reading Big Endian has basic, but not full, support.
+* Reading on a Big Endian system is not tested.
+* Reading of multiple frame image data to RMagick does not work in all cases.
+* Retrieving images when file contains two or more unrelated images may not be handled correctly.

data/DOCUMENTATION

@@ -1,11 +1,14 @@
-DICOM is a small library for reading DICOM files. It is written completely in Ruby and has no external dependencies.
+DICOM is a small library for reading, editing and writing DICOM files.
+It is written completely in Ruby and has no external dependencies.
 
-Copyright 2008 Christoffer Lervåg (chris.lervag@gmail.com)
+Copyright 2008-2009 Christoffer Lervåg (chris.lervag [@nospam] @gmail.com)
 
 INSTALLATION
 
 gem install dicom
 
+*************************************************************************
+
 DOCUMENTATION
 
 CLASS DLibrary
@@ -19,32 +22,47 @@ PUBLIC CLASS METHODS
 		because you can save time by loading the library one time at startup instead of
 		having the library being loaded for each DICOM file being read.
 		Example:
-			lib = DLibrary.new()
+			myLib = DICOM::DLibrary.new
 
 
 CLASS DObject
 
 PUBLIC CLASS METHODS
 
-	new(filename, *options)
+	new(filename, options={})
 
 		Initialize a new DICOM object.
-		Example 1 (The simple way):
+		Example 1: (The simplest way)
 			require 'dicom'
 			obj = DICOM::DObject.new("myFile.dcm")
-		Example 2 (Using a pre-loaded library to speed up reading when reading multiple files):
-			obj = DICOM::DObject.new("myFile.dcm", verbose=false, library=lib)
+		Example 2: (Using a pre-loaded library to speed up reading when reading multiple files)
+			obj = DICOM::DObject.new("myFile.dcm", :verbose => false, :lib => myLib)
+		Example 3: (Open an empty DICOM object)
+			obj = DICOM::DObject.new(nil)
+
+ACCESSORS
+	:read_success
+		A boolean that is true if DICOM object was read successfully, and false if not.
+	:write_success
+		A boolean that is true if DICOM object was written successfully, and false if not.
+	:modality
+		A string which holds the description of the modality of the DICOM object that has been read.
+		Example of use:
+			obj = DICOM::DObject.new("myFile.dcm")
+			if obj.read_success
+			  puts obj.modality
+			end
 
 PUBLIC INSTANCE METHODS
 
-	below(id, *options)
+	children(id, options={})
 		Returns the positions of all tags inside the hierarchy of a sequence or an item.
 		This is useful if you later want to get the position(s) of a certain tag,
 		restricted to the positions inside the given sequence or item.
 		Example 1: (Return all tag positions that is contained in the following sequence)
-			pos = obj.below("3006,0082")
+			pos = obj.children("3006,0082")
 		Example 2: (Return all tag positions that is contained only directly beneath the following sequence)
-			pos = obj.below("3006,0082", next_only=true)
+			pos = obj.children("3006,0082", :next_only => true)
 
 	get_frames()
 		Returns the number of frames present in the image data in the DICOM file.
@@ -70,12 +88,13 @@ PUBLIC INSTANCE METHODS
 	get_image_pos()
 		Returns the index(es) of the tag(s) that contain image data.
 
-	get_pos(id, *options)
+	get_pos(id, options={})
 		Returns the index(es) of the tag(s) in the DICOM file that match the supplied tag ID.
 		Example 1: (Find all occurences of the specified tag in the object)
 			pos = obj.get_pos("3006,0080")
 		Example 2: (Find all occurences of the specified tag inside the specified sequence)
-			pos = obj.get_pos("3006,0080", obj.below("3006,0082"))
+			selection = obj.children("3006,0082")
+			pos = obj.get_pos("3006,0080", :array => selection)
 
 	get_raw(id)
 		Returns the raw data of the DICOM tag that matches the supplied tag ID.
@@ -85,14 +104,24 @@ PUBLIC INSTANCE METHODS
 		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.
 
-	print(id, *options)
+	image_to_file(file)
+		Dumps the pixel data of the DICOM object directly to the specified file.
+		This is useful if you wish to extract this data to process it with another program.
+
+	parents(id)
+		Returns the positions of all parents of this tag in the hierarchy.
+		This is useful if you want to know the position of the items or sequence tags that 'hold' your tag.
+		Example:
+			pos = obj.parents("300C,0006")
+
+	print(id, options={})
 		Prints the information of one or many tag(s):
 			(index, [hierarchy level,] label, name, type, length, value)
 		The method can print to both screen or to a text file. If print to file is chosen,
 		the text file will be put in the folder of the original DICOM file with a '.txt' extension.
 		The ID may be a tag name, label or position, or it might be an array of positions.
 		Example 1: (Print all tags to file, with both tree visualization and level numbers)
-			obj.print(true, levels=true, tree=true, file=true)
+			obj.print(true, :levels => true, :tree => true, :file => true)
 		Example 2: (Print an array of tags to screen, no level or tree visualization)
 			obj.print([4,5,6])
 
@@ -101,3 +130,95 @@ PUBLIC INSTANCE METHODS
 
 	print_properties()
 		Prints the key structural properties of the DICOM file to the screen.
+
+	remove_tag(tag)
+		Removes the specified tag from the DICOM object. You can use this method
+		if you are editing a DICOM object and wants to get rid of some tags.
+
+	set_value(value, options={})
+		This method can be used both to edit an existing tag, or to create new tags in your DICOM object.
+		Example 1: (Edit patient name)
+			obj.set_value("Anonymous", :label => "0010,0010", :create => false)
+		Example 2: (Insert binary data for a specific tag)
+			obj.set_value(data, :pos => 52, :bin => true, :create => false)
+
+	set_image_magick(object)
+		Inserts a RMagick image object to the pixel data tag of your DICOM object.
+
+	set_image_file(file)
+		Inserts the binary content of a file to the Pixel Data tag in your DICOM object.
+		This can be useful if you have processed some image data using a custom program
+		and just wants to put that data back into a DICOM object.
+
+	write_file(file)
+		Writes the DICOM object to the specified file.
+		Example:
+			obj.write_file(myPath + "test_file.dcm")
+
+
+CLASS Anonymizer
+
+PUBLIC CLASS METHODS
+
+	new()
+		Initialize a new Anonymizer instance.
+		Example:
+			a = DICOM::Anonymizer.new
+
+ACCESSORS
+	:blank
+		A boolean that you can set if you want to all anonymization tags to be blank
+		instead of having some generic value.
+	:enumeration
+		A boolean that if set will make the script set enumerated values on anonymized tags,
+		such that you are able to separate the DICOM files of unique individuals after anonymization.
+		Example of fictious result:
+			"Joe Sixpack" => "Person1" and "Joe Schmoe" => "Person2"
+	:identity_file
+		If you request enumeration, you can specify an identity file which will enable you to reidentify
+		the anonymized DICOM files at a later stage. The relationship between original names and
+		enumerated values is stored in a text file which you can keep for yourself, while handing out
+		the anonymized DICOM files to a third party.
+
+	:write_path
+		You may set a different path for where the anonymized DICOM files will be stored. If this
+		value is not set, the Anonymizer script will overwrite the old DICOM files.
+		Example:
+			a.write_path = "C:/temp/"
+
+PUBLIC INSTANCE METHODS
+
+	add_folder(path)
+		Adds a folder who's files (including all files in subfolders) will be anonymized.
+		Example:
+			a.add_folder("/home/dicom")
+
+	add_exception(path)
+		Adds a folder who's files (including all files in its subfolders) will be excluded from anonymization.
+
+	add_tag(tag, options={})
+		Adds a tag to the list of tags that will be anonymized. As options you can specify value to be used
+		and whether the tag should be included for enumeration if this feature has been activated.
+		Example:
+			a.add_tag("0010,0010, :value => "MrAnonymous", :enum => true)
+
+	change_enum(tag, status)
+		Sets enumeration status for a specific tag. Status = true means the selected tag will get
+		an enumerated value, false means it will not.
+
+	execute(verbose)
+		Executes the anonymization process. Run this method when you are finished choosing all your settings.
+		Verbose (=true/false) will apply to the read/update/write process that takes place in DObject, and not
+		the messages of the Anonymization script itself.
+
+	print()
+		Prints the list of tags that have been selected for anonymization, along with the values
+		that the original tags will be replaced with. If enumeration is selected, this method will also
+		print which tags have been selected for enumeration.
+
+	remove_tag(tag)
+		Removes a tag from the list of tags that will be anonymized.
+		Example:
+			a.remove_tag("0010,0010")
+
+

data/README

@@ -4,7 +4,7 @@ RUBY DICOM
 SUMMARY
 --------
 
-This is a fairly basic library for reading DICOM files in Ruby. Digital Imaging and Communications in Medicine (DICOM) is a standard for handling, storing, printing, and transmitting information in medical imaging. It includes a file format definition and a network communications protocol. The library currently only supports reading of the file format.
+This is a fairly basic library for reading DICOM files in Ruby. Digital Imaging and Communications in Medicine (DICOM) is a standard for handling, storing, printing, and transmitting information in medical imaging. It includes a file format definition and a network communications protocol. The library supports reading, editing and writing the file format.
 
 BASIC USAGE
 -----------
@@ -15,7 +15,7 @@ dcm = DICOM::DObject.new("myFile.dcm")
 # Display some key information about the file:
 dcm.print_properties()
 # Print all tags to screen:
-dcm.print_all()
+dcm.print(true)
 # Retrieve a tag value:
 name = dcm.get_value("0010.0010")
 # Retrieve pixel data:
@@ -25,12 +25,21 @@ image = dcm.get_image_magick()
 image[0].display
 # Load pixel data in a NArray object and display on screen:
 image = dcm.get_image_narray()
-NImage.show image[0,true,true]
+NImage.show image[0,true,true]
+
+Tip:
+When playing around with Ruby DICOM in irb, you may be annoyed
+with all the information that is printed to screen, regardless
+if you have specified verbose as false. This is because in irb
+every variable loaded in the program is automatically printed.
+A hack to avoid this effect is to append ";0" after a command.
+Example:
+dcm = DICOM::DObject.new("myFile.dcm") ;0
   
 COPYRIGHT
 ---------
 
-Copyright 2008 Christoffer Lervåg
+Copyright 2008-2009 Christoffer Lervåg
 
 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
@@ -56,6 +65,6 @@ Location:
 Oslo, Norway
 
 Email:
-chris.lervag @nospam @gmail.com
+chris.lervag [@nospam] @gmail.com
 Please don't hesitate to email me if have any thoughts on this project!
 

data/lib/Anonymizer.rb

@@ -0,0 +1,433 @@
+#    Copyright 2008-2009 Christoffer Lerv�g
+module DICOM
+
+  # Class for anonymizing DICOM files:
+  # A good resource on this topic (report from the DICOM standards committee, work group 18):
+  # ftp://medical.nema.org/medical/dicom/Supps/sup142_03.pdf
+  class Anonymizer
+    
+    attr_accessor :blank, :enumeration, :identity_file, :verbose, :write_path
+    
+    # Initialize the Anonymizer instance:
+    def initialize(opts={})
+      # Default verbosity is true: # NB: verbosity is not used currently
+      @verbose = opts[:verbose]
+      @verbose = true if @verbose == nil
+      # Load library:
+      @lib = DLibrary.new
+      # Default value of accessors:
+      @blank = false
+      @enumeration = false
+      @write_path = nil
+      # Array of folders to be processed for anonymization:
+      @folders = Array.new
+      @exceptions = Array.new
+      # Tags that will be anonymized:
+      @tags = Array.new
+      # Default values to use on anonymized tags:
+      @values = Array.new
+      # Which tags will have enumeration applied, if requested by the user:
+      @enum = Array.new
+      # We use a hash to store information from DICOM files if enumeration is desired:
+      @enum_old_hash = {}
+      @enum_new_hash = {}
+      # All the files to be anonymized will be put in this array:
+      @files = Array.new
+      # Write paths will be determined later and put in this array:
+      @write_paths = Array.new
+      # Set the default tags to be anonymized:
+      set_defaults()
+    end # of method initialize
+    
+    
+    # Adds a folder who's files will be anonymized:
+    def add_folder(path)
+      @folders += [path] if path
+    end
+   
+   
+    # Adds an exception folder that is to be avoided when anonymizing:
+    def add_exception(path)
+      @exceptions += [path] if path
+    end
+    
+    
+    # Adds a tag to the list of tags that will be anonymized:
+    def add_tag(tag, opts={})
+      # Options and defaults:
+      value =  opts[:value]  || ""
+      enum =  opts[:enum]  || false
+      if tag
+        if tag.is_a?(String)
+          if tag.length == 9
+            # Add tag information:
+            @tags += [tag]
+            @values += [value]
+            @enum += [enum]
+          else
+            puts "Warning: Invalid tag length. Please use the form 'GGGG,EEEE'."
+          end
+        else
+          puts "Warning: Tag is not a string. Can not add tag."
+        end
+      else
+        puts "Warning: No tag supplied. Nothing to add."
+      end
+    end # of method add_tag
+    
+    
+    # Set enumeration status for a specific tag (toggle true/false)
+    def change_enum(tag, enum)
+      pos = @tags.index(tag)
+      if pos
+        if enum
+          @enum[pos] = true
+        else
+          @enum[pos] = false
+        end
+      else
+        puts "Specified tag not found in anonymization array. No changes made."
+      end
+    end # of method change_enum
+    
+    
+    # Changes the value used in anonymization for a specific tag:
+    def change_value(tag, value)
+      pos = @tags.index(tag)
+      if pos
+        if value
+          @values[pos] = value
+        else
+          puts "No value were specified. No changes made."
+        end
+      else
+        puts "Specified tag not found in anonymization array. No changes made."
+      end
+    end # of method change_value
+    
+    
+    # Executes the anonymization process:
+    def execute(verbose=false)
+      # Search through the folders to gather all the files to be anonymized:
+      puts "*******************************************************"
+      puts "Initiating anonymization process."
+      start_time = Time.now.to_f
+      puts "Searching for files..."
+      load_files()
+      puts "Done."
+      if @files.length > 0
+        if @tags.length > 0
+          puts @files.length.to_s + " files have been identified in the specified folder(s)."
+          if @write_path
+            # Determine the write paths, as anonymized files will be written to a separate location:
+            puts "Processing write paths..."
+            process_write_paths()
+            puts "Done"
+          else
+            # Overwriting old files:
+            puts "Separate write folder not specified. Will overwrite existing DICOM files."
+            @write_paths = @files
+          end
+          # If the user wants enumeration, we need to prepare variables for storing
+          # existing information associated with each tag:
+          create_enum_hash() if @enumeration
+          # Start the read/update/write process:
+          puts "Initiating read/update/write process..."
+          # Monitor whether every file read/write was successful:
+          all_read = true
+          all_write = true
+          @files.each_index do |i|
+            # Read existing file to DICOM object:
+            obj = DICOM::DObject.new(@files[i], :verbose => verbose, :lib => @lib)
+            if obj.read_success
+              # Anonymize the desired tags:
+              @tags.each_index do |j|
+                if @blank
+                  value = ""
+                elsif @enumeration
+                  # Get old value:
+                  current = obj.get_value(@tags[j])
+                  # Only launch enumeration logic if tag exists:
+                  if current != false
+                    value = get_enumeration_value(current, j)
+                  else
+                    value = ""
+                  end
+                else
+                  # Value is simply value in array:
+                  value = @values[j]
+                end # of if @blank..else..
+                # Update DICOM object with new value:
+                obj.set_value(value, :create => false, :label => @tags[j])
+              end
+              # Write DICOM file:
+              obj.write_file(@write_paths[i])
+              all_write = false unless obj.write_success
+            else
+              all_read = false
+            end
+          end # of @files.each...
+          end_time = Time.now.to_f
+          puts "Anonymization process completed!"
+          if all_read
+            puts "All files in specified folder(s) were SUCCESSFULLY read to DICOM objects."
+          else
+            puts "Some files were NOT successfully read. If folder(s) contain non-DICOM files, then this is probably the reason."
+          end
+          if all_write
+            puts "All DICOM objects were SUCCESSFULLY written as DICOM files."
+          else
+            puts "Some DICOM objects were NOT succesfully written to file. You are advised to have a closer look."
+          end
+          # Has user requested enumeration and specified an identity file in which to store the anonymized values?
+          if @enumeration and @identity_file
+            puts "Writing identity file."
+            write_identity_file()
+            puts "Done"
+          end
+          elapsed = (end_time-start_time).to_s
+          puts "Elapsed time: " + elapsed[0..elapsed.index(".")+1] + " seconds"
+        else
+          puts "No tags have been selected for anonymization. Aborting."
+        end
+      else
+        puts "No files were found in specified folders. Aborting."
+      end
+      puts "*******************************************************"
+    end # of method execute
+    
+    
+    # Prints a list of which tags are currently selected for anonymization along with
+    # replacement values that will be used and enumeration status.
+    def print()
+      # Extract the string lengths which are needed to make the formatting nice:
+      names = Array.new
+      types = Array.new
+      label_lengths = Array.new
+      name_lengths = Array.new
+      type_lengths = Array.new
+      value_lengths = Array.new
+      @tags.each_index do |i|
+        arr = @lib.get_name_vr(@tags[i])
+        names += [arr[0]]
+        types += [arr[1]]
+        label_lengths[i] = @tags[i].length
+        name_lengths[i] = names[i].length
+        type_lengths[i] = types[i].length
+        value_lengths[i] = @values[i].to_s.length unless @blank
+        value_lengths[i] = "" if @blank
+      end
+      # To give the printed output a nice format we need to check the string lengths of some of these arrays:
+      label_maxL = label_lengths.max
+      name_maxL = name_lengths.max
+      type_maxL = type_lengths.max
+      value_maxL = value_lengths.max
+      # Format string array for print output:
+      lines = Array.new
+      @tags.each_index do |i|
+        # Configure empty spaces:
+        s = " "
+        f1 = " "*(label_maxL-@tags[i].length+1)
+        f2 = " "*(name_maxL-names[i].length+1)
+        f3 = " "*(type_maxL-types[i].length+1)
+        f4 = " " if @blank
+        f4 = " "*(value_maxL-@values[i].to_s.length+1) unless @blank
+        if @enumeration
+          enum = @enum[i]
+        else
+          enum = ""
+        end
+        if @blank
+          value = ""
+        else
+          value = @values [i]
+        end
+        tag = @tags[i]
+        lines += [tag + f1 + names[i] + f2 + types[i] + f3 + value.to_s + f4 + enum.to_s ]
+      end
+      # Print to screen:
+      lines.each do |line|
+        puts line
+      end
+    end # of method print_tags
+    
+    
+    # Removes a tag from the list of tags that will be anonymized:
+    def remove_tag(tag)
+      pos = @tags.index(tag)
+      if pos
+        @tags.delete_at(pos)
+        @values.delete_at(pos)
+        @enum.delete_at(pos)
+      else
+        puts "Specified tag not found in anonymization array. No changes made."
+      end
+    end # of method remove_tag
+    
+    
+    # The following methods are private:
+    private
+    
+    
+    # Finds the common path in an array of files, by performing a recursive search.
+    # Returns the index of the last folder in str_arr that is common in all file paths.
+    def common_path(str_arr, index)
+      common_folders = Array.new
+      # Find out how much of the path is similar for all files in @files array:
+      folder = str_arr[index]
+      all_match = true
+      @files.each do |f|
+        all_match = false unless f.include?(folder)
+      end
+      if all_match
+        # Need to check the next folder in the array:
+        result = common_path(str_arr, index + 1)
+      else
+        # Current folder did not match, which means last possible match is current index -1.
+        result = index - 1
+      end
+      return result
+    end # of method common_path
+    
+    
+    # Creates a hash that is used for storing information used when enumeration is desired.
+    def create_enum_hash()
+      @enum.each_index do |i|
+        @enum_old_hash[@tags[i]] = Array.new
+        @enum_new_hash[@tags[i]] = Array.new
+      end
+    end
+    
+    
+    # Handles enumeration for current DICOM tag:
+    def get_enumeration_value(current, j)
+      # Is enumeration requested for this tag?
+      if @enum[j]
+        # Retrieve earlier used anonymization values:
+        previous_old = @enum_old_hash[@tags[j]]
+        previous_new = @enum_new_hash[@tags[j]]
+        p_index = previous_old.length
+        if previous_old.index(current) == nil
+          # Current value has not been encountered before:
+          value = @values[j]+(p_index + 1).to_s
+          # Store value in array (and hash):
+          previous_old += [current]
+          previous_new += [value]
+          @enum_old_hash[@tags[j]] = previous_old
+          @enum_new_hash[@tags[j]] = previous_new
+        else
+          # Current value has been observed before:
+          value = previous_new[previous_old.index(current)]
+        end # of if previous.index...else..
+      else
+        value = @values[j]
+      end # of if @enum[j]..else..
+      return value
+    end # of method handle_enumeration
+    
+    
+    # Discover all the files contained in the specified directory and all its sub-directories:
+    def load_files()
+      # Load find library:
+      require 'find'
+      # Iterate through the folders (and its subfolders) to extract all files:
+      for dir in @folders
+        Find.find(dir) do |path|
+          if FileTest.directory?(path)
+            if @exceptions.include?(File.basename(path))
+              Find.prune  # Don't look any further into this directory.
+            else
+              next
+            end
+          else
+            @files += [path]  # Store the file in our array
+          end
+        end
+      end # of for dir...
+    end # of method load_files
+    
+    
+    # Analyses the write_path and the 'read' file path to determine if the have some common root.
+    # If there are parts of file that exist also in write path, it will not add those parts to write_path.
+    def process_write_paths()
+      # First make sure @write_path ends with a "/" (represented by decimal 47):
+      @write_path = @write_path + "/" unless @write_path[@write_path.length-1] == 47
+      # Separate behaviour if we have one, or several files in our array:
+      if @files.length == 1
+        # One file.
+        # Write path is requested write path + old file name:
+        str_arr = @files[0].split("/")
+        @write_paths += [@write_path + str_arr.last]
+      else
+        # Several files.
+        # Find out how much of the path they have in common, remove that and
+        # add the remaining to the @write_path:
+        str_arr = @files[0].split("/")
+        last_match_index = common_path(str_arr, 0)
+        if last_match_index >= 0
+          # Remove the matching folders from the path that will be added to @write_path:
+          @files.each do |file|
+            arr = file.split("/")
+            part_to_write = arr[(last_match_index+1)..(arr.length-1)].join("/")
+            @write_paths += [@write_path + part_to_write]
+          end
+        else
+          # No common folders. Add all of original path to write path:
+          @files.each do |file|
+            @write_paths += [@write_path + file]
+          end
+        end
+      end # of if @files.length..
+    end # of method process_write_paths
+    
+    
+    # Default tags that will be anonymized, along with some settings for each:
+    def set_defaults()
+      data = [
+      ["0008,0012", "20000101", false], # Instance Creation Date
+      ["0008,0013", "000000.00", false], # Instance Creation Time
+      ["0008,0020", "20000101", false], # Study Date
+      ["0008,0023", "20000101", false], # Image Date
+      ["0008,0030", "000000.00", false], # Study Time
+      ["0008,0033", "000000.00", false], # Image Time
+      ["0008,0080", "Institution", true], # Institution name
+      ["0008,0090", "Physician", true], # Referring Physician's name
+      ["0008,1010", "Station", true], # Station name
+      ["0010,0010", "Patient", true], # Patient's name
+      ["0010,0020", "ID", true], # Patient's ID
+      ["0010,0030", "20000101", false], # Patient's Birth Date
+      ["0010,0040", "N", false], # Patient's Sex
+      ["0020,4000", "", false], # Image Comments
+      ].transpose
+      @tags = data[0]
+      @values = data[1]
+      @enum = data[2]
+    end # of method set_defaults
+    
+    
+    # Writes an identity file, which allows reidentification of DICOM files that have been anonymized
+    # using the enumeration feature. Values will be saved in a text file, using semi colon delineation.
+    def write_identity_file()
+      # Open file and prepare to write text:
+      File.open( @identity_file, 'w' ) do |output|
+        # Cycle through each 
+        @tags.each_index do |i|
+          if @enum[i]
+            # This tag has had enumeration. Gather original and anonymized values:
+            old_values = @enum_old_hash[@tags[i]]
+            new_values = @enum_new_hash[@tags[i]]
+            # Print the tag label, then new_value;old_value in the following rows.
+            output.print @tags[i] + "\n"
+            old_values.each_index do |j|
+              output.print new_values[j].to_s.rstrip + ";" + old_values[j].to_s.rstrip + "\n"
+            end
+            # Print empty line for separation between different tags:
+            output.print "\n"
+          end # of if @enum[i]
+        end # of @tags.each...
+      end # of File.open...
+    end # of method write...
+    
+    
+  end # of class
+end # of module