dicom 0.9.4 → 0.9.5

data/lib/dicom/audit_trail.rb

@@ -97,7 +97,14 @@ module DICOM
     # @param [String] file_name the path to be used for storing key/value pairs on disk
     #
     def write(file_name)
+      # Encode json string:
       str = JSON.pretty_generate(@dictionary)
+      # Create directory if needed:
+      unless File.directory?(File.dirname(file_name))
+        require 'fileutils'
+        FileUtils.mkdir_p(File.dirname(file_name))
+      end
+      # Write to file:
       File.open(file_name, 'w') {|f| f.write(str) }
     end
 

data/lib/dicom/constants.rb

@@ -6,7 +6,7 @@ module DICOM
   # Ruby DICOM's registered DICOM UID root (Implementation Class UID).
   UID_ROOT = "1.2.826.0.1.3680043.8.641"
   # Ruby DICOM name & version (max 16 characters).
-  NAME = "RUBY_DCM_" + DICOM::VERSION
+  NAME = "RUBY-DCM_" + DICOM::VERSION
 
   # Item tag.
   ITEM_TAG = "FFFE,E000"

data/lib/dicom/d_library.rb

@@ -24,15 +24,23 @@ module DICOM
       @methods_from_names = Hash.new
       @names_from_methods = Hash.new
       # Load the elements dictionary:
-      File.open("#{ROOT_DIR}/dictionary/elements.txt").each do |record|
-        load_element(record)
-      end
+      add_element_dictionary("#{ROOT_DIR}/dictionary/elements.txt")
       # Load the unique identifiers dictionary:
-      File.open("#{ROOT_DIR}/dictionary/uids.txt").each do |record|
-        fields = record.split("\t")
-        # Store the uids in a hash with uid-value as key and the uid instance as value:
-        @uids[fields[0]] = UID.new(fields[0], fields[1], fields[2].rstrip, fields[3].rstrip)
-      end
+      add_uid_dictionary("#{ROOT_DIR}/dictionary/uids.txt")
+    end
+
+    # Adds a custom DictionaryElement to the ruby-dicom element dictionary.
+    #
+    # @param [DictionaryElement] element the custom dictionary element to be added
+    #
+    def add_element(element)
+      raise ArgumentError, "Invalid argument 'element'. Expected DictionaryElement, got #{element.class}" unless element.is_a?(DictionaryElement)
+      # We store the elements in a hash with tag as key and the element instance as value:
+      @elements[element.tag] = element
+      # Populate the method conversion hashes with element data:
+      method = element.name.to_element_method
+      @methods_from_names[element.name] = method
+      @names_from_methods[method] = element.name
     end
 
     # Adds a custom dictionary file to the ruby-dicom element dictionary.
@@ -40,11 +48,36 @@ module DICOM
     # @note The format of the dictionary is a tab-separated text file with 5 columns:
     #   * Tag, Name, VR, VM & Retired status
     #   * For samples check out ruby-dicom's element dictionaries in the git repository
-    # @param [String] file The path to the dictionary file to be added
+    # @param [String] file the path to the dictionary file to be added
     #
     def add_element_dictionary(file)
-      File.open(file).each do |record|
-        load_element(record)
+      File.open(file, :encoding => 'utf-8').each do |record|
+        fields = record.split("\t")
+        add_element(DictionaryElement.new(fields[0], fields[1], fields[2].split(","), fields[3].rstrip, fields[4].rstrip))
+      end
+    end
+
+    # Adds a custom uid (e.g. SOP Class, Transfer Syntax) to the ruby-dicom uid dictionary.
+    #
+    # @param [UID] uid the custom uid instance to be added
+    #
+    def add_uid(uid)
+      raise ArgumentError, "Invalid argument 'uid'. Expected UID, got #{uid.class}" unless uid.is_a?(UID)
+      # We store the uids in a hash with uid-value as key and the uid instance as value:
+      @uids[uid.value] = uid
+    end
+
+    # Adds a custom dictionary file to the ruby-dicom uid dictionary.
+    #
+    # @note The format of the dictionary is a tab-separated text file with 4 columns:
+    #   * Value, Name, Type & Retired status
+    #   * For samples check out ruby-dicom's uid dictionaries in the git repository
+    # @param [String] file the path to the dictionary file to be added
+    #
+    def add_uid_dictionary(file)
+      File.open(file, :encoding => 'utf-8').each do |record|
+        fields = record.split("\t")
+        add_uid(UID.new(fields[0], fields[1], fields[2].rstrip, fields[3].rstrip))
       end
     end
 
@@ -197,24 +230,6 @@ module DICOM
       @uids[value]
     end
 
-
-    private
-
-
-    # Loads an element to the dictionary from an element string record.
-    #
-    # @param [String] record a tab-separated string line as extracted from a dictionary file
-    #
-    def load_element(record)
-      fields = record.split("\t")
-      # Store the elements in a hash with tag as key and the element instance as value:
-      element = DictionaryElement.new(fields[0], fields[1], fields[2].split(","), fields[3].rstrip, fields[4].rstrip)
-      @elements[fields[0]] = element
-      # Populate the method conversion hashes with element data:
-      method = element.name.to_element_method
-      @methods_from_names[element.name] = method
-      @names_from_methods[method] = element.name
-    end
-
   end
-end
+
+end

data/lib/dicom/d_object.rb

@@ -1,18 +1,4 @@
-# === TODO:
-#
-# * The retrieve file network functionality (#get_image in DClient class) has not been tested.
-# * Make the networking code more intelligent in its handling of unexpected network communication.
-# * Full support for compressed image data.
-# * Read/Write 12 bit image data.
-# * Full color support (RGB and PALETTE COLOR with #image already implemented).
-# * Support for extraction of multiple encapsulated pixel data frames in #pixels and #narray.
-# * Image handling currently ignores DICOM tags like Pixel Aspect Ratio, Image Orientation and (to some degree) Photometric Interpretation.
-# * More robust and flexible options for reorienting extracted pixel arrays?
-# * A curious observation: Creating a DLibrary instance is exceptionally slow on Ruby 1.9.1: 0.4 seconds versus ~0.01 seconds on Ruby 1.8.7!
-# * Add these as github issues and remove this list!
-
-
-#    Copyright 2008-2012 Christoffer Lervag
+#    Copyright 2008-2013 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
@@ -44,8 +30,12 @@ module DICOM
     attr_reader :parent
     # A boolean which is set as true if a DICOM file has been successfully read & parsed from a file (or binary string).
     attr_accessor :read_success
+    # The source of the DObject (nil, :str or file name string).
+    attr_accessor :source
     # The Stream instance associated with this DObject instance (this attribute is mostly used internally).
     attr_reader :stream
+    # An attribute (used by e.g. DICOM.load) to indicate that a DObject-type instance was given to the load method (instead of e.g. a file).
+    attr_accessor :was_dcm_on_input
     # A boolean which is set as true if a DObject instance has been successfully written to file (or successfully encoded).
     attr_reader :write_success
 
@@ -91,6 +81,7 @@ module DICOM
         dcm = self.new
         dcm.read_success = false
       end
+      dcm.source = link
       return dcm
     end
 
@@ -98,6 +89,7 @@ module DICOM
     #
     # @param [String] string an encoded binary string containing DICOM information
     # @param [Hash] options the options to use for parsing the DICOM string
+    # @option options [Boolean] :overwrite for the rare case of a DICOM file containing duplicate elements, setting this as true instructs the parsing algorithm to overwrite the original element with duplicates
     # @option options [Boolean] :signature if set as false, the parsing algorithm will not be looking for the DICOM header signature (defaults to true)
     # @option options [String] :syntax if a syntax string is specified, the parsing algorithm will be forced to use this transfer syntax when decoding the binary string
     # @example Parse a DICOM file that has already been loaded to a binary string
@@ -111,23 +103,26 @@ module DICOM
       raise ArgumentError, "Invalid option :syntax. Expected String, got #{options[:syntax].class}." if options[:syntax] && !options[:syntax].is_a?(String)
       signature = options[:signature].nil? ? true : options[:signature]
       dcm = self.new
-      dcm.send(:read, string, signature, :syntax => options[:syntax])
+      dcm.send(:read, string, signature, :overwrite => options[:overwrite], :syntax => options[:syntax])
       if dcm.read?
         logger.debug("DICOM string successfully parsed.")
       else
         logger.warn("Failed to parse this string as DICOM.")
       end
+      dcm.source = :str
       return dcm
     end
 
     # Creates a DObject instance by reading and parsing a DICOM file.
     #
     # @param [String] file a string which specifies the path of the DICOM file to be loaded
+    # @param [Hash] options the options to use for reading the DICOM file
+    # @option options [Boolean] :overwrite for the rare case of a DICOM file containing duplicate elements, setting this as true instructs the parsing algorithm to overwrite the original element with duplicates
     # @example Load a DICOM file
     #   require 'dicom'
     #   dcm = DICOM::DObject.read('test.dcm')
     #
-    def self.read(file)
+    def self.read(file, options={})
       raise ArgumentError, "Invalid argument 'file'. Expected String, got #{file.class}." unless file.is_a?(String)
       # Read the file content:
       bin = nil
@@ -150,12 +145,13 @@ module DICOM
       end
       # Parse the file contents and create the DICOM object:
       if bin
-        dcm = self.parse(bin)
+        dcm = self.parse(bin, options)
         # If reading failed, and no transfer syntax was detected, we will make another attempt at reading the file while forcing explicit (little endian) decoding.
         # This will help for some rare cases where the DICOM file is saved (erroneously, Im sure) with explicit encoding without specifying the transfer syntax tag.
         if !dcm.read? and !dcm.exists?("0002,0010")
           logger.info("Attempting a second decode pass (assuming Explicit Little Endian transfer syntax).")
-          dcm = self.parse(bin, :syntax => EXPLICIT_LITTLE_ENDIAN)
+          options[:syntax] = EXPLICIT_LITTLE_ENDIAN
+          dcm = self.parse(bin, options)
         end
       else
         dcm = self.new
@@ -165,6 +161,7 @@ module DICOM
       else
         logger.warn("Reading DICOM file failed: #{file}")
       end
+      dcm.source = file
       return dcm
     end
 
@@ -212,6 +209,14 @@ module DICOM
 
     alias_method :eql?, :==
 
+    # Performs de-identification (anonymization) on the DICOM object.
+    #
+    # @param [Anonymizer] a an Anonymizer instance to use for the anonymization
+    #
+    def anonymize(a=Anonymizer.new)
+      a.to_anonymizer.anonymize(self)
+    end
+
     # Encodes the DICOM object into a series of binary string segments with a specified maximum length.
     #
     # Returns the encoded binary strings in an array.
@@ -263,8 +268,17 @@ module DICOM
       # System endian:
       cpu = (CPU_ENDIAN ? "Big Endian" : "Little Endian")
       sys_info << "Byte Order (CPU):     #{cpu}"
-      # File path/name:
-      info << "File:                 #{@file}"
+      # Source (file name):
+      if @source
+        if @source == :str
+          source = "Binary string #{@read_success ? '(successfully parsed)' : '(failed to parse)'}"
+        else
+          source = "File #{@read_success ? '(successfully read)' : '(failed to read)'}: #{@source}"
+        end
+      else
+        source = 'Created from scratch'
+      end
+      info << "Source:               #{source}"
       # Modality:
       modality = (LIBRARY.uid(value('0008,0016')) ? LIBRARY.uid(value('0008,0016')).name : "SOP Class unknown or not specified!")
       info << "Modality:             #{modality}"
@@ -376,15 +390,15 @@ module DICOM
     #
     # @param [String] file_name the path of the DICOM file which is to be written to disk
     # @param [Hash] options the options to use for writing the DICOM file
-    # @option options [Boolean] :add_meta <DEPRECATED> if set to false, no manipulation of the DICOM object's meta group will be performed before the DObject is written to file
     # @option options [Boolean] :ignore_meta if true, no manipulation of the DICOM object's meta group will be performed before the DObject is written to file
+    # @option options [Boolean] :include_empty_parents if true, childless parents (sequences & items) are written to the DICOM file
     # @example Encode a DICOM file from a DObject
     #   dcm.write('C:/dicom/test.dcm')
     #
     def write(file_name, options={})
-      logger.warn("Option :add_meta => false is deprecated. Use option :ignore_meta => true instead.") if options[:add_meta] == false
       raise ArgumentError, "Invalid file_name. Expected String, got #{file_name.class}." unless file_name.is_a?(String)
-      insert_missing_meta unless options[:add_meta] == false or options[:ignore_meta]
+      @include_empty_parents = options[:include_empty_parents]
+      insert_missing_meta unless options[:ignore_meta]
       write_elements(:file_name => file_name, :signature => true, :syntax => transfer_syntax)
     end
 

data/lib/dicom/d_read.rb

@@ -88,8 +88,17 @@ module DICOM
       # Create an Element from the gathered data:
       if level_vr == "SQ" or tag == ITEM_TAG
         if level_vr == "SQ"
-          # Create a Sequence:
-          @current_element = Sequence.new(tag, :length => length, :name => name, :parent => @current_parent, :vr => vr)
+          # Check for duplicate and create sequence:
+          logger.warn("Duplicate Sequence (#{tag}) detected at level #{@current_parent.parent.is_a?(DObject) ? 'DObject' : @current_parent.parent.tag + ' => ' if @current_parent.parent}#{@current_parent.is_a?(DObject) ? 'DObject' : @current_parent.tag}") if @current_parent[tag]
+          unless @current_parent[tag] and !@overwrite
+            @current_element = Sequence.new(tag, :length => length, :name => name, :parent => @current_parent, :vr => vr)
+          else
+            # We have skipped a sequence. This means that any following children
+            # of this sequence must be skipped as well. We solve this by creating an 'orphaned'
+            # sequence that has a parent defined, but does not add itself to this parent:
+            @current_element = Sequence.new(tag, :length => length, :name => name, :vr => vr)
+            @current_element.set_parent(@current_parent)
+          end
         elsif tag == ITEM_TAG
           # Create an Item:
           if @enc_image
@@ -118,10 +127,13 @@ module DICOM
         # The occurance of such a tag indicates that a sequence or item has ended, and the parent must be changed:
         @current_parent = @current_parent.parent
       else
-        # Create an ordinary Data Element:
-        @current_element = Element.new(tag, value, :bin => bin, :name => name, :parent => @current_parent, :vr => vr)
-        # Check that the data stream didnt end abruptly:
-        raise "The actual length of the value (#{@current_element.bin.length}) does not match its specified length (#{length}) for Data Element #{@current_element.tag}" if length != @current_element.bin.length
+        # Check for duplicate and create an ordinary data element:
+        logger.warn("Duplicate Element (#{tag}) detected at level #{@current_parent.parent.is_a?(DObject) ? 'DObject' : @current_parent.parent.tag + ' => ' if @current_parent.parent}#{@current_parent.is_a?(DObject) ? 'DObject' : @current_parent.tag}") if @current_parent[tag]
+        unless @current_parent[tag] and !@overwrite
+          @current_element = Element.new(tag, value, :bin => bin, :name => name, :parent => @current_parent, :vr => vr)
+          # Check that the data stream didn't end abruptly:
+          raise "The actual length of the value (#{@current_element.bin.length}) does not match its specified length (#{length}) for Data Element #{@current_element.tag}" if length != @current_element.bin.length
+        end
       end
       # Return true to indicate success:
       return true
@@ -132,11 +144,13 @@ module DICOM
     # @param [String] string a binary DICOM string to be parsed
     # @param [Boolean] signature if true (default), the parsing algorithm will look for the DICOM header signature
     # @param [Hash] options the options to use for parsing the DICOM string
+    # @option options [Boolean] :overwrite for the rare case of a DICOM file containing duplicate elements, setting this as true instructs the parsing algorithm to overwrite the original element with duplicates
     # @option options [String] :syntax if a syntax string is specified, the parsing algorithm is forced to use this transfer syntax when decoding the string
     #
     def read(string, signature=true, options={})
       # (Re)Set variables:
       @str = string
+      @overwrite = options[:overwrite]
       # Presence of the official DICOM signature:
       @signature = false
       # Default explicitness of start of DICOM string:

data/lib/dicom/d_server.rb

@@ -52,7 +52,7 @@ module DICOM
     # @param [Integer] port the network port to be used
     # @param [Hash] options the options to use for the DICOM server
     # @option options [String] :file_handler a customized FileHandler class to use instead of the default FileHandler
-    # @option options [String] :host the hostname that the TCPServer binds to (defaults to '127.0.0.1')
+    # @option options [String] :host the hostname that the TCPServer binds to (defaults to '0.0.0.0')
     # @option options [String] :host_ae the name of the server (application entity)
     # @option options [String] :max_package_size the maximum allowed size of network packages (in bytes)
     # @option options [String] :timeout the number of seconds the server will wait on an answer from a client before aborting the communication
@@ -60,7 +60,7 @@ module DICOM
     # @example Create a server using default settings
     #   s = DICOM::DServer.new
     # @example Create a server with a specific host name and a custom buildt file handler
-    #   require 'MyFileHandler'
+    #   require_relative 'my_file_handler'
     #   server = DICOM::DServer.new(104, :host_ae => "RUBY_SERVER", :file_handler => DICOM::MyFileHandler)
     #
     def initialize(port=104, options={})
@@ -69,7 +69,7 @@ module DICOM
       @port = port
       # Optional parameters (and default values):
       @file_handler = options[:file_handler] || FileHandler
-      @host = options[:host] || '127.0.0.1'
+      @host = options[:host] || '0.0.0.0'
       @host_ae =  options[:host_ae]  || "RUBY_DICOM"
       @max_package_size = options[:max_package_size] || 32768 # 16384
       @timeout = options[:timeout] || 10 # seconds

data/lib/dicom/d_write.rb

@@ -155,14 +155,19 @@ module DICOM
             write_data_element(element)
             write_data_elements(element.children)
             if @enc_image
-              write_delimiter(element) if element.tag == PIXEL_TAG # (Write a delimiter for the pixel tag, but not for it's items)
+              # Write a delimiter for the pixel tag, but not for its items:
+              write_delimiter(element) if element.tag == PIXEL_TAG
             else
               write_delimiter(element)
             end
           else
-            # Empty sequence/item or item with binary data (We choose not to write empty, childless parents):
+            # Parent is childless:
             if element.bin
               write_data_element(element) if element.bin.length > 0
+            elsif @include_empty_parents
+              # Only write empty/childless parents if specifically indicated:
+              write_data_element(element)
+              write_delimiter(element)
             end
           end
         else

data/lib/dicom/deprecated.rb

@@ -1,2 +1,320 @@
 module DICOM
+
+  class Anonymizer
+
+    # Adds an exception folder which will be avoided when anonymizing.
+    #
+    # @deprecated Use Anonymizer#anonymize instead.
+    # @param [String] path a path that will be avoided
+    # @example Adding a folder
+    #   a.add_exception("/home/dicom/tutorials/")
+    #
+    def add_exception(path)
+      # Deprecation warning:
+      logger.warn("The '#add_exception' method of the Anonymization class has been deprecated! Please use the '#anonymize' method with a dataset argument instead.")
+      raise ArgumentError, "Expected String, got #{path.class}." unless path.is_a?(String)
+      if path
+        # Remove last character if the path ends with a file separator:
+        path.chop! if path[-1..-1] == File::SEPARATOR
+        @exceptions << path
+      end
+    end
+
+    # Adds a folder who's files will be anonymized.
+    #
+    # @deprecated Use Anonymizer#anonymize instead.
+    # @param [String] path a path that will be included in the anonymization
+    # @example Adding a folder
+    #   a.add_folder("/home/dicom")
+    #
+    def add_folder(path)
+      # Deprecation warning:
+      logger.warn("The '#add_exception' method of the Anonymization class has been deprecated! Please use the '#anonymize' method with a dataset argument instead.")
+      raise ArgumentError, "Expected String, got #{path.class}." unless path.is_a?(String)
+      @folders << path
+    end
+
+    # Executes the anonymization process.
+    #
+    # This method is run when all settings have been finalized for the Anonymization instance.
+    #
+    # @deprecated Use Anonymizer#anonymize instead.
+    #
+    def execute
+      # Deprecation warning:
+      logger.warn("The '#execute' method of the Anonymization class has been deprecated! Please use the '#anonymize' method instead.")
+      # FIXME: This method has grown way too lengthy. It needs to be refactored one of these days.
+      # Search through the folders to gather all the files to be anonymized:
+      logger.info("Initiating anonymization process.")
+      start_time = Time.now.to_f
+      logger.info("Searching for files...")
+      load_files
+      logger.info("Done.")
+      if @files.length > 0
+        if @tags.length > 0
+          logger.info(@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:
+            logger.info("Processing write paths...")
+            process_write_paths
+            logger.info("Done")
+          else
+            # Overwriting old files:
+            logger.warn("Separate write folder not specified. Existing DICOM files will be overwritten.")
+            @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:
+          logger.info("Initiating read/update/write process. This may take some time...")
+          # Monitor whether every file read/write was successful:
+          all_read = true
+          all_write = true
+          files_written = 0
+          files_failed_read = 0
+          begin
+            require 'progressbar'
+            pbar = ProgressBar.new("Anonymizing", @files.length)
+          rescue LoadError
+            pbar = nil
+          end
+          # Temporarily increase the log threshold to suppress messages from the DObject class:
+          anonymizer_level = logger.level
+          logger.level = Logger::FATAL
+          @files.each_index do |i|
+            pbar.inc if pbar
+            # Read existing file to DICOM object:
+            dcm = DObject.read(@files[i])
+            if dcm.read?
+              # Extract the data element parents to investigate for this DICOM object:
+              parents = element_parents(dcm)
+              parents.each do |parent|
+                # Anonymize the desired tags:
+                @tags.each_index do |j|
+                  if parent.exists?(@tags[j])
+                    element = parent[@tags[j]]
+                    if element.is_a?(Element)
+                      if @blank
+                        value = ""
+                      elsif @enumeration
+                        old_value = element.value
+                        # Only launch enumeration logic if there is an actual value to the data element:
+                        if old_value
+                          value = enumerated_value(old_value, j)
+                        else
+                          value = ""
+                        end
+                      else
+                        # Use the value that has been set for this tag:
+                        value = @values[j]
+                      end
+                      element.value = value
+                    end
+                  end
+                end
+                # Delete elements marked for deletion:
+                @delete.each_key do |tag|
+                  parent.delete(tag) if parent.exists?(tag)
+                end
+              end
+              # General DICOM object manipulation:
+              # Add a Patient Identity Removed attribute (as per
+              # DICOM PS 3.15, Annex E, E.1.1 De-Identifier, point 6):
+              dcm.add(Element.new('0012,0062', 'YES'))
+              # Delete (and replace) the File Meta Information (as per
+              # DICOM PS 3.15, Annex E, E.1.1 De-Identifier, point 7):
+              dcm.delete_group('0002')
+              # Handle UIDs if requested:
+              replace_uids(parents) if @uid
+              # Delete private tags?
+              dcm.delete_private if @delete_private
+              # Write DICOM file:
+              dcm.write(@write_paths[i])
+              if dcm.written?
+                files_written += 1
+              else
+                all_write = false
+              end
+            else
+              all_read = false
+              files_failed_read += 1
+            end
+          end
+          pbar.finish if pbar
+          # Finished anonymizing files. Reset the log threshold:
+          logger.level = anonymizer_level
+          # Print elapsed time and status of anonymization:
+          end_time = Time.now.to_f
+          logger.info("Anonymization process completed!")
+          if all_read
+            logger.info("All files in the specified folder(s) were SUCCESSFULLY read to DICOM objects.")
+          else
+            logger.warn("Some files were NOT successfully read (#{files_failed_read} files). If some folder(s) contain non-DICOM files, this is expected.")
+          end
+          if all_write
+            logger.info("All DICOM objects were SUCCESSFULLY written as DICOM files (#{files_written} files).")
+          else
+            logger.warn("Some DICOM objects were NOT succesfully written to file. You are advised to investigate the result (#{files_written} files succesfully written).")
+          end
+          @audit_trail.write(@audit_trail_file) if @audit_trail
+          elapsed = (end_time-start_time).to_s
+          logger.info("Elapsed time: #{elapsed[0..elapsed.index(".")+1]} seconds")
+        else
+          logger.warn("No tags were selected for anonymization. Aborting.")
+        end
+      else
+        logger.warn("No files were found in specified folders. Aborting.")
+      end
+    end
+
+    # Prints to screen a list of which tags are currently selected for anonymization along with
+    # the replacement values that will be used and enumeration status.
+    #
+    def print
+      logger.warn("Anonymizer#print is deprecated.")
+      # Extract the string lengths which are needed to make the formatting nice:
+      names = Array.new
+      types = Array.new
+      tag_lengths = Array.new
+      name_lengths = Array.new
+      type_lengths = Array.new
+      value_lengths = Array.new
+      @tags.each_index do |i|
+        name, vr = LIBRARY.name_and_vr(@tags[i])
+        names << name
+        types << vr
+        tag_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:
+      tag_maxL = tag_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 = ' '*(tag_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 = @enumerations[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
+
+
+    private
+
+
+    # Finds the common path (if any) in the instance file path array, by performing a recursive search
+    # on the folders that make up the path of one such file.
+    #
+    # @param [Array<String>] str_arr an array of folder strings from the path of a select file
+    # @param [Fixnum] index the index of the folder in str_arr to check against all file paths
+    # @return [Fixnum] the index of the last folder in the path of the selected file that is common for all file paths
+    #
+    def common_path(str_arr, index=0)
+      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
+
+    # Discovers all the files contained in the specified directory (all its sub-directories),
+    # and adds these files to the instance file array.
+    #
+    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)
+            proceed = true
+            @exceptions.each do |e|
+              proceed = false if e == path
+            end
+            if proceed
+              next
+            else
+              Find.prune  # Don't look any further into this directory.
+            end
+          else
+            @files << path  # Store the file in our array
+          end
+        end
+      end
+    end
+
+    # Analyzes the write_path and the 'read' file path to determine if they have some common root.
+    # If there are parts of the file path that exists also in the write path, the common parts will
+    # not be added to the write_path. The processed paths are put in a write_path instance array.
+    #
+    def process_write_paths
+      @write_paths = Array.new
+      # First make sure @write_path ends with a file separator character:
+      last_character = @write_path[-1..-1]
+      @write_path = @write_path + File::SEPARATOR unless last_character == File::SEPARATOR
+      # Differing behaviour if we have one, or several files in our array:
+      if @files.length == 1
+        # Write path is requested write path + old file name:
+        str_arr = @files[0].split(File::SEPARATOR)
+        @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(File::SEPARATOR)
+        last_match_index = common_path(str_arr)
+        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(File::SEPARATOR)
+            part_to_write = arr[(last_match_index+1)..(arr.length-1)].join(File::SEPARATOR)
+            @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
+    end
+
+  end
+
 end