dicom 0.9.6 → 0.9.7

data/lib/dicom/dictionary/uids.tsv

@@ -161,6 +161,8 @@
 1.2.840.10008.5.1.4.1.1.13.1.1	X-Ray 3D Angiographic Image Storage	SOP Class	
 1.2.840.10008.5.1.4.1.1.13.1.2	X-Ray 3D Craniofacial Image Storage	SOP Class	
 1.2.840.10008.5.1.4.1.1.13.1.3	Breast Tomosynthesis Image Storage	SOP Class	
+1.2.840.10008.5.1.4.1.1.13.1.4	Breast Projection X-Ray Image Storage - For Presentation	SOP Class	
+1.2.840.10008.5.1.4.1.1.13.1.5	Breast Projection X-Ray Image Storage - For Processing	SOP Class	
 1.2.840.10008.5.1.4.1.1.14.1	Intravascular Optical Coherence Tomography Image Storage - For Presentation	SOP Class	
 1.2.840.10008.5.1.4.1.1.14.2	Intravascular Optical Coherence Tomography Image Storage - For Processing	SOP Class	
 1.2.840.10008.5.1.4.1.1.20	Nuclear Medicine Image Storage	SOP Class	
@@ -171,8 +173,8 @@
 1.2.840.10008.5.1.4.1.1.66.4	Segmentation Storage	SOP Class	
 1.2.840.10008.5.1.4.1.1.66.5	Surface Segmentation Storage	SOP Class	
 1.2.840.10008.5.1.4.1.1.67	Real World Value Mapping Storage	SOP Class	
-1.2.840.10008.5.1.4.1.1.77.1	VL Image Storage - Trial (Retired)	 	R
-1.2.840.10008.5.1.4.1.1.77.2	VL Multi-frame Image Storage - Trial (Retired)	 	R
+1.2.840.10008.5.1.4.1.1.77.1	VL Image Storage - Trial (Retired)	SOP Class	R
+1.2.840.10008.5.1.4.1.1.77.2	VL Multi-frame Image Storage - Trial (Retired)	SOP Class	R
 1.2.840.10008.5.1.4.1.1.77.1.1	VL Endoscopic Image Storage	SOP Class	
 1.2.840.10008.5.1.4.1.1.77.1.1.1	Video Endoscopic Image Storage	SOP Class	
 1.2.840.10008.5.1.4.1.1.77.1.2	VL Microscopic Image Storage	SOP Class	

data/lib/dicom/elemental_parent.rb

@@ -1,64 +1,64 @@
-module DICOM
-
-  # The ElementalParent mix-in module contains methods that are common among
-  # the two elemental parent classes: Item & Sequence
-  #
-  module ElementalParent
-
-    # Adds a child item to a Sequence (or Item in some cases where pixel data is encapsulated).
-    #
-    # If no existing Item is given, a new item will be created and added.
-    #
-    # @note Items are specified by index (starting at 0) instead of a tag string!
-    #
-    # @param [Item] item the Item instance to be added
-    # @param [Hash] options the options used for adding the item
-    # option options [Integer] :if specified, forces the item to be inserted at that specific index (Item number)
-    # option options [Boolean] :no_follow when true, the method does not update the parent attribute of the child that is added
-    # * <tt>options</tt> -- A hash of parameters.
-    # @example Add an empty Item to a specific Sequence
-    #   dcm["3006,0020"].add_item
-    # @example Add an existing Item at the 2nd item position/index in the specific Sequence
-    #   dcm["3006,0020"].add_item(my_item, :index => 1)
-    #
-    def add_item(item=nil, options={})
-      if item
-        if item.is_a?(Item)
-          if index = options[:index]
-            # This Item will take a specific index, and all existing Items with index higher or equal to this number will have their index increased by one.
-            # Check if index is valid (must be an existing index):
-            if index >= 0
-              # If the index value is larger than the max index present, we dont need to modify the existing items.
-              if index < @tags.length
-                @tags = @tags.create_key_gap_at(index)
-              else
-                # Set the index value one higher than the already existing max value:
-                index = @tags.length
-              end
-              #,Add the new Item and set its index:
-              @tags[index] = item
-              item.index = index
-            else
-              raise ArgumentError, "The specified index (#{index}) is out of range (must be a positive integer)."
-            end
-          else
-            # Add the existing Item to this Sequence:
-            index = @tags.length
-            @tags[index] = item
-            # Let the Item know what index key it's got in it's parent's Hash:
-            item.index = index
-          end
-          # Set ourself as this item's new parent:
-          item.set_parent(self) unless options[:no_follow]
-        else
-          raise ArgumentError, "Expected Item, got #{item.class}"
-        end
-      else
-        # Create an empty item with self as parent:
-        item = Item.new(:parent => self)
-      end
-    end
-
-  end
-
+module DICOM
+
+  # The ElementalParent mix-in module contains methods that are common among
+  # the two elemental parent classes: Item & Sequence
+  #
+  module ElementalParent
+
+    # Adds a child item to a Sequence (or Item in some cases where pixel data is encapsulated).
+    #
+    # If no existing Item is given, a new item will be created and added.
+    #
+    # @note Items are specified by index (starting at 0) instead of a tag string!
+    #
+    # @param [Item] item the Item instance to be added
+    # @param [Hash] options the options used for adding the item
+    # option options [Integer] :if specified, forces the item to be inserted at that specific index (Item number)
+    # option options [Boolean] :no_follow when true, the method does not update the parent attribute of the child that is added
+    # * <tt>options</tt> -- A hash of parameters.
+    # @example Add an empty Item to a specific Sequence
+    #   dcm["3006,0020"].add_item
+    # @example Add an existing Item at the 2nd item position/index in the specific Sequence
+    #   dcm["3006,0020"].add_item(my_item, :index => 1)
+    #
+    def add_item(item=nil, options={})
+      if item
+        if item.is_a?(Item)
+          if index = options[:index]
+            # This Item will take a specific index, and all existing Items with index higher or equal to this number will have their index increased by one.
+            # Check if index is valid (must be an existing index):
+            if index >= 0
+              # If the index value is larger than the max index present, we dont need to modify the existing items.
+              if index < @tags.length
+                @tags = @tags.create_key_gap_at(index)
+              else
+                # Set the index value one higher than the already existing max value:
+                index = @tags.length
+              end
+              #,Add the new Item and set its index:
+              @tags[index] = item
+              item.index = index
+            else
+              raise ArgumentError, "The specified index (#{index}) is out of range (must be a positive integer)."
+            end
+          else
+            # Add the existing Item to this Sequence:
+            index = @tags.length
+            @tags[index] = item
+            # Let the Item know what index key it's got in it's parent's Hash:
+            item.index = index
+          end
+          # Set ourself as this item's new parent:
+          item.set_parent(self) unless options[:no_follow]
+        else
+          raise ArgumentError, "Expected Item, got #{item.class}"
+        end
+      else
+        # Create an empty item with self as parent:
+        item = Item.new(:parent => self)
+      end
+    end
+
+  end
+
 end

data/lib/dicom/extensions/array.rb

@@ -1,57 +1,57 @@
-# Extensions to the Array class.
-# These mainly deal with encoding integer arrays as well as conversion between
-# signed and unsigned integers.
-#
-class Array
-
-  # Packs an array of (unsigned) integers to a binary string (blob).
-  #
-  # @param [Integer] depth the bit depth to be used when encoding the unsigned integers
-  # @return [String] an encoded binary string
-  #
-  def to_blob(depth)
-    raise ArgumentError, "Expected Integer, got #{depth.class}" unless depth.is_a?(Integer)
-    raise ArgumentError, "Unsupported bit depth #{depth}." unless [8,16].include?(depth)
-    case depth
-    when 8
-      return self.pack('C*') # Unsigned char
-    when 16
-      return self.pack('S<*') # Unsigned short, little endian byte order
-    end
-  end
-
-  # Shifts the integer values of the array to make a signed data set.
-  # The size of the shift is determined by the given bit depth.
-  #
-  # @param [Integer] depth the bit depth of the integers
-  # @return [Array<Integer>] an array of signed integers
-  #
-  def to_signed(depth)
-    case depth
-    when 8
-      self.collect {|i| i - 128}
-    when 16
-      self.collect {|i| i - 32768}
-    else
-      raise ArgumentError, "Unknown or unsupported bit depth: #{depth}"
-    end
-  end
-
-  # Shifts the integer values of the array to make an unsigned data set.
-  # The size of the shift is determined by the given bit depth.
-  #
-  # @param [Integer] depth the bit depth of the integers
-  # @return [Array<Integer>] an array of unsigned integers
-  #
-  def to_unsigned(depth)
-    case depth
-    when 8
-      self.collect {|i| i + 128}
-    when 16
-      self.collect {|i| i + 32768}
-    else
-      raise ArgumentError, "Unknown or unsupported bit depth: #{depth}"
-    end
-  end
-
+# Extensions to the Array class.
+# These mainly deal with encoding integer arrays as well as conversion between
+# signed and unsigned integers.
+#
+class Array
+
+  # Packs an array of (unsigned) integers to a binary string (blob).
+  #
+  # @param [Integer] depth the bit depth to be used when encoding the unsigned integers
+  # @return [String] an encoded binary string
+  #
+  def to_blob(depth)
+    raise ArgumentError, "Expected Integer, got #{depth.class}" unless depth.is_a?(Integer)
+    raise ArgumentError, "Unsupported bit depth #{depth}." unless [8,16].include?(depth)
+    case depth
+    when 8
+      return self.pack('C*') # Unsigned char
+    when 16
+      return self.pack('S<*') # Unsigned short, little endian byte order
+    end
+  end
+
+  # Shifts the integer values of the array to make a signed data set.
+  # The size of the shift is determined by the given bit depth.
+  #
+  # @param [Integer] depth the bit depth of the integers
+  # @return [Array<Integer>] an array of signed integers
+  #
+  def to_signed(depth)
+    case depth
+    when 8
+      self.collect {|i| i - 128}
+    when 16
+      self.collect {|i| i - 32768}
+    else
+      raise ArgumentError, "Unknown or unsupported bit depth: #{depth}"
+    end
+  end
+
+  # Shifts the integer values of the array to make an unsigned data set.
+  # The size of the shift is determined by the given bit depth.
+  #
+  # @param [Integer] depth the bit depth of the integers
+  # @return [Array<Integer>] an array of unsigned integers
+  #
+  def to_unsigned(depth)
+    case depth
+    when 8
+      self.collect {|i| i + 128}
+    when 16
+      self.collect {|i| i + 32768}
+    else
+      raise ArgumentError, "Unknown or unsupported bit depth: #{depth}"
+    end
+  end
+
 end

data/lib/dicom/extensions/hash.rb

@@ -1,31 +1,31 @@
-# Extensions to the Hash class used by the dicom gem.
-#
-class Hash
-
-  # Creates a gap in the integer keys at the specified index.
-  # This is achieved by incrementing by one all existing index keys that are equal or
-  # bigger than the given index.
-  #
-  # @note It is assumed that this hash features integers as keys and items as values!
-  # @param [Integer] index the index at which to clear
-  # @return [Hash] the modified self
-  #
-  def create_key_gap_at(index)
-    # Extract existing Hash entries to an array:
-    pairs = self.sort
-    h = Hash.new
-    # Change the key of those equal or larger than index and put these key,value pairs back in a new Hash:
-    pairs.each do |pair|
-      if pair[0] < index
-        # The key keeps its old index:
-        h[pair[0]] = pair[1]
-      else
-        # The key (and the value Item) gets its index incremented by one:
-        h[pair[0]+1] = pair[1]
-        pair[1].index = pair[0]+1
-      end
-    end
-    h
-  end
-
+# Extensions to the Hash class used by the dicom gem.
+#
+class Hash
+
+  # Creates a gap in the integer keys at the specified index.
+  # This is achieved by incrementing by one all existing index keys that are equal or
+  # bigger than the given index.
+  #
+  # @note It is assumed that this hash features integers as keys and items as values!
+  # @param [Integer] index the index at which to clear
+  # @return [Hash] the modified self
+  #
+  def create_key_gap_at(index)
+    # Extract existing Hash entries to an array:
+    pairs = self.sort
+    h = Hash.new
+    # Change the key of those equal or larger than index and put these key,value pairs back in a new Hash:
+    pairs.each do |pair|
+      if pair[0] < index
+        # The key keeps its old index:
+        h[pair[0]] = pair[1]
+      else
+        # The key (and the value Item) gets its index incremented by one:
+        h[pair[0]+1] = pair[1]
+        pair[1].index = pair[0]+1
+      end
+    end
+    h
+  end
+
 end

data/lib/dicom/extensions/string.rb

@@ -1,126 +1,126 @@
-# encoding: UTF-8
-
-# Extension to the String class. These mainly facilitate the processing and analysis of element tags.
-# A tag string (as used by the ruby-dicom library) is 9 characters long and of the form 'GGGG,EEEE'
-# (where G represents a group hexadecimal, and E represents an element hexadecimal).
-#
-class String
-
-  # Checks if a string value LOOKS like a DICOM name - it may still not be valid one.
-  #
-  # @return [Boolean] true if a string looks like a DICOM name, and false if not
-  #
-  def dicom_name?
-    self == self.dicom_titleize
-  end
-
-  # Checks if a string value LOOKS like a DICOM method name - it may still not be valid one.
-  #
-  # @return [Boolean] true if a string looks like a DICOM method name, and false if not
-  #
-  def dicom_method?
-    self == self.dicom_underscore
-  end
-
-  # Capitalizes all the words in the string and replaces some characters to make a nicer looking title.
-  #
-  # @return [String] a formatted, capitalized string
-  #
-  def dicom_titleize
-    self.dicom_underscore.gsub(/_/, ' ').gsub(/\b('?[a-z])/) { $1.capitalize }
-  end
-
-  # Makes an underscored, lowercased version of the string.
-  #
-  # @return [String] an underscored, lower case string
-  #
-  def dicom_underscore
-    word = self.dup
-    word.tr!('-', '_')
-    word.downcase!
-    word
-  end
-
-  # Divides a string into a number of sub-strings of exactly equal length.
-  #
-  # @note The length of self must be a multiple of parts, or an exception will be raised.
-  # @param [Integer] parts the number of sub-strings to create
-  # @return [Array<String>] the divided sub-strings
-  #
-  def divide(parts)
-    parts = parts.to_i
-    raise ArgumentError, "Argument must be in the range <1 - self.length (#{self.length})>. Got #{parts}." if parts < 1 or parts > self.length
-    raise ArgumentError, "Length of self (#{self.length}) must be a multiple of parts (#{parts})." if (self.length/parts.to_f % 1) != 0
-    sub_strings = Array.new
-    sub_length = self.length/parts
-    start_index = 0
-    parts.times {
-      sub_strings <<  self.slice(start_index, sub_length)
-      start_index += sub_length
-    }
-    sub_strings
-  end
-
-  # Extracts the element part of the tag string: The last 4 characters.
-  #
-  # @return [String] the element part of the tag
-  #
-  def element
-    return self[5..8]
-  end
-
-  # Returns the group part of the tag string: The first 4 characters.
-  #
-  # @return [String] the group part of the tag
-  #
-  def group
-    return self[0..3]
-  end
-
-  # Returns the "Group Length" ('GGGG,0000') tag which corresponds to the original tag/group string.
-  # The original string may either be a 4 character group string, or a 9 character custom tag.
-  #
-  # @return [String] a group length tag
-  #
-  def group_length
-    if self.length == 4
-      return self + ',0000'
-    else
-      return self.group + ',0000'
-    end
-  end
-
-  # Checks if the string is a "Group Length" tag (its element part is '0000').
-  #
-  # @return [Boolean] true if it is a group length tag, and false if not
-  #
-  def group_length?
-    return (self.element == '0000' ? true : false)
-  end
-
-  # Checks if the string is a private tag (has an odd group number).
-  #
-  # @return [Boolean] true if it is a private tag, and false if not
-  #
-  def private?
-    return ((self.upcase =~ /\A\h{3}[1,3,5,7,9,B,D,F],\h{4}\z/) == nil ? false : true)
-  end
-
-  # Checks if the string is a valid tag (as defined by ruby-dicom: 'GGGG,EEEE').
-  #
-  # @return [Boolean] true if it is a valid tag, and false if not
-  #
-  def tag?
-    # Test that the string is composed of exactly 4 HEX characters, followed by a comma, then 4 more HEX characters:
-    return ((self.upcase =~ /\A\h{4},\h{4}\z/) == nil ? false : true)
-  end
-
-  # Converts the string to a proper DICOM element method name symbol.
-  #
-  # @return [Symbol] a DICOM element method name
-  #
-  def to_element_method
-    self.gsub(/^3/,'three_').gsub(/[#*?!]/,' ').gsub(', ',' ').gsub('&','and').gsub(' - ','_').gsub(' / ','_').gsub(/[\s\-\.\,\/\\]/,'_').gsub(/[\(\)\']/,'').gsub(/\_+/, '_').downcase.to_sym
-  end
-
+# encoding: UTF-8
+
+# Extension to the String class. These mainly facilitate the processing and analysis of element tags.
+# A tag string (as used by the ruby-dicom library) is 9 characters long and of the form 'GGGG,EEEE'
+# (where G represents a group hexadecimal, and E represents an element hexadecimal).
+#
+class String
+
+  # Checks if a string value LOOKS like a DICOM name - it may still not be valid one.
+  #
+  # @return [Boolean] true if a string looks like a DICOM name, and false if not
+  #
+  def dicom_name?
+    self == self.dicom_titleize
+  end
+
+  # Checks if a string value LOOKS like a DICOM method name - it may still not be valid one.
+  #
+  # @return [Boolean] true if a string looks like a DICOM method name, and false if not
+  #
+  def dicom_method?
+    self == self.dicom_underscore
+  end
+
+  # Capitalizes all the words in the string and replaces some characters to make a nicer looking title.
+  #
+  # @return [String] a formatted, capitalized string
+  #
+  def dicom_titleize
+    self.dicom_underscore.gsub(/_/, ' ').gsub(/\b('?[a-z])/) { $1.capitalize }
+  end
+
+  # Makes an underscored, lowercased version of the string.
+  #
+  # @return [String] an underscored, lower case string
+  #
+  def dicom_underscore
+    word = self.dup
+    word.tr!('-', '_')
+    word.downcase!
+    word
+  end
+
+  # Divides a string into a number of sub-strings of exactly equal length.
+  #
+  # @note The length of self must be a multiple of parts, or an exception will be raised.
+  # @param [Integer] parts the number of sub-strings to create
+  # @return [Array<String>] the divided sub-strings
+  #
+  def divide(parts)
+    parts = parts.to_i
+    raise ArgumentError, "Argument must be in the range <1 - self.length (#{self.length})>. Got #{parts}." if parts < 1 or parts > self.length
+    raise ArgumentError, "Length of self (#{self.length}) must be a multiple of parts (#{parts})." if (self.length/parts.to_f % 1) != 0
+    sub_strings = Array.new
+    sub_length = self.length/parts
+    start_index = 0
+    parts.times {
+      sub_strings <<  self.slice(start_index, sub_length)
+      start_index += sub_length
+    }
+    sub_strings
+  end
+
+  # Extracts the element part of the tag string: The last 4 characters.
+  #
+  # @return [String] the element part of the tag
+  #
+  def element
+    return self[5..8]
+  end
+
+  # Returns the group part of the tag string: The first 4 characters.
+  #
+  # @return [String] the group part of the tag
+  #
+  def group
+    return self[0..3]
+  end
+
+  # Returns the "Group Length" ('GGGG,0000') tag which corresponds to the original tag/group string.
+  # The original string may either be a 4 character group string, or a 9 character custom tag.
+  #
+  # @return [String] a group length tag
+  #
+  def group_length
+    if self.length == 4
+      return self + ',0000'
+    else
+      return self.group + ',0000'
+    end
+  end
+
+  # Checks if the string is a "Group Length" tag (its element part is '0000').
+  #
+  # @return [Boolean] true if it is a group length tag, and false if not
+  #
+  def group_length?
+    return (self.element == '0000' ? true : false)
+  end
+
+  # Checks if the string is a private tag (has an odd group number).
+  #
+  # @return [Boolean] true if it is a private tag, and false if not
+  #
+  def private?
+    return ((self.upcase =~ /\A\h{3}[1,3,5,7,9,B,D,F],\h{4}\z/) == nil ? false : true)
+  end
+
+  # Checks if the string is a valid tag (as defined by ruby-dicom: 'GGGG,EEEE').
+  #
+  # @return [Boolean] true if it is a valid tag, and false if not
+  #
+  def tag?
+    # Test that the string is composed of exactly 4 HEX characters, followed by a comma, then 4 more HEX characters:
+    return ((self.upcase =~ /\A\h{4},\h{4}\z/) == nil ? false : true)
+  end
+
+  # Converts the string to a proper DICOM element method name symbol.
+  #
+  # @return [Symbol] a DICOM element method name
+  #
+  def to_element_method
+    self.gsub(/^3/,'three_').gsub(/[#*?!]/,' ').gsub(', ',' ').gsub('&','and').gsub(' - ','_').gsub(' / ','_').gsub(/[\s\-\.\,\/\\]/,'_').gsub(/[\(\)\']/,'').gsub(/\_+/, '_').downcase.to_sym
+  end
+
 end