dicom 0.9.4 → 0.9.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 39b5531cc2e35e76e34a22584cd3543462c371c6
+  data.tar.gz: d4c4309d054a1c2495c746956c5aa5a67536edcb
+SHA512:
+  metadata.gz: 68a07acd231106b00284009a3799621f44fa050944ea0076367545f807b76e5b57c1771cca985879951c80f0004ada6615e9c2a7bd9170d07fffe6dae62a57d1
+  data.tar.gz: 28f1655dea19ba8530a4f6aacaf307e7734ea153f0a546248289b43ccf949c8734179bb768db8bc57418ce25e1e112e918099bdfc03023d01b4110e0f36d0d2c

data/CHANGELOG.rdoc

@@ -1,3 +1,47 @@
+= 0.9.5
+
+=== 26th March, 2013
+
+* DICOM module:
+  * Use hyphen instead of underscore in ruby-dicom application title.
+  * Added the DICOM load module method, a flexible method for loading DICOM data:
+    * Accepts one or more directories (in which all files are scanned).
+    * Accepts one or more file paths (which are loaded as DICOM objects).
+    * Accepts one or more DICOM objects, which are called with #to_dcm and returned.
+* Network:
+  * Bind the DServer to '0.0.0.0' by default to avoid Econnrefused issues.
+  * Significantly improved network receive performance.
+  * Enable adding private UIDs to ruby-dicom's DICOM library.
+  * Read element and UID dictionaries with UTF-8 encoding.
+* DObject (/Item):
+  * Added DObject#anonymize for easy anonymization of a single DICOM object.
+  * Added add_element and add_sequence methods for conveniently creating new elements/sequences belonging to a specific DObject or Item.
+  * Fixed an issue where the NArray library where needed when trying to pass an array to the pixels= method.
+  * Fixed an issue where both Magick libraries where needed when trying to pass an image object to the image= method.
+  * Added DObject#was_dcm_on_input attribute to separate between file and DObject elements given to DICOM::load.
+  * Added option :include_empty_parents to DObject#write.
+  * Removed the deprecated DObjet#write :add_meta option.
+  * Added DObject#source attribute for keeping track of a DICOM object's origin.
+  * Defaults to ignoring duplicate data elements and sequences instead of replacing the original element.
+  * Added the :overwrite option to DObject#read and #parse which makes ruby-dicom overwrite elements when duplicates are encountered.
+* Anonymizer:
+  * Added Anonymizer#to_anonymizer, as well as equality and state methods.
+  * Use 'O' instead of 'N' as the default replacement value for Patient's Sex.
+  * Added :random_file_name option for increased security in the case of sensitive file name information.
+  * Make all Anonymizer attributes accessible through options with Anonymizer#new.
+  * Removed the deprecated identity_file feature.
+  * Deprecated Anonymizer#execute, along with its accompanying methods.
+  * Added the Anonymizer#anonymize method, which is intended to replace the execute method.
+  * Improved the Anonymizer's conformance with the guidelines in the DICOM standard:
+    * Delete the File Meta Information group (0002) on anonymization.
+    * Add the Patient Identity Removed element with value 'YES'.
+    * Add de-identification method code sequence.
+    * Added 7 new elements to the default anonymization list.
+  * Enabled complete remapping of UIDs in the Anonymizer (keeping all references between files/series/studies valid).
+  * Added Anonymizer :recursive option, for anonymizing entire element trees (not just the top level).
+  * Added Anonymizer :encryption option, which allows the simulatenous preservation of privacy and key/value relations in the audit file.
+
+
 = 0.9.4
 
 === 10th September, 2012

data/CONTRIBUTING.rdoc

@@ -0,0 +1,83 @@
+= Contributing Code
+
+So you want to contribute to ruby-dicom? That's great! Thank you! If you are a
+first time committer however, you must to take a moment to read these instructions.
+
+The preferred method, by far, is to convey your code contribution in the form
+of a pull request on {github}[https://github.com/dicom/ruby-dicom].
+
+== Committer's Recipe
+
+* Fork the repository (for bonus points, use a topical branch name).
+* Execute the specification (rspec tests) to verify that all spec examples pass
+  (if in doubt, check out the rakefile for instructions).
+* Add a spec example for your change. Only refactoring and documentation changes
+  require no new tests. If you are adding functionality or fixing a bug, a test is mandatory!
+* Alter the code to make the new spec example(s) pass.
+* Keep it simple! One issue per pull request. Mixing two or more independent
+  issues in the same pull request will complicate the review of your request and
+  may result in a rejection (even if independent parts of the commit are sound).
+* Don't modify the version or changelog.
+* Push to your fork and submit a pull request.
+* Wait for feedback (this shouldn't take too long). The pull request may be accepted right
+  away, it may be rejected (with a reason specified), or it may spark a discussion where
+  changes/improvements are suggested in order for the pull request to be accepted.
+
+== Guidelines
+
+In order to increase the chances of your pull request being accepted,
+please follow the project's coding guidelines. Ideally, your contribution must not
+add {technical debt}[http://en.wikipedia.org/wiki/Technical_debt] to the project.
+
+* Provide thorough documentation. It should follow the format used by this project
+  and give information on parameters, exceptions and return values where relevant.
+  Provide examples for non-trivial use cases.
+* Read the excellent {Github Ruby Styleguide}[https://github.com/styleguide/ruby]
+  if you are new to collaborative Ruby development. Do note though, that we actually
+  don't follow all styles listed yet (perhaps we should?!).
+* Some sample patterns of ours:
+  * Indentation: Two spaces (no tabs).
+  * No trailing whitespace. Blank lines should not have any space.
+  * Method parameters: my_method(my_arg) is preferred instead of my_method( my_arg ) or my_method my_arg
+  * Assignment: a = b and not a=b
+* In general: Follow the conventions you see used in the source code already.
+
+== Contribution Agreement
+
+ruby-dicom is licensed under the {GPL v3}[http://www.gnu.org/licenses/gpl.html],
+and to be in the best position to enforce the GPL, the copyright status of ruby-dicom
+needs to be as simple as possible. To achieve this, contributors should only provide
+contributions which are their own work, and either:
+
+a) Assign the copyright on the contribution to myself, Christoffer Lervåg
+
+or
+
+b) Disclaim copyright on it and thus put it in the public domain
+
+Copyright assignment (a) is the preferred and encouraged option for larger
+code contributions, and is assumed unless otherwise is specified.
+
+Please see the {GNU FAQ}[http://www.gnu.org/licenses/gpl-faq.html#AssignCopyright]
+for a fuller explanation of the need for this.
+
+== Credits
+
+All contributors are credited, with full name and link to their github account,
+in the README file. If such an accreditation is not wanted (for whatever reason),
+please let me know so, either in the pull request or in private.
+
+
+= Other ways to contribute
+
+Don't want to get your hands dirty with source code and git? Don't worry,
+there are other ways in which you can contribute to the project as well!
+
+* Create an issue on github for feature requests or bug reports.
+* Weigh in with your opinion on existing issues.
+* Write a tutorial.
+* Answer questions, or tell the community about your exciting ruby-dicom projects in the
+  {mailing list}[http://groups.google.com/group/ruby-dicom].
+* Academic works: Properly reference ruby-dicom in your work and tell us about it.
+* Spread the word: Tell your colleagues about ruby-dicom.
+* Make a donation.

data/README.rdoc

@@ -110,7 +110,7 @@ Example:
 
 == COPYRIGHT
 
-Copyright 2008-2012 Christoffer Lervåg
+Copyright 2008-2013 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
@@ -143,6 +143,7 @@ Please don't hesitate to email me if you have any feedback related to this proje
 * {Jeff Miller}[https://github.com/jeffmax]
 * {Donnie Millar}[https://github.com/dmillar]
 * {Björn Albers}[https://github.com/bjoernalbers]
-* {Lars Benner}[https://github.com/Maturin]
 * {Felix Petriconi}[https://github.com/FelixPetriconi]
 * {Steven Bedrick}[https://github.com/stevenbedrick]
+* {Lars Benner}[https://github.com/Maturin]
+* {Brett Goulder}[https://github.com/brettgoulder]

data/dicom.gemspec

@@ -9,23 +9,22 @@ Gem::Specification.new do |s|
   s.date = Time.now
   s.summary = "Library for handling DICOM files and DICOM network communication."
   s.require_paths = ['lib']
-  s.author = "Christoffer Lervag"
-  s.email = "chris.lervag@gmail.com"
-  s.homepage = "http://dicom.rubyforge.org/"
-  s.license = "GPLv3"
+  s.author = 'Christoffer Lervag'
+  s.email = 'chris.lervag@gmail.com'
+  s.homepage = 'http://dicom.rubyforge.org/'
+  s.license = 'GPLv3'
   s.description = "DICOM is a standard widely used throughout the world to store and transfer medical image data. This library enables efficient and powerful handling of DICOM in Ruby, to the benefit of any student or professional who would like to use their favorite language to process DICOM files and communicate across the network."
   s.files = Dir["{lib}/**/*", "[A-Z]*"]
   s.rubyforge_project = 'dicom'
 
   s.required_ruby_version = '>= 1.9.2'
-  s.required_rubygems_version = '>= 1.8.6'
 
-  s.add_development_dependency('bundler', '>= 1.0.0')
-  s.add_development_dependency('rake', '>= 0.9.2.2')
-  s.add_development_dependency('rspec', '>= 2.9.0')
-  s.add_development_dependency('mocha', '>= 0.10.5')
-  s.add_development_dependency('narray', '>= 0.6.0.0')
-  s.add_development_dependency('rmagick', '>= 2.12.0')
-  s.add_development_dependency('mini_magick', '>= 3.2.1')
-  s.add_development_dependency('yard', '>= 0.8.2')
+  s.add_development_dependency('bundler', '~> 1.3')
+  s.add_development_dependency('mocha', '~> 0.13')
+  s.add_development_dependency('mini_magick', '~> 3.5')
+  s.add_development_dependency('narray', '~> 0.6.0.8')
+  s.add_development_dependency('rake', '~> 0.9.6')
+  s.add_development_dependency('rmagick', '~> 2.13.2')
+  s.add_development_dependency('rspec', '~> 2.13')
+  s.add_development_dependency('yard', '~> 0.8.5')
 end

data/lib/dicom/anonymizer.rb

@@ -1,670 +1,649 @@
-module DICOM
-
-  # This is a convenience class for handling the anonymization (de-identification) of DICOM files.
-  #
-  # @note
-  #   For 'advanced' anonymization, a good resource might be the work on "Clinical Trials
-  #   De-identification Profiles" by the DICOM Standards Committee, Working Group 18:
-  #   ftp://medical.nema.org/medical/dicom/supps/sup142_pc.pdf
-  #
-  class Anonymizer
-    include Logging
-
-    # An AuditTrail instance used for this anonymization (if specified).
-    attr_reader :audit_trail
-    # The file name used for the AuditTrail serialization (if specified).
-    attr_reader :audit_trail_file
-    # A boolean that if set as true will cause all anonymized tags to be blank instead of get some generic value.
-    attr_accessor :blank
-    # A boolean that if set as true will cause all anonymized tags to be get enumerated values, to enable post-anonymization identification by the user.
-    attr_accessor :enumeration
-    # The identity file attribute.
-    attr_reader :identity_file
-    # A boolean that if set as true, will make the anonymization delete all private tags.
-    attr_accessor :delete_private
-    # The path where the anonymized files will be saved. If this value is not set, the original DICOM files will be overwritten.
-    attr_accessor :write_path
-    # A boolean indicating whether or not UIDs shall be replaced when executing the anonymization.
-    attr_accessor :uid
-    # The DICOM UID root to use when generating new UIDs.
-    attr_accessor :uid_root
-    # An array of UID tags that will be anonymized if the uid option is used.
-    attr_accessor :uids
-
-    # Creates an Anonymizer instance.
-    #
-    # @note To customize logging behaviour, refer to the Logging module documentation.
-    # @param [Hash] options the options to create an anonymizer instance with
-    # @option options [String] :audit_trail a file name path. If the file contains old audit data, these are loaded and used in the current anonymization.
-    # @option options [Boolean] :uid if true, all (top level) UIDs will be replaced with custom generated UIDs. To preserve UID relations in studies/series, the AuditTrail feature must be used.
-    # @option options [String] :uid_root an organization (or custom) UID root to use when replacing UIDs.
-    # @example Create an Anonymizer instance and restrict the log output
-    #   a = Anonymizer.new
-    #   a.logger.level = Logger::ERROR
-    # @example Perform anonymization using the audit trail feature
-    #   a = Anonymizer.new(:audit_trail => "trail.json")
-    #   a.enumeration = true
-    #   a.folder = "//dicom/today/"
-    #   a.write_path = "//anonymized/"
-    #   a.execute
-    #
-    def initialize(options={})
-      # Default value of accessors:
-      @blank = false
-      @enumeration = false
-      @delete_private = false
-      # Array of folders to be processed for anonymization:
-      @folders = Array.new
-      # Folders that will be skipped:
-      @exceptions = Array.new
-      # Data elements which will be anonymized (the array will hold a list of tag strings):
-      @tags = Array.new
-      # Default values to use on anonymized data elements:
-      @values = Array.new
-      # Which data elements will have enumeration applied, if requested by the user:
-      @enumerations = Array.new
-      # We use a Hash to store information from DICOM files if enumeration is desired:
-      @enum_old_hash = Hash.new
-      @enum_new_hash = Hash.new
-      # 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
-      # Register the uid anonymization option:
-      @uid = options[:uid]
-      # Set the uid_root to be used when anonymizing study_uid series_uid and sop_instance_uid
-      @uid_root = options[:uid_root] ? options[:uid_root] : UID_ROOT
-      # Setup audit trail if requested:
-      if options[:audit_trail]
-        @audit_trail_file = options[:audit_trail]
-        if File.exists?(@audit_trail_file) && File.size(@audit_trail_file) > 2
-          # Load the pre-existing audit trail from file:
-          @audit_trail = AuditTrail.read(@audit_trail_file)
-        else
-          # Start from scratch with an empty audit trail:
-          @audit_trail = AuditTrail.new
-        end
-      end
-      # Set the default data elements to be anonymized:
-      set_defaults
-    end
-
-    # Adds an exception folder which will be avoided when anonymizing.
-    #
-    # @param [String] path a path that will be avoided
-    # @example Adding a folder
-    #   a.add_exception("/home/dicom/tutorials/")
-    #
-    def add_exception(path)
-      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.
-    #
-    # @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)
-      raise ArgumentError, "Expected String, got #{path.class}." unless path.is_a?(String)
-      @folders << path
-    end
-
-    # Checks the enumeration status of this tag.
-    #
-    # @param [String] tag a data element tag
-    # @return [Boolean, NilClass] the enumeration status of the tag, or nil if the tag has no match
-    #
-    def enum(tag)
-      raise ArgumentError, "Expected String, got #{tag.class}." unless tag.is_a?(String)
-      raise ArgumentError, "Expected a valid tag of format 'GGGG,EEEE', got #{tag}." unless tag.tag?
-      pos = @tags.index(tag)
-      if pos
-        return @enumerations[pos]
-      else
-        logger.warn("The specified tag (#{tag}) was not found in the list of tags to be anonymized.")
-        return nil
-      end
-    end
-
-    # Executes the anonymization process.
-    #
-    # This method is run when all settings have been finalized for the Anonymization instance.
-    #
-    # @note Only top level data elements are anonymized!
-    #
-    def execute
-      # FIXME: This method has grown a bit lengthy. Perhaps it should be looked at one day.
-      # 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?
-              # Anonymize the desired tags:
-              @tags.each_index do |j|
-                if dcm.exists?(@tags[j])
-                  element = dcm[@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
-              # Handle UIDs if requested:
-              replace_uids(dcm) if @uid
-              # Delete private tags?
-              dcm.delete_private if @delete_private
-              # Delete Tags marked for removal:
-              @delete_tags.each_index do |j|
-                dcm.delete(@delete_tags[j]) if dcm.exists?(@delete_tags[j])
-              end
-              # 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
-          # Has user requested enumeration and specified an identity file in which to store the anonymized values?
-          if @enumeration and @identity_file and !@audit_trail
-            logger.info("Writing identity file.")
-            write_identity_file
-            logger.info("Done")
-          end
-          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
-
-    # Setter method for the identity file.
-    #
-    # @deprecated The identity file feature is deprecated!
-    #   Please use the AuditTrail feature instead.
-    # @param [String] file_name the path of the identity file
-    #
-    def identity_file=(file_name)
-      # Deprecation warning:
-      logger.warn("The identity_file feature of the Anonymization class has been deprecated! Please use the AuditTrail feature instead.")
-      @identity_file = file_name
-    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
-      # 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
-
-    # Removes a tag from the list of tags that will be anonymized.
-    #
-    # @param [String] tag a data element tag
-    # @example Do not anonymize the Patient's Name tag
-    #   a.remove_tag("0010,0010")
-    #
-    def remove_tag(tag)
-      raise ArgumentError, "Expected String, got #{tag.class}." unless tag.is_a?(String)
-      raise ArgumentError, "Expected a valid tag of format 'GGGG,EEEE', got #{tag}." unless tag.tag?
-      pos = @tags.index(tag)
-      if pos
-        @tags.delete_at(pos)
-        @values.delete_at(pos)
-        @enumerations.delete_at(pos)
-      end
-    end
-
-    # Compeletely deletes a tag from the file
-    #
-    # @param [String] tag a data element tag
-    # @example Completely delete the Patient's Name tag from the DICOM files
-    #   a.delete_tag("0010,0010")
-    #
-    def delete_tag(tag)
-      raise ArgumentError, "Expected String, got #{tag.class}." unless tag.is_a?(String)
-      raise ArgumentError, "Expected a valid tag of format 'GGGG,EEEE', got #{tag}." unless tag.tag?
-      @delete_tags.push(tag) if not @delete_tags.include?(tag)
-    end
-
-    # Sets the anonymization settings for the specified tag. If the tag is already present in the list
-    # of tags to be anonymized, its settings are updated, and if not, a new tag entry is created.
-    #
-    # @param [String] tag a data element tag
-    # @param [Hash] options the anonymization settings for the specified tag
-    # @option options [String, Integer, Float] :value the replacement value to be used when anonymizing this data element. Defaults to the pre-existing value and "" for new tags.
-    # @option options [String, Integer, Float] :enum specifies if enumeration is to be used for this tag. Defaults to the pre-existing value and false for new tags.
-    # @example Set the anonymization settings of the Patient's Name tag
-    #   a.set_tag("0010,0010", :value => "MrAnonymous", :enum => true)
-    #
-    def set_tag(tag, options={})
-      raise ArgumentError, "Expected String, got #{tag.class}." unless tag.is_a?(String)
-      raise ArgumentError, "Expected a valid tag of format 'GGGG,EEEE', got #{tag}." unless tag.tag?
-      pos = @tags.index(tag)
-      if pos
-        # Update existing values:
-        @values[pos] = options[:value] if options[:value]
-        @enumerations[pos] = options[:enum] if options[:enum] != nil
-      else
-        # Add new elements:
-        @tags << tag
-        @values << (options[:value] ? options[:value] : default_value(tag))
-        @enumerations << (options[:enum] ? options[:enum] : false)
-      end
-    end
-
-    # Gives the value which will be used when anonymizing this tag.
-    #
-    # @note If enumeration is selected for a string type tag, a number will be
-    #   appended in addition to the string that is returned here.
-    #
-    # @param [String] tag a data element tag
-    # @return [String, Integer, Float, NilClass] the replacement value for the specified tag, or nil if the tag is not matched
-    #
-    def value(tag)
-      raise ArgumentError, "Expected String, got #{tag.class}." unless tag.is_a?(String)
-      raise ArgumentError, "Expected a valid tag of format 'GGGG,EEEE', got #{tag}." unless tag.tag?
-      pos = @tags.index(tag)
-      if pos
-        return @values[pos]
-      else
-        logger.warn("The specified tag (#{tag}) was not found in the list of tags to be anonymized.")
-        return nil
-      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
-
-    # Creates a hash that is used for storing information that is used when enumeration is selected.
-    #
-    def create_enum_hash
-      @enumerations.each_index do |i|
-        @enum_old_hash[@tags[i]] = Array.new
-        @enum_new_hash[@tags[i]] = Array.new
-      end
-    end
-
-    # Determines a default value to use for anonymizing the given tag.
-    #
-    # @param [String] tag a data element tag
-    # @return [String, Integer, Float] the default replacement value for a given tag
-    #
-    def default_value(tag)
-      name, vr = LIBRARY.name_and_vr(tag)
-      conversion = VALUE_CONVERSION[vr] || :to_s
-      case conversion
-      when :to_i then return 0
-      when :to_f then return 0.0
-      else
-        # Assume type is string and return an empty string:
-        return ""
-      end
-    end
-
-    # Handles the enumeration for the given data element tag.
-    # If its value has been encountered before, its corresponding enumerated
-    # replacement value is retrieved, and if a new original value is encountered,
-    # a new enumerated replacement value is found by increasing an index by 1.
-    #
-    # @param [String, Integer, Float] original the original value of the tag to be anonymized
-    # @param [Fixnum] j the index of this tag in the tag-related instance arrays
-    # @return [String, Integer, Float] the replacement value which is used for the anonymization of the tag
-    #
-    def enumerated_value(original, j)
-      # Is enumeration requested for this tag?
-      if @enumerations[j]
-        if @audit_trail
-          # Check if the UID has been encountered already:
-          replacement = @audit_trail.replacement(@tags[j], original)
-          unless replacement
-            # This original value has not been encountered yet. Determine the index to use.
-            index = @audit_trail.records(@tags[j]).length + 1
-            # Create the replacement value:
-            if @values[j].is_a?(String)
-              replacement = @values[j] + index.to_s
-            else
-              replacement = @values[j] + index
-            end
-            # Add this tag record to the audit trail:
-            @audit_trail.add_record(@tags[j], original, replacement)
-          end
-        else
-          # 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(original) == nil
-            # Current value has not been encountered before:
-            replacement = @values[j]+(p_index + 1).to_s
-            # Store value in array (and hash):
-            previous_old << original
-            previous_new << replacement
-            @enum_old_hash[@tags[j]] = previous_old
-            @enum_new_hash[@tags[j]] = previous_new
-          else
-            # Current value has been observed before:
-            replacement = previous_new[previous_old.index(original)]
-          end
-        end
-      else
-        replacement = @values[j]
-      end
-      return replacement
-    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
-      # 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
-
-    # Replaces the UIDs of the given DICOM object.
-    #
-    # @note Empty UIDs are ignored (we don't generate new UIDs for these).
-    # @note If AuditTrail is set, the relationship between old and new UIDs are preserved,
-    #   and the relations between files in a study/series should remain valid.
-    # @param [DObject] dcm the dicom object to be processed
-    #
-    def replace_uids(dcm)
-      @uids.each_pair do |tag, prefix|
-        original = dcm.value(tag)
-        if original && original.length > 0
-          # We have a UID value, go ahead and replace it:
-          if @audit_trail
-            # Check if the UID has been encountered already:
-            replacement = @audit_trail.replacement(tag, original)
-            unless replacement
-              # The UID has not been stored previously. Generate a new one:
-              replacement = DICOM.generate_uid(@uid_root, prefix)
-              # Add this tag record to the audit trail:
-              @audit_trail.add_record(tag, original, replacement)
-            end
-            # Replace the UID in the DICOM object:
-            dcm[tag].value = replacement
-            # NB! The SOP Instance UID must also be written to the Media Storage SOP Instance UID tag:
-            dcm["0002,0003"].value = replacement if tag == "0008,0018" && dcm.exists?("0002,0003")
-          else
-            # We don't care about preserving UID relations. Just insert a custom UID:
-            dcm[tag].value = DICOM.generate_uid(@uid_root, prefix)
-          end
-        end
-      end
-    end
-
-    # Sets up some default information variables that are used by the Anonymizer.
-    #
-    def set_defaults
-      # A hash of UID tags to be replaced (if requested) and prefixes to use for each tag:
-      @uids = {
-        "0008,0018" => 3, # SOP Instance UID
-        "0020,000D" => 1, # Study Instance UID
-        "0020,000E" => 2, # Series Instance UID
-        "0020,0052" => 9 # Frame of Reference UID
-      }
-      # Sets up default tags that will be anonymized, along with default replacement values and enumeration settings.
-      # This data is stored in 3 separate instance arrays for tags, values and enumeration.
-      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,0050", "", true], # Accession Number
-        ["0008,0080", "Institution", true], # Institution name
-        ["0008,0090", "Physician", true], # Referring Physician's name
-        ["0008,1010", "Station", true], # Station name
-        ["0008,1070", "Operator", true], # Operator's 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]
-      @enumerations = data[2]
-      # Tags to be deleted completely during anonymization:
-      @delete_tags = [
-      ]
-    end
-
-    # Writes an identity file, which allows reidentification of DICOM files that have been anonymized
-    # using the enumeration feature. Values are saved in a text file, using semi colon delineation.
-    #
-    # @deprecated The identity file feature is deprecated!
-    #   Please use the AuditTrail feature instead.
-    #
-    def write_identity_file
-      raise ArgumentError, "Expected String, got #{@identity_file.class}. Unable to write identity file." unless @identity_file.is_a?(String)
-      # Open file and prepare to write text:
-      File.open(@identity_file, 'w') do |output|
-        # Cycle through each
-        @tags.each_index do |i|
-          if @enumerations[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
-        end
-      end
-    end
-  end
-end
+module DICOM
+
+  # This is a convenience class for handling the anonymization
+  # (de-identification) of DICOM files.
+  #
+  # @note
+  #   For a thorough introduction to the concept of DICOM anonymization,
+  #   please refer to The DICOM Standard, Part 15: Security and System
+  #   Management Profiles, Annex E: Attribute Confidentiality Profiles.
+  #   For guidance on settings for individual data elements, please
+  #   refer to DICOM PS 3.15, Annex E, Table E.1-1: Application Level
+  #   Confidentiality Profile Attributes.
+  #
+  class Anonymizer
+    include Logging
+
+    # An AuditTrail instance used for this anonymization (if specified).
+    attr_reader :audit_trail
+    # The file name used for the AuditTrail serialization (if specified).
+    attr_reader :audit_trail_file
+    # A boolean that if set as true will cause all anonymized tags to be blank instead of get some generic value.
+    attr_accessor :blank
+    # An hash of elements (represented by tag keys) that will be deleted from the DICOM objects on anonymization.
+    attr_reader :delete
+    # A boolean that if set as true, will make the anonymization delete all private tags.
+    attr_accessor :delete_private
+    # The cryptographic hash function to be used for encrypting DICOM values recorded in an audit trail file.
+    attr_reader :encryption
+    # A boolean that if set as true will cause all anonymized tags to be get enumerated values, to enable post-anonymization re-identification by the user.
+    attr_accessor :enumeration
+    # The logger level which is applied to DObject operations during anonymization (defaults to Logger::FATAL).
+    attr_reader :logger_level
+    # A boolean that if set as true will cause all anonymized files to be written with random file names (if write_path has been specified).
+    attr_accessor :random_file_name
+    # A boolean that if set as true, will cause the anonymization to run on all levels of the DICOM file tag hierarchy.
+    attr_accessor :recursive
+    # A boolean indicating whether or not UIDs shall be replaced when executing the anonymization.
+    attr_accessor :uid
+    # The DICOM UID root to use when generating new UIDs.
+    attr_accessor :uid_root
+    # The path where the anonymized files will be saved. If this value is not set, the original DICOM files will be overwritten.
+    attr_accessor :write_path
+
+    # Creates an Anonymizer instance.
+    #
+    # @note To customize logging behaviour, refer to the Logging module documentation.
+    # @param [Hash] options the options to create an anonymizer instance with
+    # @option options [String] :audit_trail a file name path (if the file contains old audit data, these are loaded and used in the current anonymization)
+    # @option options [Boolean] :blank toggles whether to set the values of anonymized elements as empty instead of some generic value
+    # @option options [Boolean] :delete_private toggles whether private elements are to be deleted
+    # @option options [TrueClass, Digest::Class] :encryption if set as true, the default hash function (MD5) will be used for representing DICOM values in an audit file. Otherwise a Digest class can be given, e.g. Digest::SHA256
+    # @option options [Boolean] :enumeration toggles whether (some) elements get enumerated values (to enable post-anonymization re-identification)
+    # @option options [Fixnum] :logger_level the logger level which is applied to DObject operations during anonymization (defaults to Logger::FATAL)
+    # @option options [Boolean] :random_file_name toggles whether anonymized files will be given random file names when rewritten (in combination with the :write_path option)
+    # @option options [Boolean] :recursive toggles whether to anonymize on all sub-levels of the DICOM object tag hierarchies
+    # @option options [Boolean] :uid toggles whether UIDs will be replaced with custom generated UIDs (beware that to preserve UID relations in studies/series, the audit_trail feature must be used)
+    # @option options [String] :uid_root an organization (or custom) UID root to use when replacing UIDs
+    # @option options [String] :write_path a directory where the anonymized files are re-written (if not specified, files are overwritten)
+    # @example Create an Anonymizer instance and increase the log output
+    #   a = Anonymizer.new
+    #   a.logger.level = Logger::INFO
+    # @example Perform anonymization using the audit trail feature
+    #   a = Anonymizer.new(:audit_trail => 'trail.json')
+    #   a.enumeration = true
+    #   a.write_path = '//anonymized/'
+    #   a.anonymize('//dicom/today/')
+    #
+    def initialize(options={})
+      # Transfer options to attributes:
+      @blank = options[:blank]
+      @delete_private = options[:delete_private]
+      @enumeration = options[:enumeration]
+      @logger_level = options[:logger_level] || Logger::FATAL
+      @random_file_name = options[:random_file_name]
+      @recursive = options[:recursive]
+      @uid = options[:uid]
+      @uid_root = options[:uid_root] ? options[:uid_root] : UID_ROOT
+      @write_path = options[:write_path]
+      # Array of folders to be processed for anonymization:
+      @folders = Array.new
+      # Folders that will be skipped:
+      @exceptions = Array.new
+      # Data elements which will be anonymized (the array will hold a list of tag strings):
+      @tags = Array.new
+      # Default values to use on anonymized data elements:
+      @values = Array.new
+      # Which data elements will have enumeration applied, if requested by the user:
+      @enumerations = Array.new
+      # We use a Hash to store information from DICOM files if enumeration is desired:
+      @enum_old_hash = Hash.new
+      @enum_new_hash = Hash.new
+      # All the files to be anonymized will be put in this array:
+      @files = Array.new
+      @prefixes = Hash.new
+      # Setup audit trail if requested:
+      if options[:audit_trail]
+        @audit_trail_file = options[:audit_trail]
+        if File.exists?(@audit_trail_file) && File.size(@audit_trail_file) > 2
+          # Load the pre-existing audit trail from file:
+          @audit_trail = AuditTrail.read(@audit_trail_file)
+        else
+          # Start from scratch with an empty audit trail:
+          @audit_trail = AuditTrail.new
+        end
+        # Set up encryption if indicated:
+        if options[:encryption]
+          require 'digest'
+          if options[:encryption].respond_to?(:hexdigest)
+            @encryption = options[:encryption]
+          else
+            @encryption = Digest::MD5
+          end
+        end
+      end
+      # Set the default data elements to be anonymized:
+      set_defaults
+    end
+
+    # Checks for equality.
+    #
+    # Other and self are considered equivalent if they are
+    # of compatible types and their attributes are equivalent.
+    #
+    # @param other an object to be compared with self.
+    # @return [Boolean] true if self and other are considered equivalent
+    #
+    def ==(other)
+      if other.respond_to?(:to_anonymizer)
+        other.send(:state) == state
+      end
+    end
+
+    alias_method :eql?, :==
+
+    # Anonymizes the given DICOM data with the settings of this Anonymizer instance.
+    #
+    # @param [String, DObject, Array<String, DObject>] data single or multiple DICOM data (directories, file paths, binary strings, DICOM objects)
+    # @return [Array<DObject>] an array of the anonymized DICOM objects
+    #
+    def anonymize(data)
+      dicom = prepare(data)
+      if @tags.length > 0
+        dicom.each do |dcm|
+          anonymize_dcm(dcm)
+          # Write DICOM object to file unless it was passed to the anonymizer as an object:
+          write(dcm) unless dcm.was_dcm_on_input
+        end
+      else
+        logger.warn("No tags have been selected for anonymization. Aborting anonymization.")
+      end
+      # Reset the ruby-dicom log threshold to its original level:
+      logger.level = @original_level
+      # Save the audit trail (if used):
+      @audit_trail.write(@audit_trail_file) if @audit_trail
+      logger.info("Anonymization complete.")
+      dicom
+    end
+
+    # Specifies that the given tag is to be completely deleted
+    # from the anonymized DICOM objects.
+    #
+    # @param [String] tag a data element tag
+    # @example Completely delete the Patient's Name tag from the DICOM files
+    #   a.delete_tag('0010,0010')
+    #
+    def delete_tag(tag)
+      raise ArgumentError, "Expected String, got #{tag.class}." unless tag.is_a?(String)
+      raise ArgumentError, "Expected a valid tag of format 'GGGG,EEEE', got #{tag}." unless tag.tag?
+      @delete[tag] = true
+    end
+
+    # Checks the enumeration status of this tag.
+    #
+    # @param [String] tag a data element tag
+    # @return [Boolean, NilClass] the enumeration status of the tag, or nil if the tag has no match
+    #
+    def enum(tag)
+      raise ArgumentError, "Expected String, got #{tag.class}." unless tag.is_a?(String)
+      raise ArgumentError, "Expected a valid tag of format 'GGGG,EEEE', got #{tag}." unless tag.tag?
+      pos = @tags.index(tag)
+      if pos
+        return @enumerations[pos]
+      else
+        logger.warn("The specified tag (#{tag}) was not found in the list of tags to be anonymized.")
+        return nil
+      end
+    end
+
+    # Computes a hash code for this object.
+    #
+    # @note Two objects with the same attributes will have the same hash code.
+    #
+    # @return [Fixnum] the object's hash code
+    #
+    def hash
+      state.hash
+    end
+
+    # Removes a tag from the list of tags that will be anonymized.
+    #
+    # @param [String] tag a data element tag
+    # @example Do not anonymize the Patient's Name tag
+    #   a.remove_tag('0010,0010')
+    #
+    def remove_tag(tag)
+      raise ArgumentError, "Expected String, got #{tag.class}." unless tag.is_a?(String)
+      raise ArgumentError, "Expected a valid tag of format 'GGGG,EEEE', got #{tag}." unless tag.tag?
+      pos = @tags.index(tag)
+      if pos
+        @tags.delete_at(pos)
+        @values.delete_at(pos)
+        @enumerations.delete_at(pos)
+      end
+    end
+
+    # Sets the anonymization settings for the specified tag. If the tag is already present in the list
+    # of tags to be anonymized, its settings are updated, and if not, a new tag entry is created.
+    #
+    # @param [String] tag a data element tag
+    # @param [Hash] options the anonymization settings for the specified tag
+    # @option options [String, Integer, Float] :value the replacement value to be used when anonymizing this data element. Defaults to the pre-existing value and '' for new tags.
+    # @option options [String, Integer, Float] :enum specifies if enumeration is to be used for this tag. Defaults to the pre-existing value and false for new tags.
+    # @example Set the anonymization settings of the Patient's Name tag
+    #   a.set_tag('0010,0010', :value => 'MrAnonymous', :enum => true)
+    #
+    def set_tag(tag, options={})
+      raise ArgumentError, "Expected String, got #{tag.class}." unless tag.is_a?(String)
+      raise ArgumentError, "Expected a valid tag of format 'GGGG,EEEE', got #{tag}." unless tag.tag?
+      pos = @tags.index(tag)
+      if pos
+        # Update existing values:
+        @values[pos] = options[:value] if options[:value]
+        @enumerations[pos] = options[:enum] if options[:enum] != nil
+      else
+        # Add new elements:
+        @tags << tag
+        @values << (options[:value] ? options[:value] : default_value(tag))
+        @enumerations << (options[:enum] ? options[:enum] : false)
+      end
+    end
+
+    # Returns self.
+    #
+    # @return [Anonymizer] self
+    #
+    def to_anonymizer
+      self
+    end
+
+    # Gives the value which will be used when anonymizing this tag.
+    #
+    # @note If enumeration is selected for a string type tag, a number will be
+    #   appended in addition to the string that is returned here.
+    #
+    # @param [String] tag a data element tag
+    # @return [String, Integer, Float, NilClass] the replacement value for the specified tag, or nil if the tag is not matched
+    #
+    def value(tag)
+      raise ArgumentError, "Expected String, got #{tag.class}." unless tag.is_a?(String)
+      raise ArgumentError, "Expected a valid tag of format 'GGGG,EEEE', got #{tag}." unless tag.tag?
+      pos = @tags.index(tag)
+      if pos
+        return @values[pos]
+      else
+        logger.warn("The specified tag (#{tag}) was not found in the list of tags to be anonymized.")
+        return nil
+      end
+    end
+
+
+    private
+
+
+    # Performs anonymization on a DICOM object.
+    #
+    # @param [DObject] dcm a DICOM object
+    #
+    def anonymize_dcm(dcm)
+      # Extract the data element parents to investigate:
+      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'))
+      # Add a De-Identification Method Code Sequence Item:
+      dcm.add(Sequence.new('0012,0064')) unless dcm.exists?('0012,0064')
+      i = dcm['0012,0064'].add_item
+      i.add(Element.new('0012,0063', 'De-identified by the ruby-dicom Anonymizer'))
+      # FIXME: At some point we should add a set of de-indentification method codes, as per
+      #   DICOM PS 3.16 CID 7050 which corresponds to the settings chosen for the anonymizer.
+      # Delete the old File Meta Information group (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 if indicated:
+      dcm.delete_private if @delete_private
+    end
+
+    # Gives the value to be used for the audit trail, which is either
+    # the original value itself, or an encrypted string based on it.
+    #
+    # @param [String, Integer, Float] original the original value of the tag to be anonymized
+    # @return [String, Integer, Float] with encryption, a hash string is returned, otherwise the original value
+    #
+    def at_value(original)
+      @encryption ? @encryption.hexdigest(original) : original
+    end
+
+    # Creates a hash that is used for storing information that is used when enumeration is selected.
+    #
+    def create_enum_hash
+      @enumerations.each_index do |i|
+        @enum_old_hash[@tags[i]] = Array.new
+        @enum_new_hash[@tags[i]] = Array.new
+      end
+    end
+
+    # Determines a default value to use for anonymizing the given tag.
+    #
+    # @param [String] tag a data element tag
+    # @return [String, Integer, Float] the default replacement value for a given tag
+    #
+    def default_value(tag)
+      name, vr = LIBRARY.name_and_vr(tag)
+      conversion = VALUE_CONVERSION[vr] || :to_s
+      case conversion
+      when :to_i then return 0
+      when :to_f then return 0.0
+      else
+        # Assume type is string and return an empty string:
+        return ''
+      end
+    end
+
+    # Creates a write path for the given DICOM object, based on the object's
+    # original file path and the write_path attribute.
+    #
+    # @param [DObject] dcm a DICOM object
+    # @return [String] the destination directory path
+    #
+    def destination(dcm)
+      # Split the source path into dir and file:
+      source_dir = File.dirname(dcm.source)
+      source_folders = source_dir.split(File::SEPARATOR)
+      target_folders = @write_path.split(File::SEPARATOR)
+      # If the first element is the current dir symbol, get rid of it:
+      source_folders.delete('.')
+      # Check for equalness of folder names in a range limited by the shortest array:
+      common_length = [source_folders.length, target_folders.length].min
+      uncommon_index = nil
+      common_length.times do |i|
+        if target_folders[i] != source_folders[i]
+          uncommon_index = i
+          break
+        end
+      end
+      # Create the output path by joining the two paths together using the determined index:
+      append_path = uncommon_index ? source_folders[uncommon_index..-1] : nil
+      [target_folders, append_path].compact.join(File::SEPARATOR)
+    end
+
+    # Extracts all parents from a DObject instance which potentially
+    # have child (data) elements. This typically means the DObject
+    # instance itself as well as items (i.e. not sequences).
+    # Note that unless the @recursive attribute has been set,
+    # this method will only return the DObject (placed inside an array).
+    #
+    # @param [DObject] dcm a DICOM object
+    # @return [Array<DObject, Item>] an array containing either just a DObject or also all parental child items within the tag hierarchy
+    #
+    def element_parents(dcm)
+      parents = Array.new
+      parents << dcm
+      if @recursive
+        dcm.sequences.each do |s|
+          parents += element_parents_recursive(s)
+        end
+      end
+      parents
+    end
+
+    # Recursively extracts all item parents from a sequence instance (including
+    # any sub-sequences) which actually contain child (data) elements.
+    #
+    # @param [Sequence] sequence a Sequence instance
+    # @return [Array<Item>] an array containing items within the tag hierarchy that contains child elements
+    #
+    def element_parents_recursive(sequence)
+      parents = Array.new
+      sequence.items.each do |i|
+        parents << i if i.elements?
+        i.sequences.each do |s|
+          parents += element_parents_recursive(s)
+        end
+      end
+      parents
+    end
+
+    # Handles the enumeration for the given data element tag.
+    # If its value has been encountered before, its corresponding enumerated
+    # replacement value is retrieved, and if a new original value is encountered,
+    # a new enumerated replacement value is found by increasing an index by 1.
+    #
+    # @param [String, Integer, Float] original the original value of the tag to be anonymized
+    # @param [Fixnum] j the index of this tag in the tag-related instance arrays
+    # @return [String, Integer, Float] the replacement value which is used for the anonymization of the tag
+    #
+    def enumerated_value(original, j)
+      # Is enumeration requested for this tag?
+      if @enumerations[j]
+        if @audit_trail
+          # Check if the UID has been encountered already:
+          replacement = @audit_trail.replacement(@tags[j], at_value(original))
+          unless replacement
+            # This original value has not been encountered yet. Determine the index to use.
+            index = @audit_trail.records(@tags[j]).length + 1
+            # Create the replacement value:
+            if @values[j].is_a?(String)
+              replacement = @values[j] + index.to_s
+            else
+              replacement = @values[j] + index
+            end
+            # Add this tag record to the audit trail:
+            @audit_trail.add_record(@tags[j], at_value(original), replacement)
+          end
+        else
+          # 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(original) == nil
+            # Current value has not been encountered before:
+            replacement = @values[j]+(p_index + 1).to_s
+            # Store value in array (and hash):
+            previous_old << original
+            previous_new << replacement
+            @enum_old_hash[@tags[j]] = previous_old
+            @enum_new_hash[@tags[j]] = previous_new
+          else
+            # Current value has been observed before:
+            replacement = previous_new[previous_old.index(original)]
+          end
+        end
+      else
+        replacement = @values[j]
+      end
+      return replacement
+    end
+
+    # Establishes a prefix for a given UID tag.
+    # This makes it somewhat easier to distinguish
+    # between different types of random generated UIDs.
+    #
+    # @param [String] tag a data element string tag
+    #
+    def prefix(tag)
+      if @prefixes[tag]
+        @prefixes[tag]
+      else
+        @prefixes[tag] = @prefixes.length + 1
+        @prefixes[tag]
+      end
+    end
+
+    # Prepares the data for anonymization.
+    #
+    # @param [String, DObject, Array<String, DObject>] data single or multiple DICOM data (directories, file paths, binary strings, DICOM objects)
+    # @return [Array] the original data (wrapped in an array) as well as an array of loaded DObject instances
+    #
+    def prepare(data)
+      logger.info("Loading DICOM data.")
+      # Temporarily adjust the ruby-dicom log threshold (usually to suppress messages from the DObject class):
+      @original_level = logger.level
+      logger.level = @logger_level
+      dicom = DICOM.load(data)
+      logger.level = @original_level
+      logger.info("#{dicom.length} DICOM objects have been prepared for anonymization.")
+      logger.level = @logger_level
+      # Set up enumeration if requested:
+      create_enum_hash if @enumeration
+      require 'securerandom' if @random_file_name
+      dicom
+    end
+
+    # Replaces the UIDs of the given DICOM object.
+    #
+    # @note Empty UIDs are ignored (we don't generate new UIDs for these).
+    # @note If AuditTrail is set, the relationship between old and new UIDs are preserved,
+    #   and the relations between files in a study/series should remain valid.
+    # @param [Array<DObject, Item>] parents dicom parent objects who's child elements will be investigated
+    #
+    def replace_uids(parents)
+      parents.each do |parent|
+        parent.each_element do |element|
+          if element.vr == ('UI') and !@static_uids[element.tag]
+            original = element.value
+            if original && original.length > 0
+              # We have a UID value, go ahead and replace it:
+              if @audit_trail
+                # Check if the UID has been encountered already:
+                replacement = @audit_trail.replacement('uids', original)
+                unless replacement
+                  # The UID has not been stored previously. Generate a new one:
+                  replacement = DICOM.generate_uid(@uid_root, prefix(element.tag))
+                  # Add this tag record to the audit trail:
+                  @audit_trail.add_record('uids', original, replacement)
+                end
+                # Replace the UID in the DICOM object:
+                element.value = replacement
+              else
+                # We don't care about preserving UID relations. Just insert a custom UID:
+                element.value = DICOM.generate_uid(@uid_root, prefix(element.tag))
+              end
+            end
+          end
+        end
+      end
+    end
+
+    # Sets up some default information variables that are used by the Anonymizer.
+    #
+    def set_defaults
+      # Some UIDs should not be remapped even if uid anonymization has been requested:
+      @static_uids = {
+        # Private related:
+        '0002,0100' => true,
+        '0004,1432' => true,
+        # Coding scheme related:
+        '0008,010C' => true,
+        '0008,010D' => true,
+        # Transfer syntax related:
+        '0002,0010' => true,
+        '0400,0010' => true,
+        '0400,0510' => true,
+        '0004,1512' => true,
+        # SOP class related:
+        '0000,0002' => true,
+        '0000,0003' => true,
+        '0002,0002' => true,
+        '0004,1510' => true,
+        '0004,151A' => true,
+        '0008,0016' => true,
+        '0008,001A' => true,
+        '0008,001B' => true,
+        '0008,0062' => true,
+        '0008,1150' => true,
+        '0008,115A' => true
+      }
+      # Sets up default tags that will be anonymized, along with default replacement values and enumeration settings.
+      # This data is stored in 3 separate instance arrays for tags, values and enumeration.
+      data = [
+        ['0008,0012', '20000101', false], # Instance Creation Date
+        ['0008,0013', '000000.00', false], # Instance Creation Time
+        ['0008,0020', '20000101', false], # Study Date
+        ['0008,0021', '20000101', false], # Series Date
+        ['0008,0022', '20000101', false], # Acquisition Date
+        ['0008,0023', '20000101', false], # Image Date
+        ['0008,0030', '000000.00', false], # Study Time
+        ['0008,0031', '000000.00', false], # Series Time
+        ['0008,0032', '000000.00', false], # Acquisition Time
+        ['0008,0033', '000000.00', false], # Image Time
+        ['0008,0050', '', true], # Accession Number
+        ['0008,0080', 'Institution', true], # Institution name
+        ['0008,0081', 'Address', true], # Institution Address
+        ['0008,0090', 'Physician', true], # Referring Physician's name
+        ['0008,1010', 'Station', true], # Station name
+        ['0008,1040', 'Department', true], # Institutional Department name
+        ['0008,1070', 'Operator', true], # Operator's 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', 'O', false], # Patient's Sex
+        ['0010,1010', '', false], # Patient's Age
+        ['0020,4000', '', false], # Image Comments
+      ].transpose
+      @tags = data[0]
+      @values = data[1]
+      @enumerations = data[2]
+      # Tags to be deleted completely during anonymization:
+      @delete = Hash.new
+    end
+
+    # Collects the attributes of this instance.
+    #
+    # @return [Array] an array of attributes
+    #
+    def state
+       [
+        @tags, @values, @enumerations, @delete, @blank,
+        @delete_private, @enumeration, @logger_level,
+        @random_file_name, @recursive, @uid, @uid_root, @write_path
+       ]
+    end
+
+    # Writes a DICOM object to file.
+    #
+    # @param [DObject] dcm a DICOM object
+    #
+    def write(dcm)
+      if @write_path
+        # The DICOM object is to be written to a separate directory. If the
+        # original and the new directories have a common root, this is taken into
+        # consideration when determining the object's write path:
+        path = destination(dcm)
+        if @random_file_name
+          file_name = "#{SecureRandom.hex(16)}.dcm"
+        else
+          file_name = File.basename(dcm.source)
+        end
+        dcm.write(File.join(path, file_name))
+      else
+        # The original DICOM file is overwritten with the anonymized DICOM object:
+        dcm.write(dcm.source)
+      end
+    end
+
+  end
+
+end