dicom 0.6.1 → 0.7

data/lib/{DRead.rb → dicom/DRead.rb}

@@ -1,4 +1,4 @@
-#    Copyright 2008-2009 Christoffer Lervag
+#    Copyright 2008-2010 Christoffer Lervag
 
 # Some notes about this DICOM file reading class:
 # In addition to reading files that are compliant to DICOM 3 Part 10, the philosophy of this library
@@ -11,20 +11,19 @@ module DICOM
   # Class for reading the data from a DICOM file:
   class DRead
 
-    attr_reader :success, :names, :tags, :types, :lengths, :values, :raw, :levels, :explicit, :file_endian, :msg
+    attr_reader :success, :names, :tags, :vr, :lengths, :values, :bin, :levels, :explicit, :file_endian, :msg
 
     # Initialize the DRead instance.
     def initialize(string=nil, options={})
       # Process option values, setting defaults for the ones that are not specified:
-      @lib =  options[:lib] || DLibrary.new
       @sys_endian = options[:sys_endian] || false
-      @bin = options[:bin]
+      @bin_string = options[:bin]
       @transfer_syntax = options[:syntax]
       # Initiate the variables that are used during file reading:
       init_variables
 
       # Are we going to read from a file, or read from a binary string:
-      if @bin
+      if @bin_string
         # Read from the provided binary string:
         @str = string
       else
@@ -43,7 +42,7 @@ module DICOM
       # Create a Stream instance to handle the decoding of content from this binary string:
       @stream = Stream.new(@str, @file_endian, @explicit)
       # Do not check for header information when supplied a (network) binary string:
-      unless @bin
+      unless @bin_string
         # Read and verify the DICOM header:
         header = check_header
         # If the file didnt have the expected header, we will attempt to read
@@ -66,11 +65,11 @@ module DICOM
       # Post processing:
       # Assume file has been read successfully:
       @success = true
-      # Check if the last element was read out correctly (that the length of its data (@raw.last.length)
+      # Check if the last element was read out correctly (that the length of its data (@bin.last.length)
       # corresponds to that expected by the length specified in the DICOM file (@lengths.last)).
       # We only run this test if the last element has a positive expectation value, obviously.
       if @lengths.last.to_i > 0
-        if @raw.last.length != @lengths.last
+        if @bin.last.length != @lengths.last
           @msg << "Error! The data content read from file does not match the length specified for the tag #{@tags.last}. It seems this is either an invalid or corrupt DICOM file. Returning."
           @success = false
           return
@@ -176,17 +175,17 @@ module DICOM
         return false
       end
       # STEP 2: ------------------------------------------------------
-      # Access library to retrieve the data element name and type (VR) from the tag we just read:
-      lib_data = @lib.get_name_vr(tag)
+      # Access library to retrieve the data element name and VR from the tag we just read:
+      lib_data = LIBRARY.get_name_vr(tag)
       name = lib_data[0]
       vr = lib_data[1]
       # (Note: VR will be overwritten if the DICOM file contains VR)
 
       # STEP 3: ----------------------------------------------------
-      # Read type (VR) (if it exists) and the length value:
-      tag_info = read_type_length(vr,tag)
-      type = tag_info[0]
-      level_type = type
+      # Read VR (if it exists) and the length value:
+      tag_info = read_vr_length(vr,tag)
+      vr = tag_info[0]
+      level_vr = vr
       length = tag_info[1]
 
       # STEP 4: ----------------------------------------
@@ -195,37 +194,37 @@ module DICOM
       if @enc_image and tag == "FFFE,E000"
         # The first item appearing after the image element is a 'normal' item, the rest hold image data.
         # Note that the first item will contain data if there are multiple images, and so must be read.
-        type = "OW" # how about alternatives like OB?
+        vr = "OW" # how about alternatives like OB?
         # Modify name of item if this is an item that holds pixel data:
         if @tags.last != "7FE0,0010"
           name = "Pixel Data Item"
         end
       end
       # Read the value of the element (if it contains data, and it is not a sequence or ordinary item):
-      if length.to_i > 0 and type != "SQ" and type != "()"
+      if length.to_i > 0 and vr != "SQ" and vr != "()"
         # Read the element's value (data):
-        data = read_value(type,length)
+        data = read_value(vr,length)
         value = data[0]
-        raw = data[1]
+        bin = data[1]
       else
         # Data element has no value (data).
         # Special case: Check if pixel data element is sequenced:
         if tag == "7FE0,0010"
-          # Change name and type of pixel data element if it does not contain data itself:
+          # Change name and vr of pixel data element if it does not contain data itself:
           name = "Encapsulated Pixel Data"
-          level_type = "SQ"
+          level_vr = "SQ"
           @enc_image = true
         end
       end # of if length.to_i > 0
       # Set the hiearchy level of this data element:
-      set_level(level_type, length, tag, name)
+      set_level(level_vr, length, tag, name)
       # Transfer the gathered data to arrays and return true:
       @names << name
       @tags << tag
-      @types << type
+      @vr << vr
       @lengths << length
       @values << value
-      @raw << raw
+      @bin << bin
       return true
     end # of process_data_element
 
@@ -252,8 +251,8 @@ module DICOM
     end
 
 
-    # Reads and returns data element TYPE (VR) (2 bytes) and data element LENGTH (Varying length; 2-6 bytes).
-    def read_type_length(type,tag)
+    # Reads and returns data element VR (2 bytes) and data element LENGTH (Varying length; 2-6 bytes).
+    def read_vr_length(vr,tag)
       # Structure will differ, dependent on whether we have explicit or implicit encoding:
       pre_skip = 0
       bytes = 0
@@ -261,14 +260,14 @@ module DICOM
       if @explicit == true
         # Step 1: Read VR (if it exists)
         unless tag == "FFFE,E000" or tag == "FFFE,E00D" or tag == "FFFE,E0DD"
-          # Read the element's type (2 bytes - since we are not dealing with an item related element):
-          type = @stream.decode(2, "STR")
+          # Read the element's vr (2 bytes - since we are not dealing with an item related element):
+          vr = @stream.decode(2, "STR")
           @integrated_lengths[@integrated_lengths.length-1] += 2
         end
         # Step 2: Read length
-        # Three possible structures for value length here, dependent on element type:
-        case type
-          when "OB","OW","SQ","UN"
+        # Three possible structures for value length here, dependent on element vr:
+        case vr
+          when "OB","OW","SQ","UN","UT"
             # 6 bytes total:
             # Two empty bytes first:
             pre_skip = 2
@@ -276,11 +275,11 @@ module DICOM
             bytes = 4
           when "()"
             # 4 bytes:
-            # For elements "FFFE,E000", "FFFE,E00D" and "FFFE,E0DD"
+            # For elements "FFFE,E000", "FFFE,E00D" and "FFFE,E0DD":
             bytes = 4
           else
             # 2 bytes:
-            # For all the other element types, value length is 2 bytes:
+            # For all the other element vr, value length is 2 bytes:
             bytes = 2
         end
       else
@@ -306,23 +305,23 @@ module DICOM
         # If it is not, it may indicate a file that is not standards compliant or it might even not be a DICOM file.
         @msg += ["Warning: Odd number of bytes in data element's length occured. This is a violation of the DICOM standard, but program will attempt to read the rest of the file anyway."]
       end
-      return [type, length]
-    end # of read_type_length
+      return [vr, length]
+    end # of read_vr_length
 
 
     # Reads and returns data element VALUE (Of varying length - which is determined at an earlier stage).
-    def read_value(type, length)
+    def read_value(vr, length)
       # Extract the binary data:
       bin = @stream.extract(length)
       @integrated_lengths[@integrated_lengths.size-1] += length
       # Decode data?
       # Some data elements (like those containing image data, compressed data or unknown data),
       # will not be decoded here.
-      unless type == "OW" or type == "OB" or type == "OF" or type == "UN"
+      unless vr == "OW" or vr == "OB" or vr == "OF" or vr == "UN"
         # "Rewind" and extract the value from this binary data:
         @stream.skip(-length)
         # Decode data:
-        value = @stream.decode(length, type)
+        value = @stream.decode(length, vr)
         if not value.is_a?(Array)
           data = value
         else
@@ -341,7 +340,7 @@ module DICOM
 
     # Sets the level of the current element in the hiearchy.
     # The default (top) level is zero.
-    def set_level(type, length, tag, name)
+    def set_level(vr, length, tag, name)
       # Set the level of this element:
       @levels += [@current_level]
       # Determine if there is a level change for the following element:
@@ -350,7 +349,7 @@ module DICOM
       # Note the following exception:
       # If data element is an "Item", and it contains data (image fragment) directly, which is to say,
       # not in its sub-elements, we should not increase the level. (This is fixed in the process_data_element method.)
-      if type == "SQ"
+      if vr == "SQ"
         increase = true
       elsif name == "Item"
         increase = true
@@ -363,7 +362,7 @@ module DICOM
         if length.to_i != 0
           @hierarchy << [length, @integrated_lengths.last]
         else
-          @hierarchy << type
+          @hierarchy << vr
         end
       end
       # Need to check whether a previous sequence or item has ended, if so the level must be decreased by one:
@@ -448,7 +447,7 @@ module DICOM
         end
       end
       # Query the library with our particular transfer syntax string:
-      result = @lib.process_transfer_syntax(@transfer_syntax)
+      result = LIBRARY.process_transfer_syntax(@transfer_syntax)
       # Result is a 3-element array: [Validity of ts, explicitness, endianness]
       unless result[0]
         @msg+=["Warning: Invalid/unknown transfer syntax! Will try reading the file, but errors may occur."]
@@ -487,10 +486,10 @@ module DICOM
       # Arrays that will hold information from the elements of the DICOM file:
       @names = Array.new
       @tags = Array.new
-      @types = Array.new
+      @vr = Array.new
       @lengths = Array.new
       @values = Array.new
-      @raw = Array.new
+      @bin = Array.new
       @levels = Array.new
       # Array that will holde any messages generated while reading the DICOM file:
       @msg = Array.new

data/lib/{DServer.rb → dicom/DServer.rb}

@@ -1,4 +1,4 @@
-#    Copyright 2009 Christoffer Lervag
+#    Copyright 2009-2010 Christoffer Lervag
 
 module DICOM
 
@@ -6,16 +6,25 @@ module DICOM
   # which will act as a simple storage node (a server that receives images).
   class DServer
 
-    attr_accessor :host_ae, :max_package_size, :port, :timeout, :verbose
+
+    # Run the server and take a block for initializing.
+    def self.run(port=104, path='./received/', &block)
+      server = DServer.new(port)
+      server.instance_eval(&block)
+      server.start_scp(path)
+    end
+
+    # Accessible attributes:
+    attr_accessor :host_ae, :max_package_size, :port, :timeout, :verbose, :file_handler
     attr_reader :errors, :notices
 
     # Initialize the instance with a host adress and a port number.
-    def initialize(port, options={})
+    def initialize(port=104, options={})
       require 'socket'
       # Required parameters:
       @port = port
       # Optional parameters (and default values):
-      @lib =  options[:lib]  || DLibrary.new
+      @file_handler = options[:file_handler] || FileHandler
       @host_ae =  options[:host_ae]  || "RUBY_DICOM"
       @max_package_size = options[:max_package_size] || 32768 # 16384
       @timeout = options[:timeout] || 10 # seconds
@@ -70,10 +79,9 @@ module DICOM
       @valid_abstract_syntaxes = Array.new
     end
 
-
-    # Start a Storage Content Provider (SCP).
+    # Start a Service Class Provider (SCP).
     # This service will receive and store DICOM files in a specified folder.
-    def start_scp(path)
+    def start_scp(path='./received/')
       add_notice("Starting SCP server...")
       add_notice("*********************************")
       # Initiate server:
@@ -82,16 +90,17 @@ module DICOM
       loop do
         Thread.start(@scp.accept) do |session|
           # Initialize the network package handler for this session:
-          link = Link.new(:host_ae => @host_ae, :max_package_size => @max_package_size, :timeout => @timeout, :verbose => @verbose)
+          link = Link.new(:host_ae => @host_ae, :max_package_size => @max_package_size, :timeout => @timeout, :verbose => @verbose, :file_handler => @file_handler)
           add_notice("Connection established (name: #{session.peeraddr[2]}, ip: #{session.peeraddr[3]})")
           # Receive an incoming message:
-          segments = link.receive_single_transmission(session)
+          #segments = link.receive_single_transmission(session)
+          segments = link.receive_multiple_transmissions(session)
           info = segments.first
           # Interpret the received message:
           if info[:valid]
             association_error = check_association_request(info)
             unless association_error
-              syntax_result = check_syntax_requests(info)
+              syntax_result = check_syntax_requests(link, info)
               link.handle_association_accept(session, info, syntax_result)
               if syntax_result == "00" # Normal (no error)
                 add_notice("An incoming association request and its abstract syntax has been accepted.")
@@ -100,10 +109,15 @@ module DICOM
                   link.handle_release(session)
                 else
                   # Process the incoming data:
-                  file_path = link.handle_incoming_data(session, path)
-                  add_notice("DICOM file saved to: " + file_path)
-                  # Send a receipt for received data:
-                  link.handle_response(session)
+                  success, message = link.handle_incoming_data(session, path)
+                  if success
+                    add_notice(message)
+                    # Send a receipt for received data:
+                    link.handle_response(session)
+                  else
+                    # Something has gone wrong:
+                    add_error(message)
+                  end
                   # Release the connection:
                   link.handle_release(session)
                 end
@@ -171,17 +185,17 @@ module DICOM
 
     # Check if the requested abstract syntax & transfer syntax are supported:
     # Error codes are given in the official dicom document, part 08_08, page 39
-    def check_syntax_requests(info)
+    def check_syntax_requests(link, info)
       result = "00" # (no error)
       # We will accept any transfer syntax (as long as it is recognized in the library):
       # (Weakness: Only checking the first occuring transfer syntax for now)
-      transfer_syntax = info[:ts].first[:transfer_syntax]
-      unless @lib.check_ts_validity(transfer_syntax)
+      transfer_syntax = link.extract_transfer_syntax(info)
+      unless LIBRARY.check_ts_validity(transfer_syntax)
         result = "04" # transfer syntax not supported
         add_error("Warning: Unsupported transfer syntax received in incoming association request. (#{transfer_syntax})")
       end
       # Check that abstract syntax is among the ones that have been set as valid for this server instance:
-      abstract_syntax = info[:abstract_syntax]
+      abstract_syntax = link.extract_abstract_syntax(info)
       unless @valid_abstract_syntaxes.include?(abstract_syntax)
         result = "03" # abstract syntax not supported
       end
@@ -286,5 +300,5 @@ module DICOM
     end
 
 
-  end
-end
+  end # of class
+end # of module

data/lib/{DWrite.rb → dicom/DWrite.rb}

@@ -1,4 +1,4 @@
-#    Copyright 2008-2009 Christoffer Lervag
+#    Copyright 2008-2010 Christoffer Lervag
 
 # Some notes about this DICOM file writing class:
 # In its current state, this class will always try to write the file such that it is compliant to the
@@ -14,22 +14,21 @@ module DICOM
   # Class for writing the data from a DObject to a valid DICOM file.
   class DWrite
 
-    attr_writer :tags, :types, :lengths, :raw, :rest_endian, :rest_explicit
+    attr_writer :tags, :vr, :lengths, :bin, :rest_endian, :rest_explicit
     attr_reader :success, :msg
 
     # Initialize the DWrite instance.
     def initialize(file_name=nil, options={})
       # Process option values, setting defaults for the ones that are not specified:
-      @lib =  options[:lib] || DLibrary.new
       @sys_endian = options[:sys_endian] || false
       @file_name = file_name
       @transfer_syntax = options[:transfer_syntax] || "1.2.840.10008.1.2" # Implicit, little endian
 
       # Create arrays used for storing data element information:
       @tags = Array.new
-      @types = Array.new
+      @vr = Array.new
       @lengths = Array.new
-      @raw = Array.new
+      @bin = Array.new
       # Array for storing error/warning messages:
       @msg = Array.new
       # Default values that may be overwritten by the user:
@@ -99,12 +98,12 @@ module DICOM
         if value_length > size
           # Start writing content from this data element,
           # then continue writing its content in the next segments.
-          # Write tag & type/length:
+          # Write tag & vr/length:
           write_tag(i)
-          write_type_length(i)
+          write_vr_length(i)
           # Find out how much of this element's value we can write, then add it:
           available = size - @stream.length
-          value_first_part = @raw[i].slice(0, available)
+          value_first_part = @bin[i].slice(0, available)
           @stream.add_last(value_first_part)
           # Add segment and reset:
           segments << @stream.string
@@ -114,7 +113,7 @@ module DICOM
           index = available
           # Iterate through the data element's value until we have added it entirely:
           remaining_segments.times do
-            value = @raw[i].slice(index, size)
+            value = @bin[i].slice(index, size)
             index = index + size
             @stream.add_last(value)
             # Add segment and reset:
@@ -183,14 +182,14 @@ module DICOM
       tag = @stream.encode_tag("0002,0012")
       @stream.add_last(tag)
       @stream.encode_last("UI", "STR")
-      value = @stream.encode_value(@implementation_uid, "STR")
+      value = @stream.encode_value(UID, "STR")
       @stream.encode_last(value.length, "US")
       @stream.add_last(value)
       # Implementation Version Name:
       tag = @stream.encode_tag("0002,0013")
       @stream.add_last(tag)
       @stream.encode_last("SH", "STR")
-      value = @stream.encode_value(@implementation_name, "STR")
+      value = @stream.encode_value(NAME, "STR")
       @stream.encode_last(value.length, "US")
       @stream.add_last(value)
       # Group length:
@@ -201,9 +200,9 @@ module DICOM
       # Length:
       length = @stream.encode(4, "US")
       @stream.add_first(length)
-      # Type:
-      type = @stream.encode("UL", "STR")
-      @stream.add_first(type)
+      # VR:
+      vr = @stream.encode("UL", "STR")
+      @stream.add_first(vr)
       # Tag:
       tag = @stream.encode_tag("0002,0000")
       @stream.add_first(tag)
@@ -216,8 +215,8 @@ module DICOM
     def write_data_element(i)
       # Step 1: Write tag:
       write_tag(i)
-      # Step 2: Write [type] and value length:
-      write_type_length(i)
+      # Step 2: Write [vr] and value length:
+      write_vr_length(i)
       # Step 3: Write value:
       write_value(i)
       # If DICOM object contains encapsulated pixel data, we need some special handling for its items:
@@ -242,9 +241,9 @@ module DICOM
     end
 
 
-    # Writes the type (VR) (if it is to be written) and length value
+    # Writes the VR (if it is to be written) and length value
     # (these two are the middle part of the data element):
-    def write_type_length(i)
+    def write_vr_length(i)
       # First some preprocessing:
       # Set length value:
       if @lengths[i] == nil
@@ -265,14 +264,14 @@ module DICOM
       if @explicit == true
         # Step 1: Write VR (if it is to be written)
         unless @tags[i] == "FFFE,E000" or @tags[i] == "FFFE,E00D" or @tags[i] == "FFFE,E0DD"
-          # Write data element type (VR) (2 bytes - since we are not dealing with an item related element):
-          vr = @stream.encode(@types[i], "STR")
+          # Write data element VR (2 bytes - since we are not dealing with an item related element):
+          vr = @stream.encode(@vr[i], "STR")
           add(vr)
         end
         # Step 2: Write length
-        # Three possible structures for value length here, dependent on data element type:
-        case @types[i]
-          when "OB","OW","SQ","UN"
+        # Three possible structures for value length here, dependent on data element vr:
+        case @vr[i]
+          when "OB","OW","SQ","UN","UT"
             if @enc_image
               # Item under an encapsulated Pixel Data (7FE0,0010):
               # 4 bytes:
@@ -291,22 +290,22 @@ module DICOM
             add(length4)
           else
             # 2 bytes:
-            # For all the other data element types, value length is 2 bytes:
+            # For all the other data element vr, value length is 2 bytes:
             add(length2)
-        end # of case type
+        end
       else
         # *****IMPLICIT*****:
         # No VR written.
         # Writing value length (4 bytes):
         add(length4)
       end
-    end # of write_type_length
+    end # of write_vr_length
 
 
     # Writes the value (last part of the data element):
     def write_value(i)
       # This is pretty straightforward, just dump the binary data to the file/string:
-      add(@raw[i])
+      add(@bin[i])
     end
 
 
@@ -347,7 +346,7 @@ module DICOM
     # Changes encoding variables as the file writing proceeds past the initial 0002 group of the DICOM file.
     def switch_syntax
       # The information from the Transfer syntax element (if present), needs to be processed:
-      result = @lib.process_transfer_syntax(@transfer_syntax.rstrip)
+      result = LIBRARY.process_transfer_syntax(@transfer_syntax.rstrip)
       # Result is a 3-element array: [Validity of ts, explicitness, endianness]
       unless result[0]
         @msg << "Warning: Invalid/unknown transfer syntax! Will still write the file, but you should give this a closer look."
@@ -405,9 +404,6 @@ module DICOM
       end
       # Items contained under the Pixel Data element needs some special attention to write correctly:
       @enc_image = false
-      # Version information:
-      @implementation_uid = "1.2.826.0.1.3680043.8.641"
-      @implementation_name = "RUBY_DICOM_0.6"
     end
 
   end # of class