dicom 0.5 → 0.6

data/CHANGELOG

@@ -1,3 +1,16 @@
+= 0.6
+
+=== 13th August, 2009
+
+* Complete rewrite of encoding/decoding to reduce code duplication and simplify the code.
+* General optimizations to improve speed and reduce code complexity.
+* Rewrote Dictionary to use Hash instead of Array. This has significantly improved the read spead of the library.
+* Ruby DICOM now automatically strips away trailing whitespace when decoding string values.
+* Introducing basic, experimental network functionality.
+* The new DClient class enables features such as query, move and send.
+* The new DServer class presents the ability to set up a simple storage server (Service Class Provider).
+
+
 = 0.5
 
 === 4th May, 2009
@@ -14,7 +27,7 @@
 * Several methods have been made more robust.
 * Added new keyword :partial to the get_pos() method, which will enable search for partial string matches.
 * Added new keyword :array to the get_value() and get_raw() methods which enables easy extraction of
-  multiple values of a given tag to an array (relevant for tags present at multiple places in a DICOM file)
+  multiple values of a given tag to an array (relevant for tags present at multiple places in a DICOM file).
 * Fixed a bug where exception folders where ignored in the Anonymizer class.
 
 
@@ -75,7 +88,9 @@
 === 20th July, 2008
 
 First public release.
-The library does have several known issues and lacks some features I would like it to have, but it does offer basic functionality and should be usable for people interested in working with DICOM files in Ruby. The reading algorithm has been tested succesfully with some 40 different DICOM files, so it should be fairly robust.
+The library does have several known issues and lacks some features I would like it to have, but it does
+offer basic functionality and should be usable for people interested in working with DICOM files in Ruby.
+The reading algorithm has been tested succesfully with some 40 different DICOM files, so it should be fairly robust.
 
 Features:
 * Reads DICOM files
@@ -88,8 +103,9 @@ Features:
 
 
 Known issues:
-* 12 bit image data not supported
-* Color images not supported in NArray and RMagick retrieve methods
+* Network communication is highly experimental.
+* 12 bit image data not supported.
+* Color images not supported in NArray and RMagick retrieve methods.
 * Unpacking compressed image data has basic support but is not properly tested yet.
 * Reading Big Endian files has fairly good, but possibly not full, support.
 * Reading on a Big Endian system is not tested.

data/DOCUMENTATION

@@ -1,4 +1,5 @@
-DICOM is a small library for reading, editing and writing DICOM files.
+DICOM is a small and simple library for handling DICOM files (reading, editing
+and writing) and DICOM network communication (both client and server side).
 It is written completely in Ruby and has no external dependencies.
 
 Copyright 2008-2009 Christoffer Lerv�g (chris.lervag [@nospam] @gmail.com)
@@ -251,3 +252,172 @@ PUBLIC INSTANCE METHODS
 			a.remove_tag("0010,0010")
 
 
+CLASS DClient
+
+PUBLIC CLASS METHODS
+
+  new(host_ip, port, options={})
+    Initialize a new DClient instance.
+    Example:
+      node = DICOM::DClient.new("10.1.25.200", 104)
+
+ACCESSORS (Read & write)
+  :ae
+    Calling application entity (name of the service class user - client).
+  :host_ae
+    Called application entity (name of the service class provider - server).
+  :host_ip
+    The host (server) ip adress.
+  :max_package_size
+    Maximum size of transferred network packages.
+  :port
+    Port number to be used in the network communication.
+  :timeout
+    Timeout (in seconds) to be used in the network communication.
+  :verbose
+    Verbosity with regards to notices and error messages (true or false).
+ACCESSORS (Read only)
+  :command_results
+    An array holding any received command results.
+  :data_results
+    An array holding any received data results.
+  :errors
+    An array holding any error messages that have occurred in this session.
+  :notices
+    An array holding any informational messages presented in this session.
+
+PUBLIC INSTANCE METHODS
+
+  get_image(path, options={})
+    Retrieve a DICOM image file from a server (C-GET-RQ) (this method is probably not working yet).
+    Accepted options:
+      "0008,0018" (SOP Instance UID)
+      "0008,0052" (Query/Retrieve Level)
+      "0020,000D" (Study Instance UID)
+      "0020,000E" (Series Instance UID)
+    Example:
+      node.get_image("/home/dicom/", "0008,0018" => sop_uid, "0020,000D" => study_uid, "0020,000E" => series_uid)
+
+  find_images(options={})
+    Query a server for DICOM images that matches your specified criteria.
+    Accepted options:
+      "0008,0018" (SOP Instance UID)
+      "0008,0052" (Query/Retrieve Level)
+      "0020,000D" (Study Instance UID)
+      "0020,000E" (Series Instance UID)
+      "0020,0013" (Instance Number)
+    Example:
+      find_images("0010,0020" => patient_id, "0020,000D" => study_uid, "0020,000E" => series_uid)
+
+  find_patients(options={})
+    Query a server for patients that matches your specified criteria.
+    Accepted options:
+      "0008,0052" (Query/Retrieve Level)
+      "0010,0010" (Patient's Name)
+      "0010,0020" (Patient ID)
+      "0010,0030" (Patient's Birth Date)
+      "0010,0040" (Patient's Sex)
+    Example:
+      find_patients("0010,0010" => "James*")
+
+  find_series(options={})
+    Query a server for series that matches your specified criteria.
+    Accepted options:
+      "0008,0052" (Query/Retrieve Level)
+      "0008,0060" (Modality)
+      "0008,103E" (Series Description)
+      "0020,000D" (Study Instance UID)
+      "0020,000E" (Series Instance UID)
+      "0020,0011" (Series Number)
+    Example:
+      find_series("0010,0020" => patient_id, "0020,000D" => study_uid)
+
+  find_studies(options={})
+    Query a server for studies that matches your specified criteria.
+    Accepted options:
+      "0008,0020" (Study Date)
+      "0008,0030" (Study Time)
+      "0008,0050" (Accession Number)
+      "0008,0052" (Query/Retrieve Level)
+      "0008,0090" (Referring Physician's Name)
+      "0008,1030" (Study Description)
+      "0008,1060" (Name of Physician(s) Reading Study)
+      "0010,0010" (Patient's Name)
+      "0010,0020" (Patient ID)
+      "0010,0030" (Patient's Birth Date)
+      "0010,0040" (Patient's Sex)
+      "0020,000D" (Study Instance UID)
+      "0020,0010" (Study ID)
+    Example:
+      find_studies("0008,0020" => study_date, "0010,000D" => patient_id)
+
+  move_image(destination, options={})
+    Move an image to a dicom node other than yourself.
+    Accepted options:
+      "0008,0018" (SOP Instance UID)
+      "0008,0052" (Query/Retrieve Level)
+      "0020,000D" (Study Instance UID)
+      "0020,000E" (Series Instance UID)
+    Example:
+      move_image("MYDICOM", "0008,0018" => sop_uid, "0020,000D" => study_uid, "0020,000E" => series_uid)
+
+  move_study(destination, options={})
+    Move an entire study to a dicom node other than yourself.
+    Accepted options:
+      "0008,0052" (Query/Retrieve Level)
+      "0010,0020" (Patient ID)
+      "0020,000D" (Study Instance UID)
+    Example:
+      move_study("MYDICOM", "0010,0020" => patient_id, "0020,000D" => study_uid)
+
+  send(file_path)
+    Send a DICOM file to a service class provider (SCP/PACS).
+    Example:
+      send("myFile.dcm")
+
+  test
+    Tests a connection with your DICOM server by trying a simple association.
+
+
+CLASS DServer
+
+PUBLIC CLASS METHODS
+
+  new(port, options={})
+    Initialize a new DServer instance.
+    Example:
+      node = DICOM::DServer.new(104)
+
+ACCESSORS (Read & write)
+  :host_ae
+    Called application entity (name of the service class provider - server).
+  :max_package_size
+    Maximum size of transferred network packages.
+  :port
+    Port number to be used in the network communication.
+  :timeout
+    Timeout (in seconds) to be used in the network communication.
+  :verbose
+    Verbosity with regards to notices and error messages (true or false).
+ACCESSORS (Read only)
+  :errors
+    An array holding any error messages that have occurred in this session.
+  :notices
+    An array holding any informational messages presented in this session.
+
+PUBLIC INSTANCE METHODS
+
+  add_abstract_syntax(value)
+    Adds a specified abstract syntax to the list of syntaxes that is accepted by the server.
+
+  print_syntaxes
+    Prints the list of abstract syntaxes that is accepted by the server.
+
+  remove_abstract_syntax(value)
+    Removes a specified abstract syntax from the list of syntaxes that is accepted by the server.
+
+  remove_all_abstract_syntaxes
+    Completely clears the list of syntaxes that the server instance will accept.
+
+  start_scp(path)
+    Launch the simple storage server (Storage Content Provider - SCP)

data/README

@@ -4,12 +4,17 @@ RUBY DICOM
 SUMMARY
 --------
 
-This is a fairly basic library for handling DICOM files in Ruby. Digital Imaging and Communications in Medicine (DICOM) is a standard for handling, storing, printing, and transmitting information in medical imaging. It includes a file format definition and a network communications protocol. Ruby DICOM supports reading from, editing and writing to this file format.
+This is a small and simple library for handling DICOM in Ruby. DICOM (Digital Imaging
+and Communications in Medicine) is a standard for handling, storing, printing,
+and transmitting information in medical imaging. It includes a file format definition
+and a network communications protocol. Ruby DICOM supports reading from, editing and
+writing to this file format. It also features experimental support for network
+communication modalities like query, move and send.
 
 BASIC USAGE
 -----------
 
-require 'dicom'
+require "dicom"
 # Read file:
 dcm = DICOM::DObject.new("myFile.dcm")
 # Display some key information about the file:
@@ -26,6 +31,9 @@ image[0].display
 # Load pixel data to a NArray object and display it on screen:
 image = dcm.get_image_narray()
 NImage.show image[0,true,true]
+# Send a local file to a server (PACS) over the network:
+node = DICOM::DClient.new("10.1.25.200", 104)
+node.send("myFile.dcm")
 
 Tip:
 When playing around with Ruby DICOM in irb, you may be annoyed
@@ -66,5 +74,5 @@ Oslo, Norway
 
 Email:
 chris.lervag [@nospam] @gmail.com
-Please don't hesitate to email me if have any thoughts on this project!
+Please don't hesitate to email me if have any thoughts about this project!
 

data/lib/DClient.rb

@@ -0,0 +1,579 @@
+#    Copyright 2009 Christoffer Lervag
+
+module DICOM
+
+  # This class contains code for handling the client side of DICOM TCP/IP network communication.
+  class DClient
+
+    attr_accessor :ae, :host_ae, :host_ip, :max_package_size, :port, :timeout, :verbose
+    attr_reader :command_results, :data_results, :errors, :notices
+
+    # Initialize the instance with a host adress and a port number.
+    def initialize(host_ip, port, options={})
+      require 'socket'
+      # Required parameters:
+      @host_ip = host_ip
+      @port = port
+      # Optional parameters (and default values):
+      @ae =  options[:ae]  || "RUBY_DICOM"
+      @lib =  options[:lib]  || DLibrary.new
+      @host_ae =  options[:host_ae]  || "DEFAULT"
+      @max_package_size = options[:max_package_size] || 32768 # 16384
+      @timeout = options[:timeout] || 10 # seconds
+      @min_length = 12 # minimum number of bytes to expect in an incoming transmission
+      @verbose = options[:verbose]
+      @verbose = true if @verbose == nil # Default verbosity is 'on'.
+      # Other instance variables:
+      @errors = Array.new # errors and warnings are put in this array
+      @notices = Array.new # information on successful transmissions are put in this array
+      # Variables used for monitoring state of transmission:
+      @connection = nil # TCP connection status
+      @association = nil # DICOM Association status
+      @request_approved = nil # Status of our DICOM request
+      @release = nil # Status of received, valid release response
+      # Results from a query:
+      @command_results = Array.new
+      @data_results = Array.new
+      # Set default values like transfer syntax, user information, endianness:
+      set_default_values
+      set_user_information_array
+      # Initialize the network package handler:
+      @link = Link.new(:ae => @ae, :host_ae => @host_ae, :max_package_size => @max_package_size, :timeout => @timeout)
+    end
+
+
+    # Retrieve a dicom file from a service class provider (SCP/PACS).
+    # Example:  get_image("c:/dicom/", "0008,0018" => sop_uid, "0020,000D" => study_uid, "0020,000E" => series_uid)
+    def get_image(path, options={})
+      # Study Root Query/Retrieve Information Model - GET:
+      @abstract_syntax = "1.2.840.10008.5.1.4.1.2.2.3"
+      # Transfer the current options to the data_elements hash:
+      set_command_fragment_get
+      # Prepare data elements for this operation:
+      set_data_fragment_get_image
+      set_data_options(options)
+      perform_get(path)
+    end
+
+
+    # Query a service class provider for images that match the specified criteria.
+    # Example:   find_images("0010,0020" => "123456789", "0020,000D" => "1.2.840.1145.342", "0020,000E" => "1.3.6.1.4.1.2452.6.687844") # (Patient ID, Study Instance UID & Series Instance UID)
+    def find_images(options={})
+      # Study Root Query/Retrieve Information Model - FIND:
+      @abstract_syntax = "1.2.840.10008.5.1.4.1.2.2.1"
+      # Prepare data elements for this operation:
+      set_data_fragment_find_images
+      set_data_options(options)
+      perform_find
+    end
+
+
+    # Query a service class provider for patients that match the specified criteria.
+    # Example:   find_patients("0010,0010" => "James*") # (Patient's Name)
+    def find_patients(options={})
+      # Patient Root Query/Retrieve Information Model - FIND:
+      @abstract_syntax = "1.2.840.10008.5.1.4.1.2.1.1"
+      # Prepare data elements for this operation:
+      set_data_fragment_find_patients
+      set_data_options(options)
+      perform_find
+    end
+
+
+    # Query a service class provider for series that match the specified criteria.
+    # Example:   find_series("0010,0020" => "123456789", "0020,000D" => "1.2.840.1145.342") # (Patient ID & Study Instance UID)
+    def find_series(options={})
+      # Study Root Query/Retrieve Information Model - FIND:
+      @abstract_syntax = "1.2.840.10008.5.1.4.1.2.2.1"
+      # Prepare data elements for this operation:
+      set_data_fragment_find_series
+      set_data_options(options)
+      perform_find
+    end
+
+
+    # Query a service class provider for studies that match the specified criteria.
+    # Example:   find_studies("0008,0020" => "20090604-", "0010,000D" => "123456789") # (Study Date & Patient ID)
+    def find_studies(options={})
+      # Study Root Query/Retrieve Information Model - FIND:
+      @abstract_syntax = "1.2.840.10008.5.1.4.1.2.2.1"
+      # Prepare data elements for this operation:
+      set_data_fragment_find_studies
+      set_data_options(options)
+      perform_find
+    end
+
+
+    # Move an image to a dicom node other than yourself.
+    # Example:  move_image("MYDICOM", "0008,0018" => sop_uid, "0020,000D" => study_uid, "0020,000E" => series_uid)
+    def move_image(destination, options={})
+      # Study Root Query/Retrieve Information Model - MOVE:
+      @abstract_syntax = "1.2.840.10008.5.1.4.1.2.2.2"
+      # Transfer the current options to the data_elements hash:
+      set_command_fragment_move(destination)
+      # Prepare data elements for this operation:
+      set_data_fragment_move_image
+      set_data_options(options)
+      perform_move
+    end
+
+
+    # Move an entire study to a dicom node other than yourself.
+    # Example:  move_study("MYDICOM", "0010,0020" => pat_id, "0020,000D" => study_uid)
+    def move_study(destination, options={})
+      # Study Root Query/Retrieve Information Model - MOVE:
+      @abstract_syntax = "1.2.840.10008.5.1.4.1.2.2.2"
+      # Transfer the current options to the data_elements hash:
+      set_command_fragment_move(destination)
+      # Prepare data elements for this operation:
+      set_data_fragment_move_study
+      set_data_options(options)
+      perform_move
+    end
+
+
+    # Send a DICOM file to a service class provider (SCP/PACS).
+    def send(file_path)
+      # Load the DICOM file from the specified path:
+      obj = DObject.new(file_path, :verbose => false, :lib => @lib)
+      if obj.read_success
+        # Get the SOP Class UID (abstract syntax) from the DICOM obj:
+        @abstract_syntax = obj.get_value("0008,0016")
+        # Get the Transfer Syntax UID from the DICOM obj,
+        # and if not available, set to default: Implicit, Little endian
+        @transfer_syntax = [obj.get_value("0002,0010")] || ["1.2.840.10008.1.2"]
+        # Open a DICOM link:
+        establish_association
+        if @association
+          if @request_approved
+            # Continue with our c-store operation, since our request was accepted.
+            # Prepare the DICOM object for transmission:
+            obj.encode_segments(@max_pdu_length - 14)
+            # Handle the transmission:
+            perform_send(obj)
+          end
+        end
+      else
+        # Failed to read DICOM file. Can not transmit this file.
+        add_error("Error: The supplied file was not recognised as a valid DICOM file. File NOT transmitted. (file: #{file_path}")
+      end
+      # Close the DICOM link:
+      establish_release
+    end
+
+
+    # Tests the connection to the specified host by trying to negotiate an association, then releasing it.
+    def test
+      add_notice("TESTING CONNECTION...")
+      success = false
+      # Verification SOP Class:
+      @abstract_syntax = "1.2.840.10008.1.1"
+      # Open a DICOM link:
+      establish_association
+      if @association
+        if @request_approved
+          success = true
+        end
+        # Close the DICOM link:
+        establish_release
+      end
+      if success
+        add_notice("TEST SUCCSESFUL!")
+      else
+        add_error("TEST FAILED!")
+      end
+      return success
+    end
+
+
+    # Following methods are private:
+    private
+
+
+    # Adds a warning or error message to the instance array holding messages,
+    # and if verbose variable is true, prints the message as well.
+    def add_error(error)
+      puts error if @verbose
+      @errors << error
+    end
+
+
+    # Adds a notice (information regarding progress or successful communications) to the instance array,
+    # and if verbosity is set for these kinds of messages, prints it to the screen as well.
+    def add_notice(notice)
+      puts notice if @verbose
+      @notices << notice
+    end
+
+
+    # Open a TCP session with a specified server, and handle the association request along with its response.
+    def establish_association
+      # Reset some variables:
+      @association = false
+      @request_approved = false
+      # Initiate the association:
+      @link.build_association_request(@application_context_uid, @abstract_syntax, @transfer_syntax, @user_information)
+      @connection = TCPSocket.new(@host_ip, @port)
+      @link.transmit(@connection)
+      info = @link.receive_single_transmission(@connection).first
+      # Interpret the results:
+      if info[:valid]
+        if info[:pdu] == "02"
+          # Values of importance are extracted and put into instance variables:
+          @association = true
+          @max_pdu_length = info[:max_pdu_length]
+          @presentation_context_id = info[:presentation_context_id]
+          add_notice("Association successfully negotiated with host #{host_ae} (#{host_ip}).")
+        else
+          add_error("Association was denied from host #{host_ae} (#{host_ip})!")
+        end
+        if info[:result] == 0
+          @request_approved = true
+          add_notice("Your request was accepted by host #{host_ae} (#{host_ip}).")
+        else
+          add_error("Your request was denied by host #{host_ae} (#{host_ip})!")
+        end
+      end
+    end
+
+
+    # Handle a release request and its response, as well as closing the TCP connection.
+    def establish_release
+      @release = false
+      if @abort
+        @connection.close unless @connection.closed?
+        add_notice("Association has been closed. (#{host_ae}, #{host_ip})")
+      else
+        unless @connection.closed?
+          @link.build_release_request
+          @link.transmit(@connection)
+          info = @link.receive_single_transmission(@connection).first
+          @connection.close
+          if info[:pdu] == "06"
+            add_notice("Association released properly from host #{host_ae} (#{host_ip}).")
+          else
+            add_error("Association was NOT released properly for some reason from host #{host_ae} (#{host_ip})!")
+          end
+        else
+          add_error("Connection was closed by the host (for some unknown reason) before the association could be released properly.")
+        end
+      end
+      @abort = false
+    end
+
+
+    # Handle the communication involved in DICOM query (C-FIND).
+    # Build the necessary strings and send the command and data element that makes up the query.
+    # Listens for and interpretes the incoming query responses.
+    def perform_find
+      # Open a DICOM link:
+      establish_association
+      if @association
+        if @request_approved
+          # Continue with our query, since the request was accepted.
+          # Set the query command elements array:
+          set_command_fragment_find
+          pdu="04"
+          #context = "01"
+          flags = "03"
+          @link.build_command_fragment(pdu, @presentation_context_id, flags, @command_elements)
+          @link.transmit(@connection)
+          @link.build_data_fragment(@data_elements)
+          @link.transmit(@connection)
+          # A query response will typically be sent in multiple, separate packets.
+          # Listen for incoming responses and interpret them individually, until we have received the last command fragment.
+          segments = @link.receive_multiple_transmissions(@connection)
+          process_returned_data(segments)
+        end
+        # Close the DICOM link:
+        establish_release
+      end
+    end
+
+
+    # Build and send command & data fragment, then receive the incoming file data.
+    def perform_get(path)
+      # Open a DICOM link:
+      establish_association
+      if @association
+        if @request_approved
+          # Continue with our operation, since the request was accepted.
+          pdu="04"
+          flags = "03"
+          @link.build_command_fragment(pdu, @presentation_context_id, flags, @command_elements)
+          @link.transmit(@connection)
+          @link.build_data_fragment(@data_elements) # (uses flag = 02)
+          @link.transmit(@connection)
+          # Listen for incoming file data:
+          @link.handle_incoming_data(@connection, path)
+          # Send confirmation response:
+          @link.handle_response(@connection)
+        end
+        # Close the DICOM link:
+        establish_release
+      end
+    end
+
+
+    # Handle the communication involved in DICOM move request.
+    def perform_move
+      # Open a DICOM link:
+      establish_association
+      if @association
+        if @request_approved
+          # Continue with our operation, since the request was accepted.
+          pdu="04"
+          flags = "03"
+          @link.build_command_fragment(pdu, @presentation_context_id, flags, @command_elements)
+          @link.transmit(@connection)
+          flags = "02"
+          @link.build_data_fragment(@data_elements)
+          @link.transmit(@connection)
+          # Receive confirmation response:
+          segments = @link.receive_single_transmission(@connection)
+          process_returned_data(segments)
+        end
+        # Close the DICOM link:
+        establish_release
+      end
+    end
+
+
+    # Builds and sends the command fragment, then builds and sends the data fragments that
+    # conveys the information from the original DICOM file.
+    def perform_send(obj)
+      # Set the command array to be used:
+      sop_uid = obj.get_value("SOP Instance UID") # 0008,0018
+      if sop_uid
+        set_command_fragment_store(sop_uid)
+        pdu_type = "04"
+        flags = "03"
+        @link.build_command_fragment(pdu_type, @presentation_context_id, flags, @command_elements)
+        @link.transmit(@connection)
+        # Transmit all but the last segments:
+        flags = "00"
+        (0..obj.segments.length-2).each do |i|
+          @link.build_storage_fragment(pdu_type, @presentation_context_id, flags, obj.segments[i])
+          @link.transmit(@connection)
+        end
+        # Transmit the last segment:
+        flags = "02"
+        @link.build_storage_fragment(pdu_type, @presentation_context_id, flags, obj.segments.last)
+        @link.transmit(@connection)
+        # Receive confirmation response:
+        segments = @link.receive_single_transmission(@connection)
+        process_returned_data(segments)
+      else
+        add_error("Error: Unable to extract SOP Instance UID for the given DICOM file. File will not be sent to its destination.")
+      end
+    end
+
+
+    # Process the data that was returned from the interaction with the SCP and make it available to the user.
+    def process_returned_data(segments)
+      # Reset command results arrays:
+      @command_results = Array.new
+      @data_results = Array.new
+      # Try to extract data:
+      segments.each do |info|
+        if info[:valid]
+          # Determine if it is command or data:
+          if info[:presentation_context_flag] == "03"
+            # Command (last fragment):
+            @command_results << info[:results]
+          elsif info[:presentation_context_flag] == "02"
+            # Data (last fragment)
+            @data_results << info[:results]
+          end
+        end
+      end
+    end
+
+
+    # Reset the values of a array.
+    # It is assumed the arrays elements are an array in itself, where element[1]
+    # will be reset to the string value "".
+    def reset(array)
+      array.each do |element|
+        element[1] = ""
+      end
+    end
+
+
+    # Set command elements used in a C-GET-RQ:
+    def set_command_fragment_get
+      @command_elements = [
+        ["0000,0002", "UI", @abstract_syntax], # Affected SOP Class UID
+        ["0000,0100", "US", 16], # Command Field: 16 (C-GET-RQ)
+        ["0000,0600", "AE", destination], # Move destination
+        ["0000,0700", "US", 0], # Priority: 0: medium
+        ["0000,0800", "US", 1] # Data Set Type: 1
+      ]
+    end
+
+
+    # Command elements used in a C-FIND-RQ.
+    # This seems to be the same, regardless of what we want to query.
+    def set_command_fragment_find
+      @command_elements = [
+        ["0000,0002", "UI", @abstract_syntax], # Affected SOP Class UID
+        ["0000,0100", "US", 32], # Command Field: 32 (C-FIND-RQ)
+        ["0000,0110", "US", 1], # Message ID: 1
+        ["0000,0700", "US", 0], # Priority: 0: medium
+        ["0000,0800", "US", 1] # Data Set Type: 1
+      ]
+    end
+
+
+    # Set command elements used in a C-MOVE-RQ:
+    def set_command_fragment_move(destination)
+      @command_elements = [
+        ["0000,0002", "UI", @abstract_syntax], # Affected SOP Class UID
+        ["0000,0100", "US", 33], # Command Field: 33 (C-MOVE-RQ)
+        ["0000,0110", "US", 1], # Message ID: 1
+        ["0000,0600", "AE", destination], # Move destination
+        ["0000,0700", "US", 0], # Priority: 0: medium
+        ["0000,0800", "US", 1] # Data Set Type: 1
+      ]
+    end
+
+
+    # Command elements used in a p-data c-store-rq query command:
+    def set_command_fragment_store(sop_uid)
+      @command_elements = [
+        ["0000,0002", "UI", @abstract_syntax], # Affected SOP Class UID
+        ["0000,0100", "US", 1], # Command Field: 1 (C-STORE-RQ)
+        ["0000,0110", "US", 1], # Message ID: 1
+        ["0000,0700", "US", 0], # Priority: 0: medium
+        ["0000,0800", "US", 1], # Data Set Type: 1
+        ["0000,1000", "UI", sop_uid] # Affected SOP Instance UID
+      ]
+    end
+
+
+    # Data elements used in a query for the images of a particular series:
+    def set_data_fragment_find_images
+      @data_elements = [
+        ["0008,0018", ""], # SOP Instance UID
+        ["0008,0052", "IMAGE"], # Query/Retrieve Level:  "IMAGE"
+        ["0020,000D", ""], # Study Instance UID
+        ["0020,000E", ""], # Series Instance UID
+        ["0020,0013", ""] # Instance Number
+      ]
+    end
+
+
+    # Data elements used in a query for patients:
+    def set_data_fragment_find_patients
+      @data_elements = [
+        ["0008,0052", "PATIENT"], # Query/Retrieve Level:  "PATIENT"
+        ["0010,0010", ""], # Patient's Name
+        ["0010,0020", ""], # Patient ID
+        ["0010,0030", ""], # Patient's Birth Date
+        ["0010,0040", ""] # Patient's Sex
+      ]
+    end
+
+
+    # Data elements used in a query for the series of a particular study:
+    def set_data_fragment_find_series
+      @data_elements = [
+        ["0008,0052", "SERIES"], # Query/Retrieve Level: "SERIES"
+        ["0008,0060", ""], # Modality
+        ["0008,103E", ""], # Series Description
+        ["0020,000D", ""], # Study Instance UID
+        ["0020,000E", ""], # Series Instance UID
+        ["0020,0011", ""] # Series Number
+      ]
+    end
+
+
+    # Data elements used in a query for studies:
+    def set_data_fragment_find_studies
+      @data_elements = [
+        ["0008,0020", ""], # Study Date
+        ["0008,0030", ""], # Study Time
+        ["0008,0050", ""], # Accession Number
+        ["0008,0052", "STUDY"], # Query/Retrieve Level:  "STUDY"
+        ["0008,0090", ""], # Referring Physician's Name
+        ["0008,1030", ""], # Study Description
+        ["0008,1060", ""], # Name of Physician(s) Reading Study
+        ["0010,0010", ""], # Patient's Name
+        ["0010,0020", ""], # Patient ID
+        ["0010,0030", ""], # Patient's Birth Date
+        ["0010,0040", ""], # Patient's Sex
+        ["0020,000D", ""], # Study Instance UID
+        ["0020,0010", ""] # Study ID
+      ]
+    end
+
+
+    # Set data elements used for an image C-GET-RQ:
+    def set_data_fragment_get_image
+      @data_elements = [
+        ["0008,0018", ""], # SOP Instance UID
+        ["0008,0052", "IMAGE"], # Query/Retrieve Level:  "IMAGE"
+        ["0020,000D", ""], # Study Instance UID
+        ["0020,000E", ""] # Series Instance UID
+      ]
+    end
+
+
+    # Set data elements used for an image C-MOVE-RQ:
+    def set_data_fragment_move_image
+      @data_elements = [
+        ["0008,0018", ""], # SOP Instance UID
+        ["0008,0052", "IMAGE"], # Query/Retrieve Level:  "IMAGE"
+        ["0020,000D", ""], # Study Instance UID
+        ["0020,000E", ""] # Series Instance UID
+      ]
+    end
+
+
+    # Set data elements used in a study C-MOVE-RQ:
+    def set_data_fragment_move_study
+      @data_elements = [
+        ["0008,0052", "STUDY"], # Query/Retrieve Level:  "STUDY"
+        ["0010,0020", ""], # Patient ID
+        ["0020,000D", ""] # Study Instance UID
+      ]
+    end
+
+
+    # Transfer the user query options to the data elements array.
+    # NB: Only tags which are predefined for the specific query type will be updated
+    # (no new tags are allowed stored among the data elements)
+    def set_data_options(options)
+      options.each_pair do |key, value|
+        tags = @data_elements.transpose[0]
+        i = tags.index(key)
+        if i
+          @data_elements[i][1] = value
+        end
+      end
+    end
+
+
+    # Set default values for accepted transfer syntaxes:
+    def set_default_values
+      # DICOM Application Context Name (unknown if this will vary or is always the same):
+      @application_context_uid = "1.2.840.10008.3.1.1.1"
+      # Transfer syntax (preferred syntax appearing first)
+      @transfer_syntax = ["1.2.840.10008.1.2.1", # Explicit VR Little Endian
+        "1.2.840.10008.1.2.2", # Explicit VR Big Endian
+        "1.2.840.10008.1.2" # Implicit VR Little Endian
+      ]
+    end
+
+
+    # Set user information [item type code, vr/type, value]
+    def set_user_information_array
+      @user_information = [
+        ["51", "UL", @max_package_size], # Max PDU Length
+        ["52", "STR", "1.2.826.0.1.3680043.8.641"], # Implementation UID
+        ["55", "STR", "RUBY_DICOM"] # Implementation Version
+      ]
+    end
+
+  end # of class
+end # of module