id
int32 0
24.9k
| repo
stringlengths 5
58
| path
stringlengths 9
168
| func_name
stringlengths 9
130
| original_string
stringlengths 66
10.5k
| language
stringclasses 1
value | code
stringlengths 66
10.5k
| code_tokens
list | docstring
stringlengths 8
16k
| docstring_tokens
list | sha
stringlengths 40
40
| url
stringlengths 94
266
|
|---|---|---|---|---|---|---|---|---|---|---|---|
22,300 |
dicom/ruby-dicom
|
lib/dicom/anonymizer.rb
|
DICOM.Anonymizer.anonymize
|
def anonymize(dicom)
dicom = Array[dicom] unless dicom.respond_to?(:to_ary)
if @tags.length > 0
prepare_anonymization
dicom.each do |dcm|
anonymize_dcm(dcm.to_dcm)
end
else
logger.warn("No tags have been selected for anonymization. Aborting anonymization.")
end
# Save the audit trail (if used):
@audit_trail.write(@audit_trail_file) if @audit_trail
logger.info("Anonymization complete.")
dicom
end
|
ruby
|
def anonymize(dicom)
dicom = Array[dicom] unless dicom.respond_to?(:to_ary)
if @tags.length > 0
prepare_anonymization
dicom.each do |dcm|
anonymize_dcm(dcm.to_dcm)
end
else
logger.warn("No tags have been selected for anonymization. Aborting anonymization.")
end
# Save the audit trail (if used):
@audit_trail.write(@audit_trail_file) if @audit_trail
logger.info("Anonymization complete.")
dicom
end
|
[
"def",
"anonymize",
"(",
"dicom",
")",
"dicom",
"=",
"Array",
"[",
"dicom",
"]",
"unless",
"dicom",
".",
"respond_to?",
"(",
":to_ary",
")",
"if",
"@tags",
".",
"length",
">",
"0",
"prepare_anonymization",
"dicom",
".",
"each",
"do",
"|",
"dcm",
"|",
"anonymize_dcm",
"(",
"dcm",
".",
"to_dcm",
")",
"end",
"else",
"logger",
".",
"warn",
"(",
"\"No tags have been selected for anonymization. Aborting anonymization.\"",
")",
"end",
"# Save the audit trail (if used):",
"@audit_trail",
".",
"write",
"(",
"@audit_trail_file",
")",
"if",
"@audit_trail",
"logger",
".",
"info",
"(",
"\"Anonymization complete.\"",
")",
"dicom",
"end"
] |
Anonymizes the given DObject or array of DICOM objects with the settings
of this Anonymizer instance.
@param [DObject, Array<DObject>] dicom single or multiple DICOM objects
@return [Array<DObject>] an array of the anonymized DICOM objects
|
[
"Anonymizes",
"the",
"given",
"DObject",
"or",
"array",
"of",
"DICOM",
"objects",
"with",
"the",
"settings",
"of",
"this",
"Anonymizer",
"instance",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/anonymizer.rb#L141-L155
|
22,301 |
dicom/ruby-dicom
|
lib/dicom/anonymizer.rb
|
DICOM.Anonymizer.delete_tag
|
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
|
ruby
|
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
|
[
"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"
] |
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')
|
[
"Specifies",
"that",
"the",
"given",
"tag",
"is",
"to",
"be",
"completely",
"deleted",
"from",
"the",
"anonymized",
"DICOM",
"objects",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/anonymizer.rb#L186-L190
|
22,302 |
dicom/ruby-dicom
|
lib/dicom/anonymizer.rb
|
DICOM.Anonymizer.set_tag
|
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
|
ruby
|
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
|
[
"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"
] |
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)
|
[
"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",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/anonymizer.rb#L246-L260
|
22,303 |
dicom/ruby-dicom
|
lib/dicom/anonymizer.rb
|
DICOM.Anonymizer.value
|
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
|
ruby
|
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
|
[
"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"
] |
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
|
[
"Gives",
"the",
"value",
"which",
"will",
"be",
"used",
"when",
"anonymizing",
"this",
"tag",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/anonymizer.rb#L278-L288
|
22,304 |
dicom/ruby-dicom
|
lib/dicom/anonymizer.rb
|
DICOM.Anonymizer.anonymize_dcm
|
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
|
ruby
|
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
|
[
"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"
] |
Performs anonymization on a DICOM object.
@param [DObject] dcm a DICOM object
|
[
"Performs",
"anonymization",
"on",
"a",
"DICOM",
"object",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/anonymizer.rb#L298-L347
|
22,305 |
dicom/ruby-dicom
|
lib/dicom/anonymizer.rb
|
DICOM.Anonymizer.anonymize_file
|
def anonymize_file(file)
# Temporarily adjust the ruby-dicom log threshold (to suppress messages from the DObject class):
@original_level = logger.level
logger.level = @logger_level
dcm = DObject.read(file)
logger.level = @original_level
anonymize_dcm(dcm)
dcm
end
|
ruby
|
def anonymize_file(file)
# Temporarily adjust the ruby-dicom log threshold (to suppress messages from the DObject class):
@original_level = logger.level
logger.level = @logger_level
dcm = DObject.read(file)
logger.level = @original_level
anonymize_dcm(dcm)
dcm
end
|
[
"def",
"anonymize_file",
"(",
"file",
")",
"# Temporarily adjust the ruby-dicom log threshold (to suppress messages from the DObject class):",
"@original_level",
"=",
"logger",
".",
"level",
"logger",
".",
"level",
"=",
"@logger_level",
"dcm",
"=",
"DObject",
".",
"read",
"(",
"file",
")",
"logger",
".",
"level",
"=",
"@original_level",
"anonymize_dcm",
"(",
"dcm",
")",
"dcm",
"end"
] |
Performs anonymization of a DICOM file.
@param [String] file a DICOM file path
|
[
"Performs",
"anonymization",
"of",
"a",
"DICOM",
"file",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/anonymizer.rb#L353-L361
|
22,306 |
dicom/ruby-dicom
|
lib/dicom/anonymizer.rb
|
DICOM.Anonymizer.default_value
|
def default_value(tag)
name, vr = LIBRARY.name_and_vr(tag)
conversion = VALUE_CONVERSION[vr]
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
|
ruby
|
def default_value(tag)
name, vr = LIBRARY.name_and_vr(tag)
conversion = VALUE_CONVERSION[vr]
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
|
[
"def",
"default_value",
"(",
"tag",
")",
"name",
",",
"vr",
"=",
"LIBRARY",
".",
"name_and_vr",
"(",
"tag",
")",
"conversion",
"=",
"VALUE_CONVERSION",
"[",
"vr",
"]",
"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"
] |
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
|
[
"Determines",
"a",
"default",
"value",
"to",
"use",
"for",
"anonymizing",
"the",
"given",
"tag",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/anonymizer.rb#L387-L397
|
22,307 |
dicom/ruby-dicom
|
lib/dicom/anonymizer.rb
|
DICOM.Anonymizer.destination
|
def destination(dcm)
# Separate the path from the source file string:
file_start = dcm.source.rindex(File.basename(dcm.source))
if file_start == 0
source_dir = "."
else
source_dir = dcm.source[0..(file_start-1)]
end
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
|
ruby
|
def destination(dcm)
# Separate the path from the source file string:
file_start = dcm.source.rindex(File.basename(dcm.source))
if file_start == 0
source_dir = "."
else
source_dir = dcm.source[0..(file_start-1)]
end
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
|
[
"def",
"destination",
"(",
"dcm",
")",
"# Separate the path from the source file string:",
"file_start",
"=",
"dcm",
".",
"source",
".",
"rindex",
"(",
"File",
".",
"basename",
"(",
"dcm",
".",
"source",
")",
")",
"if",
"file_start",
"==",
"0",
"source_dir",
"=",
"\".\"",
"else",
"source_dir",
"=",
"dcm",
".",
"source",
"[",
"0",
"..",
"(",
"file_start",
"-",
"1",
")",
"]",
"end",
"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"
] |
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
|
[
"Creates",
"a",
"write",
"path",
"for",
"the",
"given",
"DICOM",
"object",
"based",
"on",
"the",
"object",
"s",
"original",
"file",
"path",
"and",
"the",
"write_path",
"attribute",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/anonymizer.rb#L405-L429
|
22,308 |
dicom/ruby-dicom
|
lib/dicom/anonymizer.rb
|
DICOM.Anonymizer.enumerated_value
|
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
|
ruby
|
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
|
[
"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"
] |
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 [Integer] 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
|
[
"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",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/anonymizer.rb#L477-L517
|
22,309 |
dicom/ruby-dicom
|
lib/dicom/anonymizer.rb
|
DICOM.Anonymizer.replace_uids
|
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
|
ruby
|
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
|
[
"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"
] |
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
|
[
"Replaces",
"the",
"UIDs",
"of",
"the",
"given",
"DICOM",
"object",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/anonymizer.rb#L550-L576
|
22,310 |
dicom/ruby-dicom
|
lib/dicom/anonymizer.rb
|
DICOM.Anonymizer.set_defaults
|
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
|
ruby
|
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
|
[
"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"
] |
Sets up some default information variables that are used by the Anonymizer.
|
[
"Sets",
"up",
"some",
"default",
"information",
"variables",
"that",
"are",
"used",
"by",
"the",
"Anonymizer",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/anonymizer.rb#L580-L639
|
22,311 |
dicom/ruby-dicom
|
lib/dicom/anonymizer.rb
|
DICOM.Anonymizer.write
|
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
|
ruby
|
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
|
[
"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"
] |
Writes a DICOM object to file.
@param [DObject] dcm a DICOM object
|
[
"Writes",
"a",
"DICOM",
"object",
"to",
"file",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/anonymizer.rb#L657-L673
|
22,312 |
dicom/ruby-dicom
|
lib/dicom/element.rb
|
DICOM.Element.value=
|
def value=(new_value)
if VALUE_CONVERSION[@vr] == :to_s
# Unless this is actually the Character Set data element,
# get the character set (note that it may not be available):
character_set = (@tag != '0008,0005' && top_parent.is_a?(DObject)) ? top_parent.value('0008,0005') : nil
# Convert to [DObject encoding] from [input string encoding]:
# In most cases the DObject encoding is IS0-8859-1 (ISO_IR 100), but if
# it is not specified in the DICOM object, or if the specified string
# is not recognized, ASCII-8BIT is assumed.
@value = new_value.to_s.encode(ENCODING_NAME[character_set], new_value.to_s.encoding.name)
@bin = encode(@value)
else
# We may have an array (of numbers) which needs to be passed directly to
# the encode method instead of being forced into a numerical:
if new_value.is_a?(Array)
@value = new_value
@bin = encode(@value)
else
@value = new_value.send(VALUE_CONVERSION[@vr])
@bin = encode(@value)
end
end
@length = @bin.length
end
|
ruby
|
def value=(new_value)
if VALUE_CONVERSION[@vr] == :to_s
# Unless this is actually the Character Set data element,
# get the character set (note that it may not be available):
character_set = (@tag != '0008,0005' && top_parent.is_a?(DObject)) ? top_parent.value('0008,0005') : nil
# Convert to [DObject encoding] from [input string encoding]:
# In most cases the DObject encoding is IS0-8859-1 (ISO_IR 100), but if
# it is not specified in the DICOM object, or if the specified string
# is not recognized, ASCII-8BIT is assumed.
@value = new_value.to_s.encode(ENCODING_NAME[character_set], new_value.to_s.encoding.name)
@bin = encode(@value)
else
# We may have an array (of numbers) which needs to be passed directly to
# the encode method instead of being forced into a numerical:
if new_value.is_a?(Array)
@value = new_value
@bin = encode(@value)
else
@value = new_value.send(VALUE_CONVERSION[@vr])
@bin = encode(@value)
end
end
@length = @bin.length
end
|
[
"def",
"value",
"=",
"(",
"new_value",
")",
"if",
"VALUE_CONVERSION",
"[",
"@vr",
"]",
"==",
":to_s",
"# Unless this is actually the Character Set data element,",
"# get the character set (note that it may not be available):",
"character_set",
"=",
"(",
"@tag",
"!=",
"'0008,0005'",
"&&",
"top_parent",
".",
"is_a?",
"(",
"DObject",
")",
")",
"?",
"top_parent",
".",
"value",
"(",
"'0008,0005'",
")",
":",
"nil",
"# Convert to [DObject encoding] from [input string encoding]:",
"# In most cases the DObject encoding is IS0-8859-1 (ISO_IR 100), but if",
"# it is not specified in the DICOM object, or if the specified string",
"# is not recognized, ASCII-8BIT is assumed.",
"@value",
"=",
"new_value",
".",
"to_s",
".",
"encode",
"(",
"ENCODING_NAME",
"[",
"character_set",
"]",
",",
"new_value",
".",
"to_s",
".",
"encoding",
".",
"name",
")",
"@bin",
"=",
"encode",
"(",
"@value",
")",
"else",
"# We may have an array (of numbers) which needs to be passed directly to",
"# the encode method instead of being forced into a numerical:",
"if",
"new_value",
".",
"is_a?",
"(",
"Array",
")",
"@value",
"=",
"new_value",
"@bin",
"=",
"encode",
"(",
"@value",
")",
"else",
"@value",
"=",
"new_value",
".",
"send",
"(",
"VALUE_CONVERSION",
"[",
"@vr",
"]",
")",
"@bin",
"=",
"encode",
"(",
"@value",
")",
"end",
"end",
"@length",
"=",
"@bin",
".",
"length",
"end"
] |
Sets the value of the Element instance.
In addition to updating the value attribute, the specified value is encoded to binary
and used to update the Element's bin and length attributes too.
@note The specified value must be of a type that is compatible with the Element's value representation (vr).
@param [String, Integer, Float, Array] new_value a formatted value that is assigned to the element
|
[
"Sets",
"the",
"value",
"of",
"the",
"Element",
"instance",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/element.rb#L231-L254
|
22,313 |
calabash/calabash
|
lib/calabash/ios/console_helpers.rb
|
Calabash.ConsoleHelpers.console_attach
|
def console_attach(uia_strategy=nil)
Calabash::Application.default = Calabash::IOS::Application.default_from_environment
identifier = Calabash::IOS::Device.default_identifier_for_application(Calabash::Application.default)
server = Calabash::IOS::Server.default
device = Calabash::IOS::Device.new(identifier, server)
Calabash::Device.default = device
begin
Calabash::Internal.with_current_target(required_os: :ios) {|target| target.ensure_test_server_ready({:timeout => 4})}
rescue RuntimeError => e
if e.to_s == 'Calabash server did not respond'
raise RuntimeError, 'You can only attach to a running Calabash iOS App'
else
raise e
end
end
run_loop_device = device.send(:run_loop_device)
result = Calabash::Internal.with_current_target(required_os: :ios) {|target| target.send(:attach_to_run_loop, run_loop_device, uia_strategy)}
result[:application] = Calabash::Application.default
result
end
|
ruby
|
def console_attach(uia_strategy=nil)
Calabash::Application.default = Calabash::IOS::Application.default_from_environment
identifier = Calabash::IOS::Device.default_identifier_for_application(Calabash::Application.default)
server = Calabash::IOS::Server.default
device = Calabash::IOS::Device.new(identifier, server)
Calabash::Device.default = device
begin
Calabash::Internal.with_current_target(required_os: :ios) {|target| target.ensure_test_server_ready({:timeout => 4})}
rescue RuntimeError => e
if e.to_s == 'Calabash server did not respond'
raise RuntimeError, 'You can only attach to a running Calabash iOS App'
else
raise e
end
end
run_loop_device = device.send(:run_loop_device)
result = Calabash::Internal.with_current_target(required_os: :ios) {|target| target.send(:attach_to_run_loop, run_loop_device, uia_strategy)}
result[:application] = Calabash::Application.default
result
end
|
[
"def",
"console_attach",
"(",
"uia_strategy",
"=",
"nil",
")",
"Calabash",
"::",
"Application",
".",
"default",
"=",
"Calabash",
"::",
"IOS",
"::",
"Application",
".",
"default_from_environment",
"identifier",
"=",
"Calabash",
"::",
"IOS",
"::",
"Device",
".",
"default_identifier_for_application",
"(",
"Calabash",
"::",
"Application",
".",
"default",
")",
"server",
"=",
"Calabash",
"::",
"IOS",
"::",
"Server",
".",
"default",
"device",
"=",
"Calabash",
"::",
"IOS",
"::",
"Device",
".",
"new",
"(",
"identifier",
",",
"server",
")",
"Calabash",
"::",
"Device",
".",
"default",
"=",
"device",
"begin",
"Calabash",
"::",
"Internal",
".",
"with_current_target",
"(",
"required_os",
":",
":ios",
")",
"{",
"|",
"target",
"|",
"target",
".",
"ensure_test_server_ready",
"(",
"{",
":timeout",
"=>",
"4",
"}",
")",
"}",
"rescue",
"RuntimeError",
"=>",
"e",
"if",
"e",
".",
"to_s",
"==",
"'Calabash server did not respond'",
"raise",
"RuntimeError",
",",
"'You can only attach to a running Calabash iOS App'",
"else",
"raise",
"e",
"end",
"end",
"run_loop_device",
"=",
"device",
".",
"send",
"(",
":run_loop_device",
")",
"result",
"=",
"Calabash",
"::",
"Internal",
".",
"with_current_target",
"(",
"required_os",
":",
":ios",
")",
"{",
"|",
"target",
"|",
"target",
".",
"send",
"(",
":attach_to_run_loop",
",",
"run_loop_device",
",",
"uia_strategy",
")",
"}",
"result",
"[",
":application",
"]",
"=",
"Calabash",
"::",
"Application",
".",
"default",
"result",
"end"
] |
Attach the current Calabash run-loop to a console.
@example
You have encountered a failing cucumber Scenario.
You open the console and want to start investigating the cause of the failure.
Use
> console_attach
to connect to the current run-loop so you can perform gestures.
@param [Symbol] uia_strategy Optionally specify the uia strategy, which
can be one of :shared_element, :preferences, :host. If you don't
know which to choose, don't specify one and calabash will try deduce
the correct strategy to use based on the environment variables used
when starting the console.
@return [Hash] The hash will contain the current device, the path to the
current application, and the run-loop strategy.
@raise [RuntimeError] If the app is not running.
|
[
"Attach",
"the",
"current",
"Calabash",
"run",
"-",
"loop",
"to",
"a",
"console",
"."
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/ios/console_helpers.rb#L48-L71
|
22,314 |
calabash/calabash
|
lib/calabash/device.rb
|
Calabash.Device.pan_between
|
def pan_between(query_from, query_to, options={})
ensure_query_class_or_nil(query_from)
ensure_query_class_or_nil(query_to)
gesture_options = options.dup
gesture_options[:timeout] ||= Calabash::Gestures::DEFAULT_GESTURE_WAIT_TIMEOUT
_pan_between(query_from, query_to, gesture_options)
end
|
ruby
|
def pan_between(query_from, query_to, options={})
ensure_query_class_or_nil(query_from)
ensure_query_class_or_nil(query_to)
gesture_options = options.dup
gesture_options[:timeout] ||= Calabash::Gestures::DEFAULT_GESTURE_WAIT_TIMEOUT
_pan_between(query_from, query_to, gesture_options)
end
|
[
"def",
"pan_between",
"(",
"query_from",
",",
"query_to",
",",
"options",
"=",
"{",
"}",
")",
"ensure_query_class_or_nil",
"(",
"query_from",
")",
"ensure_query_class_or_nil",
"(",
"query_to",
")",
"gesture_options",
"=",
"options",
".",
"dup",
"gesture_options",
"[",
":timeout",
"]",
"||=",
"Calabash",
"::",
"Gestures",
"::",
"DEFAULT_GESTURE_WAIT_TIMEOUT",
"_pan_between",
"(",
"query_from",
",",
"query_to",
",",
"gesture_options",
")",
"end"
] |
Performs a `pan` between two elements.
@see Calabash::Gestures#pan_between
@!visibility private
|
[
"Performs",
"a",
"pan",
"between",
"two",
"elements",
"."
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/device.rb#L182-L191
|
22,315 |
calabash/calabash
|
lib/calabash/device.rb
|
Calabash.Device.flick_between
|
def flick_between(query_from, query_to, options={})
ensure_query_class_or_nil(query_from)
ensure_query_class_or_nil(query_to)
gesture_options = options.dup
gesture_options[:timeout] ||= Calabash::Gestures::DEFAULT_GESTURE_WAIT_TIMEOUT
_flick_between(query_from, query_to, gesture_options)
end
|
ruby
|
def flick_between(query_from, query_to, options={})
ensure_query_class_or_nil(query_from)
ensure_query_class_or_nil(query_to)
gesture_options = options.dup
gesture_options[:timeout] ||= Calabash::Gestures::DEFAULT_GESTURE_WAIT_TIMEOUT
_flick_between(query_from, query_to, gesture_options)
end
|
[
"def",
"flick_between",
"(",
"query_from",
",",
"query_to",
",",
"options",
"=",
"{",
"}",
")",
"ensure_query_class_or_nil",
"(",
"query_from",
")",
"ensure_query_class_or_nil",
"(",
"query_to",
")",
"gesture_options",
"=",
"options",
".",
"dup",
"gesture_options",
"[",
":timeout",
"]",
"||=",
"Calabash",
"::",
"Gestures",
"::",
"DEFAULT_GESTURE_WAIT_TIMEOUT",
"_flick_between",
"(",
"query_from",
",",
"query_to",
",",
"gesture_options",
")",
"end"
] |
Performs a `flick` between two elements.
@!visibility private
|
[
"Performs",
"a",
"flick",
"between",
"two",
"elements",
"."
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/device.rb#L195-L204
|
22,316 |
calabash/calabash
|
lib/calabash/web.rb
|
Calabash.Web.evaluate_javascript_in
|
def evaluate_javascript_in(query, javascript)
wait_for_view(query,
timeout: Calabash::Gestures::DEFAULT_GESTURE_WAIT_TIMEOUT)
_evaluate_javascript_in(query, javascript)
end
|
ruby
|
def evaluate_javascript_in(query, javascript)
wait_for_view(query,
timeout: Calabash::Gestures::DEFAULT_GESTURE_WAIT_TIMEOUT)
_evaluate_javascript_in(query, javascript)
end
|
[
"def",
"evaluate_javascript_in",
"(",
"query",
",",
"javascript",
")",
"wait_for_view",
"(",
"query",
",",
"timeout",
":",
"Calabash",
"::",
"Gestures",
"::",
"DEFAULT_GESTURE_WAIT_TIMEOUT",
")",
"_evaluate_javascript_in",
"(",
"query",
",",
"javascript",
")",
"end"
] |
Evaluate javascript in a Web View. On iOS, an implicit return is
inserted, on Android an explicit return is needed.
@example
# iOS
cal.evaluate_javascript_in("UIWebView", "2+2")
# Android
cal.evaluate_javascript_in("WebView", "return 2+2")
@example
# iOS
cal.evaluate_javascript_in("WKWebView",
"document.body.style.backgroundColor = 'red';")
# Android
cal.evaluate_javascript_in("XWalkContent",
"document.body.style.backgroundColor = 'red';")
@note No error will be raised if the javascript given is invalid, or
throws an exception.
@param [String, Hash, Calabash::Query] query Query that matches the
webview
@param [String] javascript The javascript to evaluate
@raise ViewNotFoundError If no views are found matching `query`
|
[
"Evaluate",
"javascript",
"in",
"a",
"Web",
"View",
".",
"On",
"iOS",
"an",
"implicit",
"return",
"is",
"inserted",
"on",
"Android",
"an",
"explicit",
"return",
"is",
"needed",
"."
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/web.rb#L30-L35
|
22,317 |
calabash/calabash
|
lib/calabash/text.rb
|
Calabash.Text.wait_for_keyboard
|
def wait_for_keyboard(timeout: nil)
keyboard_timeout = keyboard_wait_timeout(timeout)
message = "Timed out after #{keyboard_timeout} seconds waiting for the keyboard to appear"
wait_for(message, timeout: keyboard_timeout) do
keyboard_visible?
end
end
|
ruby
|
def wait_for_keyboard(timeout: nil)
keyboard_timeout = keyboard_wait_timeout(timeout)
message = "Timed out after #{keyboard_timeout} seconds waiting for the keyboard to appear"
wait_for(message, timeout: keyboard_timeout) do
keyboard_visible?
end
end
|
[
"def",
"wait_for_keyboard",
"(",
"timeout",
":",
"nil",
")",
"keyboard_timeout",
"=",
"keyboard_wait_timeout",
"(",
"timeout",
")",
"message",
"=",
"\"Timed out after #{keyboard_timeout} seconds waiting for the keyboard to appear\"",
"wait_for",
"(",
"message",
",",
"timeout",
":",
"keyboard_timeout",
")",
"do",
"keyboard_visible?",
"end",
"end"
] |
Waits for a keyboard to appear.
@see Calabash::Wait.default_options
@param [Number] timeout How long to wait for the keyboard.
@raise [Calabash::Wait::TimeoutError] Raises error if no keyboard
appears.
|
[
"Waits",
"for",
"a",
"keyboard",
"to",
"appear",
"."
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/text.rb#L125-L131
|
22,318 |
calabash/calabash
|
lib/calabash/text.rb
|
Calabash.Text.wait_for_no_keyboard
|
def wait_for_no_keyboard(timeout: nil)
keyboard_timeout = keyboard_wait_timeout(timeout)
message = "Timed out after #{keyboard_timeout} seconds waiting for the keyboard to disappear"
wait_for(message, timeout: keyboard_timeout) do
!keyboard_visible?
end
end
|
ruby
|
def wait_for_no_keyboard(timeout: nil)
keyboard_timeout = keyboard_wait_timeout(timeout)
message = "Timed out after #{keyboard_timeout} seconds waiting for the keyboard to disappear"
wait_for(message, timeout: keyboard_timeout) do
!keyboard_visible?
end
end
|
[
"def",
"wait_for_no_keyboard",
"(",
"timeout",
":",
"nil",
")",
"keyboard_timeout",
"=",
"keyboard_wait_timeout",
"(",
"timeout",
")",
"message",
"=",
"\"Timed out after #{keyboard_timeout} seconds waiting for the keyboard to disappear\"",
"wait_for",
"(",
"message",
",",
"timeout",
":",
"keyboard_timeout",
")",
"do",
"!",
"keyboard_visible?",
"end",
"end"
] |
Waits for the keyboard to disappear.
@see Calabash::Wait.default_options
@param [Number] timeout How log to wait for the keyboard to disappear.
@raise [Calabash::Wait::TimeoutError] Raises error if any keyboard is
visible after the `timeout`.
|
[
"Waits",
"for",
"the",
"keyboard",
"to",
"disappear",
"."
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/text.rb#L140-L146
|
22,319 |
dicom/ruby-dicom
|
lib/dicom/d_client.rb
|
DICOM.DClient.find_series
|
def find_series(query_params={})
# Study Root Query/Retrieve Information Model - FIND:
set_default_presentation_context("1.2.840.10008.5.1.4.1.2.2.1")
# Every query attribute with a value != nil (required) will be sent in the dicom query.
# The query parameters with nil-value (optional) are left out unless specified.
default_query_params = {
"0008,0052" => "SERIES", # Query/Retrieve Level: "SERIES"
"0008,0060" => "", # Modality
"0020,000E" => "", # Series Instance UID
"0020,0011" => "" # Series Number
}
# Raising an error if a non-tag query attribute is used:
query_params.keys.each do |tag|
raise ArgumentError, "The supplied tag (#{tag}) is not valid. It must be a string of the form 'GGGG,EEEE'." unless tag.is_a?(String) && tag.tag?
end
# Set up the query parameters and carry out the C-FIND:
set_data_elements(default_query_params.merge(query_params))
perform_find
return @data_results
end
|
ruby
|
def find_series(query_params={})
# Study Root Query/Retrieve Information Model - FIND:
set_default_presentation_context("1.2.840.10008.5.1.4.1.2.2.1")
# Every query attribute with a value != nil (required) will be sent in the dicom query.
# The query parameters with nil-value (optional) are left out unless specified.
default_query_params = {
"0008,0052" => "SERIES", # Query/Retrieve Level: "SERIES"
"0008,0060" => "", # Modality
"0020,000E" => "", # Series Instance UID
"0020,0011" => "" # Series Number
}
# Raising an error if a non-tag query attribute is used:
query_params.keys.each do |tag|
raise ArgumentError, "The supplied tag (#{tag}) is not valid. It must be a string of the form 'GGGG,EEEE'." unless tag.is_a?(String) && tag.tag?
end
# Set up the query parameters and carry out the C-FIND:
set_data_elements(default_query_params.merge(query_params))
perform_find
return @data_results
end
|
[
"def",
"find_series",
"(",
"query_params",
"=",
"{",
"}",
")",
"# Study Root Query/Retrieve Information Model - FIND:",
"set_default_presentation_context",
"(",
"\"1.2.840.10008.5.1.4.1.2.2.1\"",
")",
"# Every query attribute with a value != nil (required) will be sent in the dicom query.",
"# The query parameters with nil-value (optional) are left out unless specified.",
"default_query_params",
"=",
"{",
"\"0008,0052\"",
"=>",
"\"SERIES\"",
",",
"# Query/Retrieve Level: \"SERIES\"",
"\"0008,0060\"",
"=>",
"\"\"",
",",
"# Modality",
"\"0020,000E\"",
"=>",
"\"\"",
",",
"# Series Instance UID",
"\"0020,0011\"",
"=>",
"\"\"",
"# Series Number",
"}",
"# Raising an error if a non-tag query attribute is used:",
"query_params",
".",
"keys",
".",
"each",
"do",
"|",
"tag",
"|",
"raise",
"ArgumentError",
",",
"\"The supplied tag (#{tag}) is not valid. It must be a string of the form 'GGGG,EEEE'.\"",
"unless",
"tag",
".",
"is_a?",
"(",
"String",
")",
"&&",
"tag",
".",
"tag?",
"end",
"# Set up the query parameters and carry out the C-FIND:",
"set_data_elements",
"(",
"default_query_params",
".",
"merge",
"(",
"query_params",
")",
")",
"perform_find",
"return",
"@data_results",
"end"
] |
Queries a service class provider for series that match the specified criteria.
=== Instance level attributes for this query:
* '0008,0060' (Modality)
* '0020,000E' (Series Instance UID)
* '0020,0011' (Series Number)
In addition to the above listed attributes, a number of "optional" attributes
may be specified. For a general list of optional object instance level attributes,
please refer to the DICOM standard, PS3.4 C.6.1.1.4, Table C.6-3.
@note Caution: Calling this method without parameters will instruct your PACS
to return info on ALL series in the database!
@param [Hash] query_params the query parameters to use
@option query_params [String] 'GGGG,EEEE' a tag and value pair to be used in the query
@example Find all series belonging to the given study
node.find_series('0020,000D' => '1.2.840.1145.342')
|
[
"Queries",
"a",
"service",
"class",
"provider",
"for",
"series",
"that",
"match",
"the",
"specified",
"criteria",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_client.rb#L177-L196
|
22,320 |
dicom/ruby-dicom
|
lib/dicom/d_client.rb
|
DICOM.DClient.move_image
|
def move_image(destination, options={})
# Study Root Query/Retrieve Information Model - MOVE:
set_default_presentation_context("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
|
ruby
|
def move_image(destination, options={})
# Study Root Query/Retrieve Information Model - MOVE:
set_default_presentation_context("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
|
[
"def",
"move_image",
"(",
"destination",
",",
"options",
"=",
"{",
"}",
")",
"# Study Root Query/Retrieve Information Model - MOVE:",
"set_default_presentation_context",
"(",
"\"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"
] |
Moves a single image to a DICOM server.
This DICOM node must be a third party (i.e. not the client instance you
are requesting the move with!).
=== Instance level attributes for this procedure:
* '0008,0018' (SOP Instance UID)
* '0008,0052' (Query/Retrieve Level)
* '0020,000D' (Study Instance UID)
* '0020,000E' (Series Instance UID)
@param [String] destination the AE title of the DICOM server which will receive the file
@param [Hash] options the options to use for moving the DICOM object
@option options [String] 'GGGG,EEEE' a tag and value pair to be used for the procedure
@example Move an image from e.q. a PACS to another SCP on the network
node.move_image('SOME_SERVER', '0008,0018' => sop_uid, '0020,000D' => study_uid, '0020,000E' => series_uid)
|
[
"Moves",
"a",
"single",
"image",
"to",
"a",
"DICOM",
"server",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_client.rb#L296-L305
|
22,321 |
dicom/ruby-dicom
|
lib/dicom/d_client.rb
|
DICOM.DClient.move_study
|
def move_study(destination, options={})
# Study Root Query/Retrieve Information Model - MOVE:
set_default_presentation_context("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
|
ruby
|
def move_study(destination, options={})
# Study Root Query/Retrieve Information Model - MOVE:
set_default_presentation_context("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
|
[
"def",
"move_study",
"(",
"destination",
",",
"options",
"=",
"{",
"}",
")",
"# Study Root Query/Retrieve Information Model - MOVE:",
"set_default_presentation_context",
"(",
"\"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"
] |
Move an entire study to a DICOM server.
This DICOM node must be a third party (i.e. not the client instance you
are requesting the move with!).
=== Instance level attributes for this procedure:
* '0008,0052' (Query/Retrieve Level)
* '0010,0020' (Patient ID)
* '0020,000D' (Study Instance UID)
@param [String] destination the AE title of the DICOM server which will receive the files
@param [Hash] options the options to use for moving the DICOM objects
@option options [String] 'GGGG,EEEE' a tag and value pair to be used for the procedure
@example Move an entire study from e.q. a PACS to another SCP on the network
node.move_study('SOME_SERVER', '0010,0020' => pat_id, '0020,000D' => study_uid)
|
[
"Move",
"an",
"entire",
"study",
"to",
"a",
"DICOM",
"server",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_client.rb#L325-L334
|
22,322 |
dicom/ruby-dicom
|
lib/dicom/d_client.rb
|
DICOM.DClient.available_transfer_syntaxes
|
def available_transfer_syntaxes(transfer_syntax)
case transfer_syntax
when IMPLICIT_LITTLE_ENDIAN
return [IMPLICIT_LITTLE_ENDIAN, EXPLICIT_LITTLE_ENDIAN]
when EXPLICIT_LITTLE_ENDIAN
return [EXPLICIT_LITTLE_ENDIAN, IMPLICIT_LITTLE_ENDIAN]
when EXPLICIT_BIG_ENDIAN
return [EXPLICIT_BIG_ENDIAN, IMPLICIT_LITTLE_ENDIAN]
else # Compression:
return [transfer_syntax]
end
end
|
ruby
|
def available_transfer_syntaxes(transfer_syntax)
case transfer_syntax
when IMPLICIT_LITTLE_ENDIAN
return [IMPLICIT_LITTLE_ENDIAN, EXPLICIT_LITTLE_ENDIAN]
when EXPLICIT_LITTLE_ENDIAN
return [EXPLICIT_LITTLE_ENDIAN, IMPLICIT_LITTLE_ENDIAN]
when EXPLICIT_BIG_ENDIAN
return [EXPLICIT_BIG_ENDIAN, IMPLICIT_LITTLE_ENDIAN]
else # Compression:
return [transfer_syntax]
end
end
|
[
"def",
"available_transfer_syntaxes",
"(",
"transfer_syntax",
")",
"case",
"transfer_syntax",
"when",
"IMPLICIT_LITTLE_ENDIAN",
"return",
"[",
"IMPLICIT_LITTLE_ENDIAN",
",",
"EXPLICIT_LITTLE_ENDIAN",
"]",
"when",
"EXPLICIT_LITTLE_ENDIAN",
"return",
"[",
"EXPLICIT_LITTLE_ENDIAN",
",",
"IMPLICIT_LITTLE_ENDIAN",
"]",
"when",
"EXPLICIT_BIG_ENDIAN",
"return",
"[",
"EXPLICIT_BIG_ENDIAN",
",",
"IMPLICIT_LITTLE_ENDIAN",
"]",
"else",
"# Compression:",
"return",
"[",
"transfer_syntax",
"]",
"end",
"end"
] |
Returns an array of supported transfer syntaxes for the specified transfer syntax.
For compressed transfer syntaxes, we currently do not support reencoding these to other syntaxes.
|
[
"Returns",
"an",
"array",
"of",
"supported",
"transfer",
"syntaxes",
"for",
"the",
"specified",
"transfer",
"syntax",
".",
"For",
"compressed",
"transfer",
"syntaxes",
"we",
"currently",
"do",
"not",
"support",
"reencoding",
"these",
"to",
"other",
"syntaxes",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_client.rb#L395-L406
|
22,323 |
dicom/ruby-dicom
|
lib/dicom/d_client.rb
|
DICOM.DClient.establish_association
|
def establish_association
# Reset some variables:
@association = false
@request_approved = false
# Initiate the association:
@link.build_association_request(@presentation_contexts, @user_information)
@link.start_session(@host_ip, @port)
@link.transmit
info = @link.receive_multiple_transmissions.first
# Interpret the results:
if info && info[:valid]
if info[:pdu] == PDU_ASSOCIATION_ACCEPT
# Values of importance are extracted and put into instance variables:
@association = true
@max_pdu_length = info[:max_pdu_length]
logger.info("Association successfully negotiated with host #{@host_ae} (#{@host_ip}).")
# Check if all our presentation contexts was accepted by the host:
process_presentation_context_response(info[:pc])
else
logger.error("Association was denied from host #{@host_ae} (#{@host_ip})!")
end
end
end
|
ruby
|
def establish_association
# Reset some variables:
@association = false
@request_approved = false
# Initiate the association:
@link.build_association_request(@presentation_contexts, @user_information)
@link.start_session(@host_ip, @port)
@link.transmit
info = @link.receive_multiple_transmissions.first
# Interpret the results:
if info && info[:valid]
if info[:pdu] == PDU_ASSOCIATION_ACCEPT
# Values of importance are extracted and put into instance variables:
@association = true
@max_pdu_length = info[:max_pdu_length]
logger.info("Association successfully negotiated with host #{@host_ae} (#{@host_ip}).")
# Check if all our presentation contexts was accepted by the host:
process_presentation_context_response(info[:pc])
else
logger.error("Association was denied from host #{@host_ae} (#{@host_ip})!")
end
end
end
|
[
"def",
"establish_association",
"# Reset some variables:",
"@association",
"=",
"false",
"@request_approved",
"=",
"false",
"# Initiate the association:",
"@link",
".",
"build_association_request",
"(",
"@presentation_contexts",
",",
"@user_information",
")",
"@link",
".",
"start_session",
"(",
"@host_ip",
",",
"@port",
")",
"@link",
".",
"transmit",
"info",
"=",
"@link",
".",
"receive_multiple_transmissions",
".",
"first",
"# Interpret the results:",
"if",
"info",
"&&",
"info",
"[",
":valid",
"]",
"if",
"info",
"[",
":pdu",
"]",
"==",
"PDU_ASSOCIATION_ACCEPT",
"# Values of importance are extracted and put into instance variables:",
"@association",
"=",
"true",
"@max_pdu_length",
"=",
"info",
"[",
":max_pdu_length",
"]",
"logger",
".",
"info",
"(",
"\"Association successfully negotiated with host #{@host_ae} (#{@host_ip}).\"",
")",
"# Check if all our presentation contexts was accepted by the host:",
"process_presentation_context_response",
"(",
"info",
"[",
":pc",
"]",
")",
"else",
"logger",
".",
"error",
"(",
"\"Association was denied from host #{@host_ae} (#{@host_ip})!\"",
")",
"end",
"end",
"end"
] |
Opens a TCP session with the server, and handles the association request as well as the response.
|
[
"Opens",
"a",
"TCP",
"session",
"with",
"the",
"server",
"and",
"handles",
"the",
"association",
"request",
"as",
"well",
"as",
"the",
"response",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_client.rb#L410-L432
|
22,324 |
dicom/ruby-dicom
|
lib/dicom/d_client.rb
|
DICOM.DClient.establish_release
|
def establish_release
@release = false
if @abort
@link.stop_session
logger.info("Association has been closed. (#{@host_ae}, #{@host_ip})")
else
unless @link.session.closed?
@link.build_release_request
@link.transmit
info = @link.receive_single_transmission.first
@link.stop_session
if info[:pdu] == PDU_RELEASE_RESPONSE
logger.info("Association released properly from host #{@host_ae}.")
else
logger.error("Association released from host #{@host_ae}, but a release response was not registered.")
end
else
logger.error("Connection was closed by the host (for some unknown reason) before the association could be released properly.")
end
end
@abort = false
end
|
ruby
|
def establish_release
@release = false
if @abort
@link.stop_session
logger.info("Association has been closed. (#{@host_ae}, #{@host_ip})")
else
unless @link.session.closed?
@link.build_release_request
@link.transmit
info = @link.receive_single_transmission.first
@link.stop_session
if info[:pdu] == PDU_RELEASE_RESPONSE
logger.info("Association released properly from host #{@host_ae}.")
else
logger.error("Association released from host #{@host_ae}, but a release response was not registered.")
end
else
logger.error("Connection was closed by the host (for some unknown reason) before the association could be released properly.")
end
end
@abort = false
end
|
[
"def",
"establish_release",
"@release",
"=",
"false",
"if",
"@abort",
"@link",
".",
"stop_session",
"logger",
".",
"info",
"(",
"\"Association has been closed. (#{@host_ae}, #{@host_ip})\"",
")",
"else",
"unless",
"@link",
".",
"session",
".",
"closed?",
"@link",
".",
"build_release_request",
"@link",
".",
"transmit",
"info",
"=",
"@link",
".",
"receive_single_transmission",
".",
"first",
"@link",
".",
"stop_session",
"if",
"info",
"[",
":pdu",
"]",
"==",
"PDU_RELEASE_RESPONSE",
"logger",
".",
"info",
"(",
"\"Association released properly from host #{@host_ae}.\"",
")",
"else",
"logger",
".",
"error",
"(",
"\"Association released from host #{@host_ae}, but a release response was not registered.\"",
")",
"end",
"else",
"logger",
".",
"error",
"(",
"\"Connection was closed by the host (for some unknown reason) before the association could be released properly.\"",
")",
"end",
"end",
"@abort",
"=",
"false",
"end"
] |
Handles the release request along with the response, as well as closing the TCP connection.
|
[
"Handles",
"the",
"release",
"request",
"along",
"with",
"the",
"response",
"as",
"well",
"as",
"closing",
"the",
"TCP",
"connection",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_client.rb#L436-L457
|
22,325 |
dicom/ruby-dicom
|
lib/dicom/d_client.rb
|
DICOM.DClient.load_files
|
def load_files(files_or_objects)
files_or_objects = [files_or_objects] unless files_or_objects.is_a?(Array)
status = true
message = ""
objects = Array.new
abstracts = Array.new
id = 1
@presentation_contexts = Hash.new
files_or_objects.each do |file_or_object|
if file_or_object.is_a?(String)
# Temporarily increase the log threshold to suppress messages from the DObject class:
client_level = logger.level
logger.level = Logger::FATAL
dcm = DObject.read(file_or_object)
# Reset the logg threshold:
logger.level = client_level
if dcm.read_success
# Load the DICOM object:
objects << dcm
else
status = false
message = "Failed to read a DObject from this file: #{file_or_object}"
end
elsif file_or_object.is_a?(DObject)
# Load the DICOM object and its abstract syntax:
abstracts << file_or_object.value("0008,0016")
objects << file_or_object
else
status = false
message = "Array contains invalid object: #{file_or_object.class}."
end
end
# Extract available transfer syntaxes for the various sop classes found amongst these objects
syntaxes = Hash.new
objects.each do |dcm|
sop_class = dcm.value("0008,0016")
if sop_class
transfer_syntaxes = available_transfer_syntaxes(dcm.transfer_syntax)
if syntaxes[sop_class]
syntaxes[sop_class] << transfer_syntaxes
else
syntaxes[sop_class] = transfer_syntaxes
end
else
status = false
message = "Missing SOP Class UID. Unable to transmit DICOM object"
end
# Extract the unique variations of SOP Class and syntaxes and construct the presentation context hash:
syntaxes.each_pair do |sop_class, ts|
selected_transfer_syntaxes = ts.flatten.uniq
@presentation_contexts[sop_class] = Hash.new
selected_transfer_syntaxes.each do |syntax|
@presentation_contexts[sop_class][id] = {:transfer_syntaxes => [syntax]}
id += 2
end
end
end
return objects, status, message
end
|
ruby
|
def load_files(files_or_objects)
files_or_objects = [files_or_objects] unless files_or_objects.is_a?(Array)
status = true
message = ""
objects = Array.new
abstracts = Array.new
id = 1
@presentation_contexts = Hash.new
files_or_objects.each do |file_or_object|
if file_or_object.is_a?(String)
# Temporarily increase the log threshold to suppress messages from the DObject class:
client_level = logger.level
logger.level = Logger::FATAL
dcm = DObject.read(file_or_object)
# Reset the logg threshold:
logger.level = client_level
if dcm.read_success
# Load the DICOM object:
objects << dcm
else
status = false
message = "Failed to read a DObject from this file: #{file_or_object}"
end
elsif file_or_object.is_a?(DObject)
# Load the DICOM object and its abstract syntax:
abstracts << file_or_object.value("0008,0016")
objects << file_or_object
else
status = false
message = "Array contains invalid object: #{file_or_object.class}."
end
end
# Extract available transfer syntaxes for the various sop classes found amongst these objects
syntaxes = Hash.new
objects.each do |dcm|
sop_class = dcm.value("0008,0016")
if sop_class
transfer_syntaxes = available_transfer_syntaxes(dcm.transfer_syntax)
if syntaxes[sop_class]
syntaxes[sop_class] << transfer_syntaxes
else
syntaxes[sop_class] = transfer_syntaxes
end
else
status = false
message = "Missing SOP Class UID. Unable to transmit DICOM object"
end
# Extract the unique variations of SOP Class and syntaxes and construct the presentation context hash:
syntaxes.each_pair do |sop_class, ts|
selected_transfer_syntaxes = ts.flatten.uniq
@presentation_contexts[sop_class] = Hash.new
selected_transfer_syntaxes.each do |syntax|
@presentation_contexts[sop_class][id] = {:transfer_syntaxes => [syntax]}
id += 2
end
end
end
return objects, status, message
end
|
[
"def",
"load_files",
"(",
"files_or_objects",
")",
"files_or_objects",
"=",
"[",
"files_or_objects",
"]",
"unless",
"files_or_objects",
".",
"is_a?",
"(",
"Array",
")",
"status",
"=",
"true",
"message",
"=",
"\"\"",
"objects",
"=",
"Array",
".",
"new",
"abstracts",
"=",
"Array",
".",
"new",
"id",
"=",
"1",
"@presentation_contexts",
"=",
"Hash",
".",
"new",
"files_or_objects",
".",
"each",
"do",
"|",
"file_or_object",
"|",
"if",
"file_or_object",
".",
"is_a?",
"(",
"String",
")",
"# Temporarily increase the log threshold to suppress messages from the DObject class:",
"client_level",
"=",
"logger",
".",
"level",
"logger",
".",
"level",
"=",
"Logger",
"::",
"FATAL",
"dcm",
"=",
"DObject",
".",
"read",
"(",
"file_or_object",
")",
"# Reset the logg threshold:",
"logger",
".",
"level",
"=",
"client_level",
"if",
"dcm",
".",
"read_success",
"# Load the DICOM object:",
"objects",
"<<",
"dcm",
"else",
"status",
"=",
"false",
"message",
"=",
"\"Failed to read a DObject from this file: #{file_or_object}\"",
"end",
"elsif",
"file_or_object",
".",
"is_a?",
"(",
"DObject",
")",
"# Load the DICOM object and its abstract syntax:",
"abstracts",
"<<",
"file_or_object",
".",
"value",
"(",
"\"0008,0016\"",
")",
"objects",
"<<",
"file_or_object",
"else",
"status",
"=",
"false",
"message",
"=",
"\"Array contains invalid object: #{file_or_object.class}.\"",
"end",
"end",
"# Extract available transfer syntaxes for the various sop classes found amongst these objects",
"syntaxes",
"=",
"Hash",
".",
"new",
"objects",
".",
"each",
"do",
"|",
"dcm",
"|",
"sop_class",
"=",
"dcm",
".",
"value",
"(",
"\"0008,0016\"",
")",
"if",
"sop_class",
"transfer_syntaxes",
"=",
"available_transfer_syntaxes",
"(",
"dcm",
".",
"transfer_syntax",
")",
"if",
"syntaxes",
"[",
"sop_class",
"]",
"syntaxes",
"[",
"sop_class",
"]",
"<<",
"transfer_syntaxes",
"else",
"syntaxes",
"[",
"sop_class",
"]",
"=",
"transfer_syntaxes",
"end",
"else",
"status",
"=",
"false",
"message",
"=",
"\"Missing SOP Class UID. Unable to transmit DICOM object\"",
"end",
"# Extract the unique variations of SOP Class and syntaxes and construct the presentation context hash:",
"syntaxes",
".",
"each_pair",
"do",
"|",
"sop_class",
",",
"ts",
"|",
"selected_transfer_syntaxes",
"=",
"ts",
".",
"flatten",
".",
"uniq",
"@presentation_contexts",
"[",
"sop_class",
"]",
"=",
"Hash",
".",
"new",
"selected_transfer_syntaxes",
".",
"each",
"do",
"|",
"syntax",
"|",
"@presentation_contexts",
"[",
"sop_class",
"]",
"[",
"id",
"]",
"=",
"{",
":transfer_syntaxes",
"=>",
"[",
"syntax",
"]",
"}",
"id",
"+=",
"2",
"end",
"end",
"end",
"return",
"objects",
",",
"status",
",",
"message",
"end"
] |
Loads one or more DICOM files.
Returns an array of DObject instances, an array of unique abstract syntaxes found among the files, a status boolean and a message string.
=== Parameters
* <tt>files_or_objects</tt> -- A single file path or an array of paths, or a DObject or an array of DObject instances.
|
[
"Loads",
"one",
"or",
"more",
"DICOM",
"files",
".",
"Returns",
"an",
"array",
"of",
"DObject",
"instances",
"an",
"array",
"of",
"unique",
"abstract",
"syntaxes",
"found",
"among",
"the",
"files",
"a",
"status",
"boolean",
"and",
"a",
"message",
"string",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_client.rb#L474-L532
|
22,326 |
dicom/ruby-dicom
|
lib/dicom/d_client.rb
|
DICOM.DClient.perform_echo
|
def perform_echo
# Open a DICOM link:
establish_association
if association_established?
if request_approved?
# Continue with our echo, since the request was accepted.
# Set the query command elements array:
set_command_fragment_echo
@link.build_command_fragment(PDU_DATA, presentation_context_id, COMMAND_LAST_FRAGMENT, @command_elements)
@link.transmit
# Listen for incoming responses and interpret them individually, until we have received the last command fragment.
segments = @link.receive_multiple_transmissions
process_returned_data(segments)
# Print stuff to screen?
end
# Close the DICOM link:
establish_release
end
end
|
ruby
|
def perform_echo
# Open a DICOM link:
establish_association
if association_established?
if request_approved?
# Continue with our echo, since the request was accepted.
# Set the query command elements array:
set_command_fragment_echo
@link.build_command_fragment(PDU_DATA, presentation_context_id, COMMAND_LAST_FRAGMENT, @command_elements)
@link.transmit
# Listen for incoming responses and interpret them individually, until we have received the last command fragment.
segments = @link.receive_multiple_transmissions
process_returned_data(segments)
# Print stuff to screen?
end
# Close the DICOM link:
establish_release
end
end
|
[
"def",
"perform_echo",
"# Open a DICOM link:",
"establish_association",
"if",
"association_established?",
"if",
"request_approved?",
"# Continue with our echo, since the request was accepted.",
"# Set the query command elements array:",
"set_command_fragment_echo",
"@link",
".",
"build_command_fragment",
"(",
"PDU_DATA",
",",
"presentation_context_id",
",",
"COMMAND_LAST_FRAGMENT",
",",
"@command_elements",
")",
"@link",
".",
"transmit",
"# Listen for incoming responses and interpret them individually, until we have received the last command fragment.",
"segments",
"=",
"@link",
".",
"receive_multiple_transmissions",
"process_returned_data",
"(",
"segments",
")",
"# Print stuff to screen?",
"end",
"# Close the DICOM link:",
"establish_release",
"end",
"end"
] |
Handles the communication involved in a DICOM C-ECHO.
Build the necessary strings and send the command and data element that makes up the echo request.
Listens for and interpretes the incoming echo response.
|
[
"Handles",
"the",
"communication",
"involved",
"in",
"a",
"DICOM",
"C",
"-",
"ECHO",
".",
"Build",
"the",
"necessary",
"strings",
"and",
"send",
"the",
"command",
"and",
"data",
"element",
"that",
"makes",
"up",
"the",
"echo",
"request",
".",
"Listens",
"for",
"and",
"interpretes",
"the",
"incoming",
"echo",
"response",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_client.rb#L538-L556
|
22,327 |
dicom/ruby-dicom
|
lib/dicom/d_client.rb
|
DICOM.DClient.perform_get
|
def perform_get(path)
# Open a DICOM link:
establish_association
if association_established?
if request_approved?
# Continue with our operation, since the request was accepted.
@link.build_command_fragment(PDU_DATA, presentation_context_id, COMMAND_LAST_FRAGMENT, @command_elements)
@link.transmit
@link.build_data_fragment(@data_elements, presentation_context_id)
@link.transmit
# Listen for incoming file data:
success = @link.handle_incoming_data(path)
if success
# Send confirmation response:
@link.handle_response
end
end
# Close the DICOM link:
establish_release
end
end
|
ruby
|
def perform_get(path)
# Open a DICOM link:
establish_association
if association_established?
if request_approved?
# Continue with our operation, since the request was accepted.
@link.build_command_fragment(PDU_DATA, presentation_context_id, COMMAND_LAST_FRAGMENT, @command_elements)
@link.transmit
@link.build_data_fragment(@data_elements, presentation_context_id)
@link.transmit
# Listen for incoming file data:
success = @link.handle_incoming_data(path)
if success
# Send confirmation response:
@link.handle_response
end
end
# Close the DICOM link:
establish_release
end
end
|
[
"def",
"perform_get",
"(",
"path",
")",
"# Open a DICOM link:",
"establish_association",
"if",
"association_established?",
"if",
"request_approved?",
"# Continue with our operation, since the request was accepted.",
"@link",
".",
"build_command_fragment",
"(",
"PDU_DATA",
",",
"presentation_context_id",
",",
"COMMAND_LAST_FRAGMENT",
",",
"@command_elements",
")",
"@link",
".",
"transmit",
"@link",
".",
"build_data_fragment",
"(",
"@data_elements",
",",
"presentation_context_id",
")",
"@link",
".",
"transmit",
"# Listen for incoming file data:",
"success",
"=",
"@link",
".",
"handle_incoming_data",
"(",
"path",
")",
"if",
"success",
"# Send confirmation response:",
"@link",
".",
"handle_response",
"end",
"end",
"# Close the DICOM link:",
"establish_release",
"end",
"end"
] |
Handles the communication involved in a DICOM C-GET.
Builds and sends command & data fragment, then receives the incoming file data.
--
FIXME: This method has never actually been tested, since it is difficult to find a host that accepts a c-get-rq.
|
[
"Handles",
"the",
"communication",
"involved",
"in",
"a",
"DICOM",
"C",
"-",
"GET",
".",
"Builds",
"and",
"sends",
"command",
"&",
"data",
"fragment",
"then",
"receives",
"the",
"incoming",
"file",
"data",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_client.rb#L590-L610
|
22,328 |
dicom/ruby-dicom
|
lib/dicom/d_client.rb
|
DICOM.DClient.perform_send
|
def perform_send(objects)
objects.each_with_index do |dcm, index|
# Gather necessary information from the object (SOP Class & Instance UID):
sop_class = dcm.value("0008,0016")
sop_instance = dcm.value("0008,0018")
if sop_class and sop_instance
# Only send the image if its sop_class has been accepted by the receiver:
if @approved_syntaxes[sop_class]
# Set the command array to be used:
message_id = index + 1
set_command_fragment_store(sop_class, sop_instance, message_id)
# Find context id and transfer syntax:
presentation_context_id = @approved_syntaxes[sop_class][0]
selected_transfer_syntax = @approved_syntaxes[sop_class][1]
# Encode our DICOM object to a binary string which is split up in pieces, sufficiently small to fit within the specified maximum pdu length:
# Set the transfer syntax of the DICOM object equal to the one accepted by the SCP:
dcm.transfer_syntax = selected_transfer_syntax
# Remove the Meta group, since it doesn't belong in a DICOM file transfer:
dcm.delete_group(META_GROUP)
max_header_length = 14
data_packages = dcm.encode_segments(@max_pdu_length - max_header_length, selected_transfer_syntax)
@link.build_command_fragment(PDU_DATA, presentation_context_id, COMMAND_LAST_FRAGMENT, @command_elements)
@link.transmit
# Transmit all but the last data strings:
last_data_package = data_packages.pop
data_packages.each do |data_package|
@link.build_storage_fragment(PDU_DATA, presentation_context_id, DATA_MORE_FRAGMENTS, data_package)
@link.transmit
end
# Transmit the last data string:
@link.build_storage_fragment(PDU_DATA, presentation_context_id, DATA_LAST_FRAGMENT, last_data_package)
@link.transmit
# Receive confirmation response:
segments = @link.receive_single_transmission
process_returned_data(segments)
end
else
logger.error("Unable to extract SOP Class UID and/or SOP Instance UID for this DICOM object. File will not be sent to its destination.")
end
end
end
|
ruby
|
def perform_send(objects)
objects.each_with_index do |dcm, index|
# Gather necessary information from the object (SOP Class & Instance UID):
sop_class = dcm.value("0008,0016")
sop_instance = dcm.value("0008,0018")
if sop_class and sop_instance
# Only send the image if its sop_class has been accepted by the receiver:
if @approved_syntaxes[sop_class]
# Set the command array to be used:
message_id = index + 1
set_command_fragment_store(sop_class, sop_instance, message_id)
# Find context id and transfer syntax:
presentation_context_id = @approved_syntaxes[sop_class][0]
selected_transfer_syntax = @approved_syntaxes[sop_class][1]
# Encode our DICOM object to a binary string which is split up in pieces, sufficiently small to fit within the specified maximum pdu length:
# Set the transfer syntax of the DICOM object equal to the one accepted by the SCP:
dcm.transfer_syntax = selected_transfer_syntax
# Remove the Meta group, since it doesn't belong in a DICOM file transfer:
dcm.delete_group(META_GROUP)
max_header_length = 14
data_packages = dcm.encode_segments(@max_pdu_length - max_header_length, selected_transfer_syntax)
@link.build_command_fragment(PDU_DATA, presentation_context_id, COMMAND_LAST_FRAGMENT, @command_elements)
@link.transmit
# Transmit all but the last data strings:
last_data_package = data_packages.pop
data_packages.each do |data_package|
@link.build_storage_fragment(PDU_DATA, presentation_context_id, DATA_MORE_FRAGMENTS, data_package)
@link.transmit
end
# Transmit the last data string:
@link.build_storage_fragment(PDU_DATA, presentation_context_id, DATA_LAST_FRAGMENT, last_data_package)
@link.transmit
# Receive confirmation response:
segments = @link.receive_single_transmission
process_returned_data(segments)
end
else
logger.error("Unable to extract SOP Class UID and/or SOP Instance UID for this DICOM object. File will not be sent to its destination.")
end
end
end
|
[
"def",
"perform_send",
"(",
"objects",
")",
"objects",
".",
"each_with_index",
"do",
"|",
"dcm",
",",
"index",
"|",
"# Gather necessary information from the object (SOP Class & Instance UID):",
"sop_class",
"=",
"dcm",
".",
"value",
"(",
"\"0008,0016\"",
")",
"sop_instance",
"=",
"dcm",
".",
"value",
"(",
"\"0008,0018\"",
")",
"if",
"sop_class",
"and",
"sop_instance",
"# Only send the image if its sop_class has been accepted by the receiver:",
"if",
"@approved_syntaxes",
"[",
"sop_class",
"]",
"# Set the command array to be used:",
"message_id",
"=",
"index",
"+",
"1",
"set_command_fragment_store",
"(",
"sop_class",
",",
"sop_instance",
",",
"message_id",
")",
"# Find context id and transfer syntax:",
"presentation_context_id",
"=",
"@approved_syntaxes",
"[",
"sop_class",
"]",
"[",
"0",
"]",
"selected_transfer_syntax",
"=",
"@approved_syntaxes",
"[",
"sop_class",
"]",
"[",
"1",
"]",
"# Encode our DICOM object to a binary string which is split up in pieces, sufficiently small to fit within the specified maximum pdu length:",
"# Set the transfer syntax of the DICOM object equal to the one accepted by the SCP:",
"dcm",
".",
"transfer_syntax",
"=",
"selected_transfer_syntax",
"# Remove the Meta group, since it doesn't belong in a DICOM file transfer:",
"dcm",
".",
"delete_group",
"(",
"META_GROUP",
")",
"max_header_length",
"=",
"14",
"data_packages",
"=",
"dcm",
".",
"encode_segments",
"(",
"@max_pdu_length",
"-",
"max_header_length",
",",
"selected_transfer_syntax",
")",
"@link",
".",
"build_command_fragment",
"(",
"PDU_DATA",
",",
"presentation_context_id",
",",
"COMMAND_LAST_FRAGMENT",
",",
"@command_elements",
")",
"@link",
".",
"transmit",
"# Transmit all but the last data strings:",
"last_data_package",
"=",
"data_packages",
".",
"pop",
"data_packages",
".",
"each",
"do",
"|",
"data_package",
"|",
"@link",
".",
"build_storage_fragment",
"(",
"PDU_DATA",
",",
"presentation_context_id",
",",
"DATA_MORE_FRAGMENTS",
",",
"data_package",
")",
"@link",
".",
"transmit",
"end",
"# Transmit the last data string:",
"@link",
".",
"build_storage_fragment",
"(",
"PDU_DATA",
",",
"presentation_context_id",
",",
"DATA_LAST_FRAGMENT",
",",
"last_data_package",
")",
"@link",
".",
"transmit",
"# Receive confirmation response:",
"segments",
"=",
"@link",
".",
"receive_single_transmission",
"process_returned_data",
"(",
"segments",
")",
"end",
"else",
"logger",
".",
"error",
"(",
"\"Unable to extract SOP Class UID and/or SOP Instance UID for this DICOM object. File will not be sent to its destination.\"",
")",
"end",
"end",
"end"
] |
Handles the communication involved in DICOM C-STORE.
For each file, builds and sends command fragment, then builds and sends the data fragments that
conveys the information from the selected DICOM file.
|
[
"Handles",
"the",
"communication",
"involved",
"in",
"DICOM",
"C",
"-",
"STORE",
".",
"For",
"each",
"file",
"builds",
"and",
"sends",
"command",
"fragment",
"then",
"builds",
"and",
"sends",
"the",
"data",
"fragments",
"that",
"conveys",
"the",
"information",
"from",
"the",
"selected",
"DICOM",
"file",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_client.rb#L639-L679
|
22,329 |
dicom/ruby-dicom
|
lib/dicom/d_client.rb
|
DICOM.DClient.process_presentation_context_response
|
def process_presentation_context_response(presentation_contexts)
# Storing approved syntaxes in an Hash with the syntax as key and the value being an array with presentation context ID and the transfer syntax chosen by the SCP.
@approved_syntaxes = Hash.new
rejected = Hash.new
# Reset the presentation context instance variable:
@link.presentation_contexts = Hash.new
accepted_pc = 0
presentation_contexts.each do |pc|
# Determine what abstract syntax this particular presentation context's id corresponds to:
id = pc[:presentation_context_id]
raise "Error! Even presentation context ID received in the association response. This is not allowed according to the DICOM standard!" if id.even?
abstract_syntax = find_abstract_syntax(id)
if pc[:result] == 0
accepted_pc += 1
@approved_syntaxes[abstract_syntax] = [id, pc[:transfer_syntax]]
@link.presentation_contexts[id] = pc[:transfer_syntax]
else
rejected[abstract_syntax] = [id, pc[:transfer_syntax]]
end
end
if rejected.length == 0
@request_approved = true
if @approved_syntaxes.length == 1 and presentation_contexts.length == 1
logger.info("The presentation context was accepted by host #{@host_ae}.")
else
logger.info("All #{presentation_contexts.length} presentation contexts were accepted by host #{@host_ae} (#{@host_ip}).")
end
else
# We still consider the request 'approved' if at least one context were accepted:
@request_approved = true if @approved_syntaxes.length > 0
logger.error("One or more of your presentation contexts were denied by host #{@host_ae}!")
@approved_syntaxes.each_pair do |key, value|
sntx_k = (LIBRARY.uid(key) ? LIBRARY.uid(key).name : 'Unknown UID!')
sntx_v = (LIBRARY.uid(value[1]) ? LIBRARY.uid(value[1]).name : 'Unknown UID!')
logger.info("APPROVED: #{sntx_k} (#{sntx_v})")
end
rejected.each_pair do |key, value|
sntx_k = (LIBRARY.uid(key) ? LIBRARY.uid(key).name : 'Unknown UID!')
sntx_v = (LIBRARY.uid(value[1]) ? LIBRARY.uid(value[1]).name : 'Unknown UID!')
logger.error("REJECTED: #{sntx_k} (#{sntx_v})")
end
end
end
|
ruby
|
def process_presentation_context_response(presentation_contexts)
# Storing approved syntaxes in an Hash with the syntax as key and the value being an array with presentation context ID and the transfer syntax chosen by the SCP.
@approved_syntaxes = Hash.new
rejected = Hash.new
# Reset the presentation context instance variable:
@link.presentation_contexts = Hash.new
accepted_pc = 0
presentation_contexts.each do |pc|
# Determine what abstract syntax this particular presentation context's id corresponds to:
id = pc[:presentation_context_id]
raise "Error! Even presentation context ID received in the association response. This is not allowed according to the DICOM standard!" if id.even?
abstract_syntax = find_abstract_syntax(id)
if pc[:result] == 0
accepted_pc += 1
@approved_syntaxes[abstract_syntax] = [id, pc[:transfer_syntax]]
@link.presentation_contexts[id] = pc[:transfer_syntax]
else
rejected[abstract_syntax] = [id, pc[:transfer_syntax]]
end
end
if rejected.length == 0
@request_approved = true
if @approved_syntaxes.length == 1 and presentation_contexts.length == 1
logger.info("The presentation context was accepted by host #{@host_ae}.")
else
logger.info("All #{presentation_contexts.length} presentation contexts were accepted by host #{@host_ae} (#{@host_ip}).")
end
else
# We still consider the request 'approved' if at least one context were accepted:
@request_approved = true if @approved_syntaxes.length > 0
logger.error("One or more of your presentation contexts were denied by host #{@host_ae}!")
@approved_syntaxes.each_pair do |key, value|
sntx_k = (LIBRARY.uid(key) ? LIBRARY.uid(key).name : 'Unknown UID!')
sntx_v = (LIBRARY.uid(value[1]) ? LIBRARY.uid(value[1]).name : 'Unknown UID!')
logger.info("APPROVED: #{sntx_k} (#{sntx_v})")
end
rejected.each_pair do |key, value|
sntx_k = (LIBRARY.uid(key) ? LIBRARY.uid(key).name : 'Unknown UID!')
sntx_v = (LIBRARY.uid(value[1]) ? LIBRARY.uid(value[1]).name : 'Unknown UID!')
logger.error("REJECTED: #{sntx_k} (#{sntx_v})")
end
end
end
|
[
"def",
"process_presentation_context_response",
"(",
"presentation_contexts",
")",
"# Storing approved syntaxes in an Hash with the syntax as key and the value being an array with presentation context ID and the transfer syntax chosen by the SCP.",
"@approved_syntaxes",
"=",
"Hash",
".",
"new",
"rejected",
"=",
"Hash",
".",
"new",
"# Reset the presentation context instance variable:",
"@link",
".",
"presentation_contexts",
"=",
"Hash",
".",
"new",
"accepted_pc",
"=",
"0",
"presentation_contexts",
".",
"each",
"do",
"|",
"pc",
"|",
"# Determine what abstract syntax this particular presentation context's id corresponds to:",
"id",
"=",
"pc",
"[",
":presentation_context_id",
"]",
"raise",
"\"Error! Even presentation context ID received in the association response. This is not allowed according to the DICOM standard!\"",
"if",
"id",
".",
"even?",
"abstract_syntax",
"=",
"find_abstract_syntax",
"(",
"id",
")",
"if",
"pc",
"[",
":result",
"]",
"==",
"0",
"accepted_pc",
"+=",
"1",
"@approved_syntaxes",
"[",
"abstract_syntax",
"]",
"=",
"[",
"id",
",",
"pc",
"[",
":transfer_syntax",
"]",
"]",
"@link",
".",
"presentation_contexts",
"[",
"id",
"]",
"=",
"pc",
"[",
":transfer_syntax",
"]",
"else",
"rejected",
"[",
"abstract_syntax",
"]",
"=",
"[",
"id",
",",
"pc",
"[",
":transfer_syntax",
"]",
"]",
"end",
"end",
"if",
"rejected",
".",
"length",
"==",
"0",
"@request_approved",
"=",
"true",
"if",
"@approved_syntaxes",
".",
"length",
"==",
"1",
"and",
"presentation_contexts",
".",
"length",
"==",
"1",
"logger",
".",
"info",
"(",
"\"The presentation context was accepted by host #{@host_ae}.\"",
")",
"else",
"logger",
".",
"info",
"(",
"\"All #{presentation_contexts.length} presentation contexts were accepted by host #{@host_ae} (#{@host_ip}).\"",
")",
"end",
"else",
"# We still consider the request 'approved' if at least one context were accepted:",
"@request_approved",
"=",
"true",
"if",
"@approved_syntaxes",
".",
"length",
">",
"0",
"logger",
".",
"error",
"(",
"\"One or more of your presentation contexts were denied by host #{@host_ae}!\"",
")",
"@approved_syntaxes",
".",
"each_pair",
"do",
"|",
"key",
",",
"value",
"|",
"sntx_k",
"=",
"(",
"LIBRARY",
".",
"uid",
"(",
"key",
")",
"?",
"LIBRARY",
".",
"uid",
"(",
"key",
")",
".",
"name",
":",
"'Unknown UID!'",
")",
"sntx_v",
"=",
"(",
"LIBRARY",
".",
"uid",
"(",
"value",
"[",
"1",
"]",
")",
"?",
"LIBRARY",
".",
"uid",
"(",
"value",
"[",
"1",
"]",
")",
".",
"name",
":",
"'Unknown UID!'",
")",
"logger",
".",
"info",
"(",
"\"APPROVED: #{sntx_k} (#{sntx_v})\"",
")",
"end",
"rejected",
".",
"each_pair",
"do",
"|",
"key",
",",
"value",
"|",
"sntx_k",
"=",
"(",
"LIBRARY",
".",
"uid",
"(",
"key",
")",
"?",
"LIBRARY",
".",
"uid",
"(",
"key",
")",
".",
"name",
":",
"'Unknown UID!'",
")",
"sntx_v",
"=",
"(",
"LIBRARY",
".",
"uid",
"(",
"value",
"[",
"1",
"]",
")",
"?",
"LIBRARY",
".",
"uid",
"(",
"value",
"[",
"1",
"]",
")",
".",
"name",
":",
"'Unknown UID!'",
")",
"logger",
".",
"error",
"(",
"\"REJECTED: #{sntx_k} (#{sntx_v})\"",
")",
"end",
"end",
"end"
] |
Processes the presentation contexts that are received in the association response
to extract the transfer syntaxes which have been accepted for the various abstract syntaxes.
=== Parameters
* <tt>presentation_contexts</tt> -- An array where each index contains a presentation context hash.
|
[
"Processes",
"the",
"presentation",
"contexts",
"that",
"are",
"received",
"in",
"the",
"association",
"response",
"to",
"extract",
"the",
"transfer",
"syntaxes",
"which",
"have",
"been",
"accepted",
"for",
"the",
"various",
"abstract",
"syntaxes",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_client.rb#L688-L730
|
22,330 |
dicom/ruby-dicom
|
lib/dicom/d_client.rb
|
DICOM.DClient.process_returned_data
|
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] == COMMAND_LAST_FRAGMENT
@command_results << info[:results]
elsif info[:presentation_context_flag] == DATA_LAST_FRAGMENT
@data_results << info[:results]
end
end
end
end
|
ruby
|
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] == COMMAND_LAST_FRAGMENT
@command_results << info[:results]
elsif info[:presentation_context_flag] == DATA_LAST_FRAGMENT
@data_results << info[:results]
end
end
end
end
|
[
"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",
"]",
"==",
"COMMAND_LAST_FRAGMENT",
"@command_results",
"<<",
"info",
"[",
":results",
"]",
"elsif",
"info",
"[",
":presentation_context_flag",
"]",
"==",
"DATA_LAST_FRAGMENT",
"@data_results",
"<<",
"info",
"[",
":results",
"]",
"end",
"end",
"end",
"end"
] |
Processes the array of information hashes that was returned from the interaction with the SCP
and transfers it to the instance variables where command and data results are stored.
|
[
"Processes",
"the",
"array",
"of",
"information",
"hashes",
"that",
"was",
"returned",
"from",
"the",
"interaction",
"with",
"the",
"SCP",
"and",
"transfers",
"it",
"to",
"the",
"instance",
"variables",
"where",
"command",
"and",
"data",
"results",
"are",
"stored",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_client.rb#L735-L750
|
22,331 |
dicom/ruby-dicom
|
lib/dicom/d_client.rb
|
DICOM.DClient.set_default_presentation_context
|
def set_default_presentation_context(abstract_syntax)
raise ArgumentError, "Expected String, got #{abstract_syntax.class}" unless abstract_syntax.is_a?(String)
id = 1
transfer_syntaxes = [IMPLICIT_LITTLE_ENDIAN, EXPLICIT_LITTLE_ENDIAN, EXPLICIT_BIG_ENDIAN]
item = {:transfer_syntaxes => transfer_syntaxes}
pc = {id => item}
@presentation_contexts = {abstract_syntax => pc}
end
|
ruby
|
def set_default_presentation_context(abstract_syntax)
raise ArgumentError, "Expected String, got #{abstract_syntax.class}" unless abstract_syntax.is_a?(String)
id = 1
transfer_syntaxes = [IMPLICIT_LITTLE_ENDIAN, EXPLICIT_LITTLE_ENDIAN, EXPLICIT_BIG_ENDIAN]
item = {:transfer_syntaxes => transfer_syntaxes}
pc = {id => item}
@presentation_contexts = {abstract_syntax => pc}
end
|
[
"def",
"set_default_presentation_context",
"(",
"abstract_syntax",
")",
"raise",
"ArgumentError",
",",
"\"Expected String, got #{abstract_syntax.class}\"",
"unless",
"abstract_syntax",
".",
"is_a?",
"(",
"String",
")",
"id",
"=",
"1",
"transfer_syntaxes",
"=",
"[",
"IMPLICIT_LITTLE_ENDIAN",
",",
"EXPLICIT_LITTLE_ENDIAN",
",",
"EXPLICIT_BIG_ENDIAN",
"]",
"item",
"=",
"{",
":transfer_syntaxes",
"=>",
"transfer_syntaxes",
"}",
"pc",
"=",
"{",
"id",
"=>",
"item",
"}",
"@presentation_contexts",
"=",
"{",
"abstract_syntax",
"=>",
"pc",
"}",
"end"
] |
Creates the presentation context used for the non-file-transmission association requests..
|
[
"Creates",
"the",
"presentation",
"context",
"used",
"for",
"the",
"non",
"-",
"file",
"-",
"transmission",
"association",
"requests",
".."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_client.rb#L867-L874
|
22,332 |
dicom/ruby-dicom
|
lib/dicom/d_client.rb
|
DICOM.DClient.set_data_elements
|
def set_data_elements(options)
@data_elements = []
options.keys.sort.each do |tag|
@data_elements << [ tag, options[tag] ] unless options[tag].nil?
end
end
|
ruby
|
def set_data_elements(options)
@data_elements = []
options.keys.sort.each do |tag|
@data_elements << [ tag, options[tag] ] unless options[tag].nil?
end
end
|
[
"def",
"set_data_elements",
"(",
"options",
")",
"@data_elements",
"=",
"[",
"]",
"options",
".",
"keys",
".",
"sort",
".",
"each",
"do",
"|",
"tag",
"|",
"@data_elements",
"<<",
"[",
"tag",
",",
"options",
"[",
"tag",
"]",
"]",
"unless",
"options",
"[",
"tag",
"]",
".",
"nil?",
"end",
"end"
] |
Sets the data_elements instance array with the given options.
|
[
"Sets",
"the",
"data_elements",
"instance",
"array",
"with",
"the",
"given",
"options",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_client.rb#L910-L915
|
22,333 |
calabash/calabash
|
lib/calabash/console_helpers.rb
|
Calabash.ConsoleHelpers.reload_git_files
|
def reload_git_files
files_to_reload =
(`git status`.lines.grep(/modified/).map{|l| l.split(" ").last.gsub('../', '')} +
`git ls-files --others --exclude-standard`.lines).map(&:chomp)
$LOADED_FEATURES.each do |file|
files_to_reload.each do |reload_name|
if file.end_with?(reload_name)
puts "LOADING #{file}"
load file
break
end
end
end
true
end
|
ruby
|
def reload_git_files
files_to_reload =
(`git status`.lines.grep(/modified/).map{|l| l.split(" ").last.gsub('../', '')} +
`git ls-files --others --exclude-standard`.lines).map(&:chomp)
$LOADED_FEATURES.each do |file|
files_to_reload.each do |reload_name|
if file.end_with?(reload_name)
puts "LOADING #{file}"
load file
break
end
end
end
true
end
|
[
"def",
"reload_git_files",
"files_to_reload",
"=",
"(",
"`",
"`",
".",
"lines",
".",
"grep",
"(",
"/",
"/",
")",
".",
"map",
"{",
"|",
"l",
"|",
"l",
".",
"split",
"(",
"\" \"",
")",
".",
"last",
".",
"gsub",
"(",
"'../'",
",",
"''",
")",
"}",
"+",
"`",
"`",
".",
"lines",
")",
".",
"map",
"(",
":chomp",
")",
"$LOADED_FEATURES",
".",
"each",
"do",
"|",
"file",
"|",
"files_to_reload",
".",
"each",
"do",
"|",
"reload_name",
"|",
"if",
"file",
".",
"end_with?",
"(",
"reload_name",
")",
"puts",
"\"LOADING #{file}\"",
"load",
"file",
"break",
"end",
"end",
"end",
"true",
"end"
] |
Reloads all required files that have git changes
|
[
"Reloads",
"all",
"required",
"files",
"that",
"have",
"git",
"changes"
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/console_helpers.rb#L9-L25
|
22,334 |
calabash/calabash
|
lib/calabash/console_helpers.rb
|
Calabash.ConsoleHelpers.cal_methods
|
def cal_methods
c = Class.new(BasicObject) do
include Calabash
end
ConsoleHelpers.puts_unbound_methods(c, 'cal.')
true
end
|
ruby
|
def cal_methods
c = Class.new(BasicObject) do
include Calabash
end
ConsoleHelpers.puts_unbound_methods(c, 'cal.')
true
end
|
[
"def",
"cal_methods",
"c",
"=",
"Class",
".",
"new",
"(",
"BasicObject",
")",
"do",
"include",
"Calabash",
"end",
"ConsoleHelpers",
".",
"puts_unbound_methods",
"(",
"c",
",",
"'cal.'",
")",
"true",
"end"
] |
Outputs all calabash methods
|
[
"Outputs",
"all",
"calabash",
"methods"
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/console_helpers.rb#L28-L35
|
22,335 |
calabash/calabash
|
lib/calabash/console_helpers.rb
|
Calabash.ConsoleHelpers.cal_method
|
def cal_method(method)
c = Class.new(BasicObject) do
include Calabash
end
ConsoleHelpers.puts_unbound_method(c, method.to_sym, 'cal.')
true
end
|
ruby
|
def cal_method(method)
c = Class.new(BasicObject) do
include Calabash
end
ConsoleHelpers.puts_unbound_method(c, method.to_sym, 'cal.')
true
end
|
[
"def",
"cal_method",
"(",
"method",
")",
"c",
"=",
"Class",
".",
"new",
"(",
"BasicObject",
")",
"do",
"include",
"Calabash",
"end",
"ConsoleHelpers",
".",
"puts_unbound_method",
"(",
"c",
",",
"method",
".",
"to_sym",
",",
"'cal.'",
")",
"true",
"end"
] |
Outputs a calabash method
|
[
"Outputs",
"a",
"calabash",
"method"
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/console_helpers.rb#L38-L45
|
22,336 |
calabash/calabash
|
lib/calabash/console_helpers.rb
|
Calabash.ConsoleHelpers.cal_ios_methods
|
def cal_ios_methods
c = Class.new(BasicObject) do
include Calabash::IOSInternal
end
ConsoleHelpers.puts_unbound_methods(c, 'cal_ios.')
true
end
|
ruby
|
def cal_ios_methods
c = Class.new(BasicObject) do
include Calabash::IOSInternal
end
ConsoleHelpers.puts_unbound_methods(c, 'cal_ios.')
true
end
|
[
"def",
"cal_ios_methods",
"c",
"=",
"Class",
".",
"new",
"(",
"BasicObject",
")",
"do",
"include",
"Calabash",
"::",
"IOSInternal",
"end",
"ConsoleHelpers",
".",
"puts_unbound_methods",
"(",
"c",
",",
"'cal_ios.'",
")",
"true",
"end"
] |
Outputs all calabash iOS methods
|
[
"Outputs",
"all",
"calabash",
"iOS",
"methods"
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/console_helpers.rb#L48-L55
|
22,337 |
calabash/calabash
|
lib/calabash/console_helpers.rb
|
Calabash.ConsoleHelpers.cal_android_methods
|
def cal_android_methods
c = Class.new(BasicObject) do
include Calabash::AndroidInternal
end
ConsoleHelpers.puts_unbound_methods(c, 'cal_android.')
true
end
|
ruby
|
def cal_android_methods
c = Class.new(BasicObject) do
include Calabash::AndroidInternal
end
ConsoleHelpers.puts_unbound_methods(c, 'cal_android.')
true
end
|
[
"def",
"cal_android_methods",
"c",
"=",
"Class",
".",
"new",
"(",
"BasicObject",
")",
"do",
"include",
"Calabash",
"::",
"AndroidInternal",
"end",
"ConsoleHelpers",
".",
"puts_unbound_methods",
"(",
"c",
",",
"'cal_android.'",
")",
"true",
"end"
] |
Outputs all calabash Android methods
|
[
"Outputs",
"all",
"calabash",
"Android",
"methods"
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/console_helpers.rb#L68-L75
|
22,338 |
calabash/calabash
|
lib/calabash/console_helpers.rb
|
Calabash.ConsoleHelpers.tree
|
def tree
ConsoleHelpers.dump(Calabash::Internal.with_current_target {|target| target.dump})
true
end
|
ruby
|
def tree
ConsoleHelpers.dump(Calabash::Internal.with_current_target {|target| target.dump})
true
end
|
[
"def",
"tree",
"ConsoleHelpers",
".",
"dump",
"(",
"Calabash",
"::",
"Internal",
".",
"with_current_target",
"{",
"|",
"target",
"|",
"target",
".",
"dump",
"}",
")",
"true",
"end"
] |
Outputs all visible elements as a tree.
|
[
"Outputs",
"all",
"visible",
"elements",
"as",
"a",
"tree",
"."
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/console_helpers.rb#L88-L91
|
22,339 |
calabash/calabash
|
lib/calabash/console_helpers.rb
|
Calabash.ConsoleHelpers.verbose
|
def verbose
if Calabash::Logger.log_levels.include?(:debug)
puts Color.blue('Debug logging is already turned on.')
else
Calabash::Logger.log_levels << :debug
puts Color.blue('Turned on debug logging.')
end
true
end
|
ruby
|
def verbose
if Calabash::Logger.log_levels.include?(:debug)
puts Color.blue('Debug logging is already turned on.')
else
Calabash::Logger.log_levels << :debug
puts Color.blue('Turned on debug logging.')
end
true
end
|
[
"def",
"verbose",
"if",
"Calabash",
"::",
"Logger",
".",
"log_levels",
".",
"include?",
"(",
":debug",
")",
"puts",
"Color",
".",
"blue",
"(",
"'Debug logging is already turned on.'",
")",
"else",
"Calabash",
"::",
"Logger",
".",
"log_levels",
"<<",
":debug",
"puts",
"Color",
".",
"blue",
"(",
"'Turned on debug logging.'",
")",
"end",
"true",
"end"
] |
Turn on debug logging.
|
[
"Turn",
"on",
"debug",
"logging",
"."
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/console_helpers.rb#L147-L156
|
22,340 |
calabash/calabash
|
lib/calabash/console_helpers.rb
|
Calabash.ConsoleHelpers.quiet
|
def quiet
if Calabash::Logger.log_levels.include?(:debug)
puts Color.blue('Turned off debug logging.')
Calabash::Logger.log_levels.delete(:debug)
else
puts Color.blue('Debug logging is already turned off.')
end
true
end
|
ruby
|
def quiet
if Calabash::Logger.log_levels.include?(:debug)
puts Color.blue('Turned off debug logging.')
Calabash::Logger.log_levels.delete(:debug)
else
puts Color.blue('Debug logging is already turned off.')
end
true
end
|
[
"def",
"quiet",
"if",
"Calabash",
"::",
"Logger",
".",
"log_levels",
".",
"include?",
"(",
":debug",
")",
"puts",
"Color",
".",
"blue",
"(",
"'Turned off debug logging.'",
")",
"Calabash",
"::",
"Logger",
".",
"log_levels",
".",
"delete",
"(",
":debug",
")",
"else",
"puts",
"Color",
".",
"blue",
"(",
"'Debug logging is already turned off.'",
")",
"end",
"true",
"end"
] |
Turn off debug logging.
|
[
"Turn",
"off",
"debug",
"logging",
"."
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/console_helpers.rb#L159-L168
|
22,341 |
dicom/ruby-dicom
|
lib/dicom/stream.rb
|
DICOM.Stream.decode
|
def decode(length, type)
raise ArgumentError, "Invalid argument length. Expected Integer, got #{length.class}" unless length.is_a?(Integer)
raise ArgumentError, "Invalid argument type. Expected string, got #{type.class}" unless type.is_a?(String)
value = nil
if (@index + length) <= @string.length
# There are sufficient bytes remaining to extract the value:
if type == 'AT'
# We need to guard ourselves against the case where a string contains an invalid 'AT' value:
if length == 4
value = decode_tag
else
# Invalid. Just return nil.
skip(length)
end
else
# Decode the binary string and return value:
value = @string.slice(@index, length).unpack(vr_to_str(type))
# If the result is an array of one element, return the element instead of the array.
# If result is contained in a multi-element array, the original array is returned.
if value.length == 1
value = value[0]
# If value is a string, strip away possible trailing whitespace:
value = value.rstrip if value.is_a?(String)
end
# Update our position in the string:
skip(length)
end
end
value
end
|
ruby
|
def decode(length, type)
raise ArgumentError, "Invalid argument length. Expected Integer, got #{length.class}" unless length.is_a?(Integer)
raise ArgumentError, "Invalid argument type. Expected string, got #{type.class}" unless type.is_a?(String)
value = nil
if (@index + length) <= @string.length
# There are sufficient bytes remaining to extract the value:
if type == 'AT'
# We need to guard ourselves against the case where a string contains an invalid 'AT' value:
if length == 4
value = decode_tag
else
# Invalid. Just return nil.
skip(length)
end
else
# Decode the binary string and return value:
value = @string.slice(@index, length).unpack(vr_to_str(type))
# If the result is an array of one element, return the element instead of the array.
# If result is contained in a multi-element array, the original array is returned.
if value.length == 1
value = value[0]
# If value is a string, strip away possible trailing whitespace:
value = value.rstrip if value.is_a?(String)
end
# Update our position in the string:
skip(length)
end
end
value
end
|
[
"def",
"decode",
"(",
"length",
",",
"type",
")",
"raise",
"ArgumentError",
",",
"\"Invalid argument length. Expected Integer, got #{length.class}\"",
"unless",
"length",
".",
"is_a?",
"(",
"Integer",
")",
"raise",
"ArgumentError",
",",
"\"Invalid argument type. Expected string, got #{type.class}\"",
"unless",
"type",
".",
"is_a?",
"(",
"String",
")",
"value",
"=",
"nil",
"if",
"(",
"@index",
"+",
"length",
")",
"<=",
"@string",
".",
"length",
"# There are sufficient bytes remaining to extract the value:",
"if",
"type",
"==",
"'AT'",
"# We need to guard ourselves against the case where a string contains an invalid 'AT' value:",
"if",
"length",
"==",
"4",
"value",
"=",
"decode_tag",
"else",
"# Invalid. Just return nil.",
"skip",
"(",
"length",
")",
"end",
"else",
"# Decode the binary string and return value:",
"value",
"=",
"@string",
".",
"slice",
"(",
"@index",
",",
"length",
")",
".",
"unpack",
"(",
"vr_to_str",
"(",
"type",
")",
")",
"# If the result is an array of one element, return the element instead of the array.",
"# If result is contained in a multi-element array, the original array is returned.",
"if",
"value",
".",
"length",
"==",
"1",
"value",
"=",
"value",
"[",
"0",
"]",
"# If value is a string, strip away possible trailing whitespace:",
"value",
"=",
"value",
".",
"rstrip",
"if",
"value",
".",
"is_a?",
"(",
"String",
")",
"end",
"# Update our position in the string:",
"skip",
"(",
"length",
")",
"end",
"end",
"value",
"end"
] |
Decodes a section of the instance string.
The instance index is offset in accordance with the length read.
@note If multiple numbers are decoded, these are returned in an array.
@param [Integer] length the string length to be decoded
@param [String] type the type (vr) of data to decode
@return [String, Integer, Float, Array] the formatted (decoded) data
|
[
"Decodes",
"a",
"section",
"of",
"the",
"instance",
"string",
".",
"The",
"instance",
"index",
"is",
"offset",
"in",
"accordance",
"with",
"the",
"length",
"read",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/stream.rb#L63-L92
|
22,342 |
dicom/ruby-dicom
|
lib/dicom/stream.rb
|
DICOM.Stream.decode_tag
|
def decode_tag
length = 4
tag = nil
if (@index + length) <= @string.length
# There are sufficient bytes remaining to extract a full tag:
str = @string.slice(@index, length).unpack(@hex)[0].upcase
if @equal_endian
tag = "#{str[2..3]}#{str[0..1]},#{str[6..7]}#{str[4..5]}"
else
tag = "#{str[0..3]},#{str[4..7]}"
end
# Update our position in the string:
skip(length)
end
tag
end
|
ruby
|
def decode_tag
length = 4
tag = nil
if (@index + length) <= @string.length
# There are sufficient bytes remaining to extract a full tag:
str = @string.slice(@index, length).unpack(@hex)[0].upcase
if @equal_endian
tag = "#{str[2..3]}#{str[0..1]},#{str[6..7]}#{str[4..5]}"
else
tag = "#{str[0..3]},#{str[4..7]}"
end
# Update our position in the string:
skip(length)
end
tag
end
|
[
"def",
"decode_tag",
"length",
"=",
"4",
"tag",
"=",
"nil",
"if",
"(",
"@index",
"+",
"length",
")",
"<=",
"@string",
".",
"length",
"# There are sufficient bytes remaining to extract a full tag:",
"str",
"=",
"@string",
".",
"slice",
"(",
"@index",
",",
"length",
")",
".",
"unpack",
"(",
"@hex",
")",
"[",
"0",
"]",
".",
"upcase",
"if",
"@equal_endian",
"tag",
"=",
"\"#{str[2..3]}#{str[0..1]},#{str[6..7]}#{str[4..5]}\"",
"else",
"tag",
"=",
"\"#{str[0..3]},#{str[4..7]}\"",
"end",
"# Update our position in the string:",
"skip",
"(",
"length",
")",
"end",
"tag",
"end"
] |
Decodes 4 bytes of the instance string and formats it as a ruby-dicom tag string.
@return [String, NilClass] a formatted tag string ('GGGG,EEEE'), or nil (e.g. if at end of string)
|
[
"Decodes",
"4",
"bytes",
"of",
"the",
"instance",
"string",
"and",
"formats",
"it",
"as",
"a",
"ruby",
"-",
"dicom",
"tag",
"string",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/stream.rb#L111-L126
|
22,343 |
dicom/ruby-dicom
|
lib/dicom/stream.rb
|
DICOM.Stream.encode
|
def encode(value, type)
raise ArgumentError, "Invalid argument type. Expected string, got #{type.class}" unless type.is_a?(String)
value = [value] unless value.is_a?(Array)
return value.pack(vr_to_str(type))
end
|
ruby
|
def encode(value, type)
raise ArgumentError, "Invalid argument type. Expected string, got #{type.class}" unless type.is_a?(String)
value = [value] unless value.is_a?(Array)
return value.pack(vr_to_str(type))
end
|
[
"def",
"encode",
"(",
"value",
",",
"type",
")",
"raise",
"ArgumentError",
",",
"\"Invalid argument type. Expected string, got #{type.class}\"",
"unless",
"type",
".",
"is_a?",
"(",
"String",
")",
"value",
"=",
"[",
"value",
"]",
"unless",
"value",
".",
"is_a?",
"(",
"Array",
")",
"return",
"value",
".",
"pack",
"(",
"vr_to_str",
"(",
"type",
")",
")",
"end"
] |
Encodes a given value to a binary string.
@param [String, Integer, Float, Array] value a formatted value (String, Integer, etc..) or an array of numbers
@param [String] type the type (vr) of data to encode
@return [String] an encoded binary string
|
[
"Encodes",
"a",
"given",
"value",
"to",
"a",
"binary",
"string",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/stream.rb#L134-L138
|
22,344 |
dicom/ruby-dicom
|
lib/dicom/stream.rb
|
DICOM.Stream.encode_string_with_trailing_spaces
|
def encode_string_with_trailing_spaces(string, target_length)
length = string.length
if length < target_length
return "#{[string].pack(@str)}#{['20'*(target_length-length)].pack(@hex)}"
elsif length == target_length
return [string].pack(@str)
else
raise "The specified string is longer than the allowed maximum length (String: #{string}, Target length: #{target_length})."
end
end
|
ruby
|
def encode_string_with_trailing_spaces(string, target_length)
length = string.length
if length < target_length
return "#{[string].pack(@str)}#{['20'*(target_length-length)].pack(@hex)}"
elsif length == target_length
return [string].pack(@str)
else
raise "The specified string is longer than the allowed maximum length (String: #{string}, Target length: #{target_length})."
end
end
|
[
"def",
"encode_string_with_trailing_spaces",
"(",
"string",
",",
"target_length",
")",
"length",
"=",
"string",
".",
"length",
"if",
"length",
"<",
"target_length",
"return",
"\"#{[string].pack(@str)}#{['20'*(target_length-length)].pack(@hex)}\"",
"elsif",
"length",
"==",
"target_length",
"return",
"[",
"string",
"]",
".",
"pack",
"(",
"@str",
")",
"else",
"raise",
"\"The specified string is longer than the allowed maximum length (String: #{string}, Target length: #{target_length}).\"",
"end",
"end"
] |
Appends a string with trailling spaces to achieve a target length, and encodes it to a binary string.
@param [String] string a string to be padded
@param [Integer] target_length the target length of the string
@return [String] an encoded binary string
|
[
"Appends",
"a",
"string",
"with",
"trailling",
"spaces",
"to",
"achieve",
"a",
"target",
"length",
"and",
"encodes",
"it",
"to",
"a",
"binary",
"string",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/stream.rb#L166-L175
|
22,345 |
dicom/ruby-dicom
|
lib/dicom/stream.rb
|
DICOM.Stream.encode_value
|
def encode_value(value, vr)
if vr == 'AT'
bin = encode_tag(value)
else
# Make sure the value is in an array:
value = [value] unless value.is_a?(Array)
# Get the proper pack string:
type = vr_to_str(vr)
# Encode:
bin = value.pack(type)
# Add an empty byte if the resulting binary has an odd length:
bin = "#{bin}#{@pad_byte[vr]}" if bin.length.odd?
end
return bin
end
|
ruby
|
def encode_value(value, vr)
if vr == 'AT'
bin = encode_tag(value)
else
# Make sure the value is in an array:
value = [value] unless value.is_a?(Array)
# Get the proper pack string:
type = vr_to_str(vr)
# Encode:
bin = value.pack(type)
# Add an empty byte if the resulting binary has an odd length:
bin = "#{bin}#{@pad_byte[vr]}" if bin.length.odd?
end
return bin
end
|
[
"def",
"encode_value",
"(",
"value",
",",
"vr",
")",
"if",
"vr",
"==",
"'AT'",
"bin",
"=",
"encode_tag",
"(",
"value",
")",
"else",
"# Make sure the value is in an array:",
"value",
"=",
"[",
"value",
"]",
"unless",
"value",
".",
"is_a?",
"(",
"Array",
")",
"# Get the proper pack string:",
"type",
"=",
"vr_to_str",
"(",
"vr",
")",
"# Encode:",
"bin",
"=",
"value",
".",
"pack",
"(",
"type",
")",
"# Add an empty byte if the resulting binary has an odd length:",
"bin",
"=",
"\"#{bin}#{@pad_byte[vr]}\"",
"if",
"bin",
".",
"length",
".",
"odd?",
"end",
"return",
"bin",
"end"
] |
Encodes a value, and if the the resulting binary string has an
odd length, appends a proper padding byte to make it even length.
@param [String, Integer, Float, Array] value a formatted value (String, Integer, etc..) or an array of numbers
@param [String] vr the value representation of data to encode
@return [String] the encoded binary string
|
[
"Encodes",
"a",
"value",
"and",
"if",
"the",
"the",
"resulting",
"binary",
"string",
"has",
"an",
"odd",
"length",
"appends",
"a",
"proper",
"padding",
"byte",
"to",
"make",
"it",
"even",
"length",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/stream.rb#L195-L209
|
22,346 |
calabash/calabash
|
lib/calabash/interactions.rb
|
Calabash.Interactions.backdoor
|
def backdoor(name, *arguments)
Calabash::Internal.with_current_target {|target| target.backdoor(name, *arguments)}
end
|
ruby
|
def backdoor(name, *arguments)
Calabash::Internal.with_current_target {|target| target.backdoor(name, *arguments)}
end
|
[
"def",
"backdoor",
"(",
"name",
",",
"*",
"arguments",
")",
"Calabash",
"::",
"Internal",
".",
"with_current_target",
"{",
"|",
"target",
"|",
"target",
".",
"backdoor",
"(",
"name",
",",
"arguments",
")",
"}",
"end"
] |
Invoke a method in your application.
This is an escape hatch for calling an arbitrary hook inside
(the test build) of your app. Commonly used to "go around" the UI for
speed purposes or reset the app to a good known state.
For iOS this method calls a method on the app's AppDelegate object.
For Android this method tries to invoke a method on the current Activity
instance. If the method is not defined in the current activity, Calabash
tries to invoke the method on the current Application instance.
@note The Android implementation accepts any number of arguments, of any
type including null (Ruby nil). The iOS implementation does not accept
more than one argument, of the type NSString (Ruby String) or
NSDictionary (Ruby Hash).
### For iOS
You must create a method on you app delegate of the form:
- (NSString *) calabashBackdoor:(NSString *)aIgnorable;
or if you want to pass parameters
- (NSString *) calabashBackdoor:(NSDictionary *)params;
### For Android
You must create a public method in your current Activity or Application.
public <return type> calabashBackdoor(String param1, int param2)
@example
# iOS
backdoor('calabashBackdoor:', '')
@example
# iOS
backdoor('calabashBackdoor:', {example:'param'})
@example
# Android
backdoor('calabashBackdoor', 'first argument', 2)
@param [String] name The selector/method name.
@param [Object] arguments A comma separated list of arguments to be
passed to the backdoor selector/method.
@return [Object] the result of performing the selector/method with the
arguments (serialized)
|
[
"Invoke",
"a",
"method",
"in",
"your",
"application",
"."
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/interactions.rb#L128-L130
|
22,347 |
dicom/ruby-dicom
|
lib/dicom/d_server.rb
|
DICOM.DServer.add_abstract_syntax
|
def add_abstract_syntax(uid)
lib_uid = LIBRARY.uid(uid)
raise "Invalid/unknown UID: #{uid}" unless lib_uid
@accepted_abstract_syntaxes[uid] = lib_uid.name
end
|
ruby
|
def add_abstract_syntax(uid)
lib_uid = LIBRARY.uid(uid)
raise "Invalid/unknown UID: #{uid}" unless lib_uid
@accepted_abstract_syntaxes[uid] = lib_uid.name
end
|
[
"def",
"add_abstract_syntax",
"(",
"uid",
")",
"lib_uid",
"=",
"LIBRARY",
".",
"uid",
"(",
"uid",
")",
"raise",
"\"Invalid/unknown UID: #{uid}\"",
"unless",
"lib_uid",
"@accepted_abstract_syntaxes",
"[",
"uid",
"]",
"=",
"lib_uid",
".",
"name",
"end"
] |
Creates a DServer instance.
@note To customize logging behaviour, refer to the Logging module documentation.
@param [Integer] port the network port to be used
@param [Hash] options the options to use for the DICOM server
@option options [String] :file_handler a customized FileHandler class to use instead of the default FileHandler
@option options [String] :host the hostname that the TCPServer binds to (defaults to '0.0.0.0')
@option options [String] :host_ae the name of the server (application entity)
@option options [String] :max_package_size the maximum allowed size of network packages (in bytes)
@option options [String] :timeout the number of seconds the server will wait on an answer from a client before aborting the communication
@example Create a server using default settings
s = DICOM::DServer.new
@example Create a server with a specific host name and a custom buildt file handler
require_relative 'my_file_handler'
server = DICOM::DServer.new(104, :host_ae => "RUBY_SERVER", :file_handler => DICOM::MyFileHandler)
Adds an abstract syntax to the list of abstract syntaxes that the server will accept.
@param [String] uid an abstract syntax UID
|
[
"Creates",
"a",
"DServer",
"instance",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_server.rb#L89-L93
|
22,348 |
dicom/ruby-dicom
|
lib/dicom/d_server.rb
|
DICOM.DServer.add_transfer_syntax
|
def add_transfer_syntax(uid)
lib_uid = LIBRARY.uid(uid)
raise "Invalid/unknown UID: #{uid}" unless lib_uid
@accepted_transfer_syntaxes[uid] = lib_uid.name
end
|
ruby
|
def add_transfer_syntax(uid)
lib_uid = LIBRARY.uid(uid)
raise "Invalid/unknown UID: #{uid}" unless lib_uid
@accepted_transfer_syntaxes[uid] = lib_uid.name
end
|
[
"def",
"add_transfer_syntax",
"(",
"uid",
")",
"lib_uid",
"=",
"LIBRARY",
".",
"uid",
"(",
"uid",
")",
"raise",
"\"Invalid/unknown UID: #{uid}\"",
"unless",
"lib_uid",
"@accepted_transfer_syntaxes",
"[",
"uid",
"]",
"=",
"lib_uid",
".",
"name",
"end"
] |
Adds a transfer syntax to the list of transfer syntaxes that the server will accept.
@param [String] uid a transfer syntax UID
|
[
"Adds",
"a",
"transfer",
"syntax",
"to",
"the",
"list",
"of",
"transfer",
"syntaxes",
"that",
"the",
"server",
"will",
"accept",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_server.rb#L99-L103
|
22,349 |
dicom/ruby-dicom
|
lib/dicom/d_server.rb
|
DICOM.DServer.print_abstract_syntaxes
|
def print_abstract_syntaxes
# Determine length of longest key to ensure pretty print:
max_uid = @accepted_abstract_syntaxes.keys.collect{|k| k.length}.max
puts "Abstract syntaxes which are accepted by this SCP:"
@accepted_abstract_syntaxes.sort.each do |pair|
puts "#{pair[0]}#{' '*(max_uid-pair[0].length)} #{pair[1]}"
end
end
|
ruby
|
def print_abstract_syntaxes
# Determine length of longest key to ensure pretty print:
max_uid = @accepted_abstract_syntaxes.keys.collect{|k| k.length}.max
puts "Abstract syntaxes which are accepted by this SCP:"
@accepted_abstract_syntaxes.sort.each do |pair|
puts "#{pair[0]}#{' '*(max_uid-pair[0].length)} #{pair[1]}"
end
end
|
[
"def",
"print_abstract_syntaxes",
"# Determine length of longest key to ensure pretty print:",
"max_uid",
"=",
"@accepted_abstract_syntaxes",
".",
"keys",
".",
"collect",
"{",
"|",
"k",
"|",
"k",
".",
"length",
"}",
".",
"max",
"puts",
"\"Abstract syntaxes which are accepted by this SCP:\"",
"@accepted_abstract_syntaxes",
".",
"sort",
".",
"each",
"do",
"|",
"pair",
"|",
"puts",
"\"#{pair[0]}#{' '*(max_uid-pair[0].length)} #{pair[1]}\"",
"end",
"end"
] |
Prints the list of accepted abstract syntaxes to the screen.
|
[
"Prints",
"the",
"list",
"of",
"accepted",
"abstract",
"syntaxes",
"to",
"the",
"screen",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_server.rb#L107-L114
|
22,350 |
calabash/calabash
|
lib/calabash/wait.rb
|
Calabash.Wait.wait_for_view
|
def wait_for_view(query,
timeout: Calabash::Wait.default_options[:timeout],
timeout_message: nil,
retry_frequency: Calabash::Wait.default_options[:retry_frequency])
if query.nil?
raise ArgumentError, 'Query cannot be nil'
end
timeout_message ||= lambda do |wait_options|
"Waited #{wait_options[:timeout]} seconds for #{Wait.parse_query_list(query)} to match a view"
end
wait_for(timeout_message,
timeout: timeout,
retry_frequency: retry_frequency,
exception_class: ViewNotFoundError) do
result = query(query)
!result.empty? && result
end.first
end
|
ruby
|
def wait_for_view(query,
timeout: Calabash::Wait.default_options[:timeout],
timeout_message: nil,
retry_frequency: Calabash::Wait.default_options[:retry_frequency])
if query.nil?
raise ArgumentError, 'Query cannot be nil'
end
timeout_message ||= lambda do |wait_options|
"Waited #{wait_options[:timeout]} seconds for #{Wait.parse_query_list(query)} to match a view"
end
wait_for(timeout_message,
timeout: timeout,
retry_frequency: retry_frequency,
exception_class: ViewNotFoundError) do
result = query(query)
!result.empty? && result
end.first
end
|
[
"def",
"wait_for_view",
"(",
"query",
",",
"timeout",
":",
"Calabash",
"::",
"Wait",
".",
"default_options",
"[",
":timeout",
"]",
",",
"timeout_message",
":",
"nil",
",",
"retry_frequency",
":",
"Calabash",
"::",
"Wait",
".",
"default_options",
"[",
":retry_frequency",
"]",
")",
"if",
"query",
".",
"nil?",
"raise",
"ArgumentError",
",",
"'Query cannot be nil'",
"end",
"timeout_message",
"||=",
"lambda",
"do",
"|",
"wait_options",
"|",
"\"Waited #{wait_options[:timeout]} seconds for #{Wait.parse_query_list(query)} to match a view\"",
"end",
"wait_for",
"(",
"timeout_message",
",",
"timeout",
":",
"timeout",
",",
"retry_frequency",
":",
"retry_frequency",
",",
"exception_class",
":",
"ViewNotFoundError",
")",
"do",
"result",
"=",
"query",
"(",
"query",
")",
"!",
"result",
".",
"empty?",
"&&",
"result",
"end",
".",
"first",
"end"
] |
Waits for `query` to match one or more views.
@example
cal.wait_for_view({marked: 'mark'})
@example
cal.wait_for_view({marked: 'login'},
timeout_message: "Did not see login button")
@example
text = cal.wait_for_view("myview")['text']
@see Calabash::Wait#wait_for for optional parameters
@param [String, Hash, Calabash::Query] query Query to match view
@return [Hash] The first view matching `query`.
@raise [ViewNotFoundError] If `query` do not match at least one view.
|
[
"Waits",
"for",
"query",
"to",
"match",
"one",
"or",
"more",
"views",
"."
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/wait.rb#L187-L206
|
22,351 |
calabash/calabash
|
lib/calabash/wait.rb
|
Calabash.Wait.wait_for_views
|
def wait_for_views(*queries,
timeout: Calabash::Wait.default_options[:timeout],
timeout_message: nil,
retry_frequency: Calabash::Wait.default_options[:retry_frequency])
if queries.nil? || queries.any?(&:nil?)
raise ArgumentError, 'Query cannot be nil'
end
timeout_message ||= lambda do |wait_options|
"Waited #{wait_options[:timeout]} seconds for #{Wait.parse_query_list(queries)} to each match a view"
end
wait_for(timeout_message,
timeout: timeout,
retry_frequency: retry_frequency,
exception_class: ViewNotFoundError) do
views_exist?(*queries)
end
# Do not return the value of views_exist?(queries) as it clutters
# a console environment
true
end
|
ruby
|
def wait_for_views(*queries,
timeout: Calabash::Wait.default_options[:timeout],
timeout_message: nil,
retry_frequency: Calabash::Wait.default_options[:retry_frequency])
if queries.nil? || queries.any?(&:nil?)
raise ArgumentError, 'Query cannot be nil'
end
timeout_message ||= lambda do |wait_options|
"Waited #{wait_options[:timeout]} seconds for #{Wait.parse_query_list(queries)} to each match a view"
end
wait_for(timeout_message,
timeout: timeout,
retry_frequency: retry_frequency,
exception_class: ViewNotFoundError) do
views_exist?(*queries)
end
# Do not return the value of views_exist?(queries) as it clutters
# a console environment
true
end
|
[
"def",
"wait_for_views",
"(",
"*",
"queries",
",",
"timeout",
":",
"Calabash",
"::",
"Wait",
".",
"default_options",
"[",
":timeout",
"]",
",",
"timeout_message",
":",
"nil",
",",
"retry_frequency",
":",
"Calabash",
"::",
"Wait",
".",
"default_options",
"[",
":retry_frequency",
"]",
")",
"if",
"queries",
".",
"nil?",
"||",
"queries",
".",
"any?",
"(",
":nil?",
")",
"raise",
"ArgumentError",
",",
"'Query cannot be nil'",
"end",
"timeout_message",
"||=",
"lambda",
"do",
"|",
"wait_options",
"|",
"\"Waited #{wait_options[:timeout]} seconds for #{Wait.parse_query_list(queries)} to each match a view\"",
"end",
"wait_for",
"(",
"timeout_message",
",",
"timeout",
":",
"timeout",
",",
"retry_frequency",
":",
"retry_frequency",
",",
"exception_class",
":",
"ViewNotFoundError",
")",
"do",
"views_exist?",
"(",
"queries",
")",
"end",
"# Do not return the value of views_exist?(queries) as it clutters",
"# a console environment",
"true",
"end"
] |
Waits for all `queries` to simultaneously match at least one view.
@example
cal.wait_for_views({id: 'foo'}, {id: 'bar'})
@see Calabash::Wait#wait_for for optional parameters
@param [String, Hash, Calabash::Query] queries List of queries or a
query.
@return The returned value is undefined
@raise [ViewNotFoundError] If `queries` do not all match at least one
view.
|
[
"Waits",
"for",
"all",
"queries",
"to",
"simultaneously",
"match",
"at",
"least",
"one",
"view",
"."
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/wait.rb#L220-L242
|
22,352 |
calabash/calabash
|
lib/calabash/wait.rb
|
Calabash.Wait.wait_for_no_view
|
def wait_for_no_view(query,
timeout: Calabash::Wait.default_options[:timeout],
timeout_message: nil,
retry_frequency: Calabash::Wait.default_options[:retry_frequency])
if query.nil?
raise ArgumentError, 'Query cannot be nil'
end
timeout_message ||= lambda do |wait_options|
"Waited #{wait_options[:timeout]} seconds for #{Wait.parse_query_list(query)} to not match any view"
end
wait_for(timeout_message,
timeout: timeout,
retry_frequency: retry_frequency,
exception_class: ViewFoundError) do
!view_exists?(query)
end
end
|
ruby
|
def wait_for_no_view(query,
timeout: Calabash::Wait.default_options[:timeout],
timeout_message: nil,
retry_frequency: Calabash::Wait.default_options[:retry_frequency])
if query.nil?
raise ArgumentError, 'Query cannot be nil'
end
timeout_message ||= lambda do |wait_options|
"Waited #{wait_options[:timeout]} seconds for #{Wait.parse_query_list(query)} to not match any view"
end
wait_for(timeout_message,
timeout: timeout,
retry_frequency: retry_frequency,
exception_class: ViewFoundError) do
!view_exists?(query)
end
end
|
[
"def",
"wait_for_no_view",
"(",
"query",
",",
"timeout",
":",
"Calabash",
"::",
"Wait",
".",
"default_options",
"[",
":timeout",
"]",
",",
"timeout_message",
":",
"nil",
",",
"retry_frequency",
":",
"Calabash",
"::",
"Wait",
".",
"default_options",
"[",
":retry_frequency",
"]",
")",
"if",
"query",
".",
"nil?",
"raise",
"ArgumentError",
",",
"'Query cannot be nil'",
"end",
"timeout_message",
"||=",
"lambda",
"do",
"|",
"wait_options",
"|",
"\"Waited #{wait_options[:timeout]} seconds for #{Wait.parse_query_list(query)} to not match any view\"",
"end",
"wait_for",
"(",
"timeout_message",
",",
"timeout",
":",
"timeout",
",",
"retry_frequency",
":",
"retry_frequency",
",",
"exception_class",
":",
"ViewFoundError",
")",
"do",
"!",
"view_exists?",
"(",
"query",
")",
"end",
"end"
] |
Waits for `query` not to match any views
@example
cal.wait_for_no_view({marked: 'mark'})
@example
cal.wait_for_no_view({marked: 'login'},
timeout_message: "Login button did not disappear")
@see Calabash::Wait#wait_for for optional parameters
@param [String, Hash, Calabash::Query] query Query to match view
@raise [ViewFoundError] If `query` do not match at least one view.
|
[
"Waits",
"for",
"query",
"not",
"to",
"match",
"any",
"views"
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/wait.rb#L257-L275
|
22,353 |
calabash/calabash
|
lib/calabash/wait.rb
|
Calabash.Wait.wait_for_no_views
|
def wait_for_no_views(*queries,
timeout: Calabash::Wait.default_options[:timeout],
timeout_message: nil,
retry_frequency: Calabash::Wait.default_options[:retry_frequency])
if queries.nil? || queries.any?(&:nil?)
raise ArgumentError, 'Query cannot be nil'
end
timeout_message ||= lambda do |wait_options|
"Waited #{wait_options[:timeout]} seconds for #{Wait.parse_query_list(queries)} to each not match any view"
end
wait_for(timeout_message,
timeout: timeout,
retry_frequency: retry_frequency,
exception_class: ViewFoundError) do
!views_exist?(*queries)
end
end
|
ruby
|
def wait_for_no_views(*queries,
timeout: Calabash::Wait.default_options[:timeout],
timeout_message: nil,
retry_frequency: Calabash::Wait.default_options[:retry_frequency])
if queries.nil? || queries.any?(&:nil?)
raise ArgumentError, 'Query cannot be nil'
end
timeout_message ||= lambda do |wait_options|
"Waited #{wait_options[:timeout]} seconds for #{Wait.parse_query_list(queries)} to each not match any view"
end
wait_for(timeout_message,
timeout: timeout,
retry_frequency: retry_frequency,
exception_class: ViewFoundError) do
!views_exist?(*queries)
end
end
|
[
"def",
"wait_for_no_views",
"(",
"*",
"queries",
",",
"timeout",
":",
"Calabash",
"::",
"Wait",
".",
"default_options",
"[",
":timeout",
"]",
",",
"timeout_message",
":",
"nil",
",",
"retry_frequency",
":",
"Calabash",
"::",
"Wait",
".",
"default_options",
"[",
":retry_frequency",
"]",
")",
"if",
"queries",
".",
"nil?",
"||",
"queries",
".",
"any?",
"(",
":nil?",
")",
"raise",
"ArgumentError",
",",
"'Query cannot be nil'",
"end",
"timeout_message",
"||=",
"lambda",
"do",
"|",
"wait_options",
"|",
"\"Waited #{wait_options[:timeout]} seconds for #{Wait.parse_query_list(queries)} to each not match any view\"",
"end",
"wait_for",
"(",
"timeout_message",
",",
"timeout",
":",
"timeout",
",",
"retry_frequency",
":",
"retry_frequency",
",",
"exception_class",
":",
"ViewFoundError",
")",
"do",
"!",
"views_exist?",
"(",
"queries",
")",
"end",
"end"
] |
Waits for all `queries` to simultaneously match no views
@example
cal.wait_for_no_views({id: 'foo'}, {id: 'bar'})
@see Calabash::Wait#wait_for for optional parameters
@param [String, Hash, Calabash::Query] queries List of queries or a
query.
@raise [ViewNotFoundError] If `queries` do not all match at least one
view.
|
[
"Waits",
"for",
"all",
"queries",
"to",
"simultaneously",
"match",
"no",
"views"
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/wait.rb#L288-L306
|
22,354 |
calabash/calabash
|
lib/calabash/wait.rb
|
Calabash.Wait.view_exists?
|
def view_exists?(query)
if query.nil?
raise ArgumentError, 'Query cannot be nil'
end
result = query(query)
!result.empty?
end
|
ruby
|
def view_exists?(query)
if query.nil?
raise ArgumentError, 'Query cannot be nil'
end
result = query(query)
!result.empty?
end
|
[
"def",
"view_exists?",
"(",
"query",
")",
"if",
"query",
".",
"nil?",
"raise",
"ArgumentError",
",",
"'Query cannot be nil'",
"end",
"result",
"=",
"query",
"(",
"query",
")",
"!",
"result",
".",
"empty?",
"end"
] |
Does the given `query` match at least one view?
@param [String, Hash, Calabash::Query] query Query to match view
@return [Boolean] Returns true if the `query` matches at least one view
@raise [ArgumentError] If given an invalid `query`
|
[
"Does",
"the",
"given",
"query",
"match",
"at",
"least",
"one",
"view?"
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/wait.rb#L313-L321
|
22,355 |
calabash/calabash
|
lib/calabash/wait.rb
|
Calabash.Wait.views_exist?
|
def views_exist?(*queries)
if queries.nil? || queries.any?(&:nil?)
raise ArgumentError, 'Query cannot be nil'
end
results = queries.map{|query| view_exists?(query)}
results.all?
end
|
ruby
|
def views_exist?(*queries)
if queries.nil? || queries.any?(&:nil?)
raise ArgumentError, 'Query cannot be nil'
end
results = queries.map{|query| view_exists?(query)}
results.all?
end
|
[
"def",
"views_exist?",
"(",
"*",
"queries",
")",
"if",
"queries",
".",
"nil?",
"||",
"queries",
".",
"any?",
"(",
":nil?",
")",
"raise",
"ArgumentError",
",",
"'Query cannot be nil'",
"end",
"results",
"=",
"queries",
".",
"map",
"{",
"|",
"query",
"|",
"view_exists?",
"(",
"query",
")",
"}",
"results",
".",
"all?",
"end"
] |
Does the given `queries` all match at least one view?
@param [String, Hash, Calabash::Query] queries List of queries or a
query
@return [Boolean] Returns true if the `queries` all match at least one
view
@raise [ArgumentError] If given an invalid list of queries
|
[
"Does",
"the",
"given",
"queries",
"all",
"match",
"at",
"least",
"one",
"view?"
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/wait.rb#L330-L338
|
22,356 |
calabash/calabash
|
lib/calabash/wait.rb
|
Calabash.Wait.expect_view
|
def expect_view(query)
if query.nil?
raise ArgumentError, 'Query cannot be nil'
end
unless view_exists?(query)
raise ViewNotFoundError,
"No view matched #{Wait.parse_query_list(query)}"
end
true
end
|
ruby
|
def expect_view(query)
if query.nil?
raise ArgumentError, 'Query cannot be nil'
end
unless view_exists?(query)
raise ViewNotFoundError,
"No view matched #{Wait.parse_query_list(query)}"
end
true
end
|
[
"def",
"expect_view",
"(",
"query",
")",
"if",
"query",
".",
"nil?",
"raise",
"ArgumentError",
",",
"'Query cannot be nil'",
"end",
"unless",
"view_exists?",
"(",
"query",
")",
"raise",
"ViewNotFoundError",
",",
"\"No view matched #{Wait.parse_query_list(query)}\"",
"end",
"true",
"end"
] |
Expect `query` to match at least one view. Raise an exception if it does
not.
@param [String, Hash, Calabash::Query] query Query to match a view
@raise [ArgumentError] If given an invalid `query`
@raise [ViewNotFoundError] If `query` does not match at least one view
|
[
"Expect",
"query",
"to",
"match",
"at",
"least",
"one",
"view",
".",
"Raise",
"an",
"exception",
"if",
"it",
"does",
"not",
"."
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/wait.rb#L346-L357
|
22,357 |
calabash/calabash
|
lib/calabash/wait.rb
|
Calabash.Wait.expect_views
|
def expect_views(*queries)
if queries.nil? || queries.any?(&:nil?)
raise ArgumentError, 'Query cannot be nil'
end
unless views_exist?(*queries)
raise ViewNotFoundError,
"Not all queries #{Wait.parse_query_list(queries)} matched a view"
end
true
end
|
ruby
|
def expect_views(*queries)
if queries.nil? || queries.any?(&:nil?)
raise ArgumentError, 'Query cannot be nil'
end
unless views_exist?(*queries)
raise ViewNotFoundError,
"Not all queries #{Wait.parse_query_list(queries)} matched a view"
end
true
end
|
[
"def",
"expect_views",
"(",
"*",
"queries",
")",
"if",
"queries",
".",
"nil?",
"||",
"queries",
".",
"any?",
"(",
":nil?",
")",
"raise",
"ArgumentError",
",",
"'Query cannot be nil'",
"end",
"unless",
"views_exist?",
"(",
"queries",
")",
"raise",
"ViewNotFoundError",
",",
"\"Not all queries #{Wait.parse_query_list(queries)} matched a view\"",
"end",
"true",
"end"
] |
Expect `queries` to each match at least one view. Raise an exception if
they do not.
@param [String, Hash, Calabash::Query] queries List of queries or a
query.
@raise [ArgumentError] If given an invalid list of queries
@raise [ViewNotFoundError] If `queries` do not all match at least one
view.
|
[
"Expect",
"queries",
"to",
"each",
"match",
"at",
"least",
"one",
"view",
".",
"Raise",
"an",
"exception",
"if",
"they",
"do",
"not",
"."
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/wait.rb#L369-L380
|
22,358 |
calabash/calabash
|
lib/calabash/wait.rb
|
Calabash.Wait.do_not_expect_view
|
def do_not_expect_view(query)
if query.nil?
raise ArgumentError, 'Query cannot be nil'
end
if view_exists?(query)
raise ViewFoundError, "A view matched #{Wait.parse_query_list(query)}"
end
true
end
|
ruby
|
def do_not_expect_view(query)
if query.nil?
raise ArgumentError, 'Query cannot be nil'
end
if view_exists?(query)
raise ViewFoundError, "A view matched #{Wait.parse_query_list(query)}"
end
true
end
|
[
"def",
"do_not_expect_view",
"(",
"query",
")",
"if",
"query",
".",
"nil?",
"raise",
"ArgumentError",
",",
"'Query cannot be nil'",
"end",
"if",
"view_exists?",
"(",
"query",
")",
"raise",
"ViewFoundError",
",",
"\"A view matched #{Wait.parse_query_list(query)}\"",
"end",
"true",
"end"
] |
Expect `query` to match no views. Raise an exception if it does.
@param [String, Hash, Calabash::Query] query Query to match a view
@raise [ArgumentError] If given an invalid `query`
@raise [ViewFoundError] If `query` matches any views.
|
[
"Expect",
"query",
"to",
"match",
"no",
"views",
".",
"Raise",
"an",
"exception",
"if",
"it",
"does",
"."
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/wait.rb#L389-L399
|
22,359 |
calabash/calabash
|
lib/calabash/wait.rb
|
Calabash.Wait.do_not_expect_views
|
def do_not_expect_views(*queries)
if queries.nil? || queries.any?(&:nil?)
raise ArgumentError, 'Query cannot be nil'
end
if queries.map{|query| view_exists?(query)}.any?
raise ViewFoundError,
"Some views matched #{Wait.parse_query_list(queries)}"
end
true
end
|
ruby
|
def do_not_expect_views(*queries)
if queries.nil? || queries.any?(&:nil?)
raise ArgumentError, 'Query cannot be nil'
end
if queries.map{|query| view_exists?(query)}.any?
raise ViewFoundError,
"Some views matched #{Wait.parse_query_list(queries)}"
end
true
end
|
[
"def",
"do_not_expect_views",
"(",
"*",
"queries",
")",
"if",
"queries",
".",
"nil?",
"||",
"queries",
".",
"any?",
"(",
":nil?",
")",
"raise",
"ArgumentError",
",",
"'Query cannot be nil'",
"end",
"if",
"queries",
".",
"map",
"{",
"|",
"query",
"|",
"view_exists?",
"(",
"query",
")",
"}",
".",
"any?",
"raise",
"ViewFoundError",
",",
"\"Some views matched #{Wait.parse_query_list(queries)}\"",
"end",
"true",
"end"
] |
Expect `queries` to each match no views. Raise an exception if they do.
@param [String, Hash, Calabash::Query] queries List of queries or a
query.
@raise [ArgumentError] If given an invalid list of queries
@raise [ViewFoundError] If one of `queries` matched any views
|
[
"Expect",
"queries",
"to",
"each",
"match",
"no",
"views",
".",
"Raise",
"an",
"exception",
"if",
"they",
"do",
"."
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/wait.rb#L409-L420
|
22,360 |
calabash/calabash
|
lib/calabash/wait.rb
|
Calabash.Wait.wait_for_text
|
def wait_for_text(text,
timeout: Calabash::Wait.default_options[:timeout],
timeout_message: nil,
retry_frequency: Calabash::Wait.default_options[:retry_frequency])
wait_for_view("* {text CONTAINS[c] '#{text}'}",
timeout: timeout,
timeout_message: timeout_message,
retry_frequency: retry_frequency)
end
|
ruby
|
def wait_for_text(text,
timeout: Calabash::Wait.default_options[:timeout],
timeout_message: nil,
retry_frequency: Calabash::Wait.default_options[:retry_frequency])
wait_for_view("* {text CONTAINS[c] '#{text}'}",
timeout: timeout,
timeout_message: timeout_message,
retry_frequency: retry_frequency)
end
|
[
"def",
"wait_for_text",
"(",
"text",
",",
"timeout",
":",
"Calabash",
"::",
"Wait",
".",
"default_options",
"[",
":timeout",
"]",
",",
"timeout_message",
":",
"nil",
",",
"retry_frequency",
":",
"Calabash",
"::",
"Wait",
".",
"default_options",
"[",
":retry_frequency",
"]",
")",
"wait_for_view",
"(",
"\"* {text CONTAINS[c] '#{text}'}\"",
",",
"timeout",
":",
"timeout",
",",
"timeout_message",
":",
"timeout_message",
",",
"retry_frequency",
":",
"retry_frequency",
")",
"end"
] |
Waits for a view containing `text`.
@see Calabash::Wait#wait_for_view
@param text [String] Text to look for
@return [Object] The view matched by the text query
|
[
"Waits",
"for",
"a",
"view",
"containing",
"text",
"."
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/wait.rb#L430-L439
|
22,361 |
calabash/calabash
|
lib/calabash/wait.rb
|
Calabash.Wait.wait_for_no_text
|
def wait_for_no_text(text,
timeout: Calabash::Wait.default_options[:timeout],
timeout_message: nil,
retry_frequency: Calabash::Wait.default_options[:retry_frequency])
wait_for_no_view("* {text CONTAINS[c] '#{text}'}",
timeout: timeout,
timeout_message: timeout_message,
retry_frequency: retry_frequency)
end
|
ruby
|
def wait_for_no_text(text,
timeout: Calabash::Wait.default_options[:timeout],
timeout_message: nil,
retry_frequency: Calabash::Wait.default_options[:retry_frequency])
wait_for_no_view("* {text CONTAINS[c] '#{text}'}",
timeout: timeout,
timeout_message: timeout_message,
retry_frequency: retry_frequency)
end
|
[
"def",
"wait_for_no_text",
"(",
"text",
",",
"timeout",
":",
"Calabash",
"::",
"Wait",
".",
"default_options",
"[",
":timeout",
"]",
",",
"timeout_message",
":",
"nil",
",",
"retry_frequency",
":",
"Calabash",
"::",
"Wait",
".",
"default_options",
"[",
":retry_frequency",
"]",
")",
"wait_for_no_view",
"(",
"\"* {text CONTAINS[c] '#{text}'}\"",
",",
"timeout",
":",
"timeout",
",",
"timeout_message",
":",
"timeout_message",
",",
"retry_frequency",
":",
"retry_frequency",
")",
"end"
] |
Waits for no views containing `text`.
@see Calabash::Wait#wait_for_view
@param text [String] Text to look for
@return [Object] The view matched by the text query
|
[
"Waits",
"for",
"no",
"views",
"containing",
"text",
"."
] |
fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745
|
https://github.com/calabash/calabash/blob/fac1ce9fcff6e2460c6e72a9b89d93a91a1bc745/lib/calabash/wait.rb#L447-L456
|
22,362 |
dicom/ruby-dicom
|
lib/dicom/audit_trail.rb
|
DICOM.AuditTrail.add_record
|
def add_record(tag, original, replacement)
@dictionary[tag] = Hash.new unless @dictionary.key?(tag)
@dictionary[tag][original] = replacement
end
|
ruby
|
def add_record(tag, original, replacement)
@dictionary[tag] = Hash.new unless @dictionary.key?(tag)
@dictionary[tag][original] = replacement
end
|
[
"def",
"add_record",
"(",
"tag",
",",
"original",
",",
"replacement",
")",
"@dictionary",
"[",
"tag",
"]",
"=",
"Hash",
".",
"new",
"unless",
"@dictionary",
".",
"key?",
"(",
"tag",
")",
"@dictionary",
"[",
"tag",
"]",
"[",
"original",
"]",
"=",
"replacement",
"end"
] |
Creates a new AuditTrail instance.
Adds a tag record to the log.
@param [String] tag the tag string (e.q. '0010,0010')
@param [String, Integer, Float] original the original value (e.q. 'John Doe')
@param [String, Integer, Float] replacement the replacement value (e.q. 'Patient1')
|
[
"Creates",
"a",
"new",
"AuditTrail",
"instance",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/audit_trail.rb#L41-L44
|
22,363 |
dicom/ruby-dicom
|
lib/dicom/audit_trail.rb
|
DICOM.AuditTrail.original
|
def original(tag, replacement)
original = nil
if @dictionary.key?(tag)
original = @dictionary[tag].key(replacement)
end
return original
end
|
ruby
|
def original(tag, replacement)
original = nil
if @dictionary.key?(tag)
original = @dictionary[tag].key(replacement)
end
return original
end
|
[
"def",
"original",
"(",
"tag",
",",
"replacement",
")",
"original",
"=",
"nil",
"if",
"@dictionary",
".",
"key?",
"(",
"tag",
")",
"original",
"=",
"@dictionary",
"[",
"tag",
"]",
".",
"key",
"(",
"replacement",
")",
"end",
"return",
"original",
"end"
] |
Retrieves the original value used for the given combination of tag & replacement value.
@param [String] tag the tag string (e.q. '0010,0010')
@param [String, Integer, Float] replacement the replacement value (e.q. 'Patient1')
@return [String, Integer, Float] the original value of the given tag
|
[
"Retrieves",
"the",
"original",
"value",
"used",
"for",
"the",
"given",
"combination",
"of",
"tag",
"&",
"replacement",
"value",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/audit_trail.rb#L60-L66
|
22,364 |
dicom/ruby-dicom
|
lib/dicom/audit_trail.rb
|
DICOM.AuditTrail.replacement
|
def replacement(tag, original)
replacement = nil
replacement = @dictionary[tag][original] if @dictionary.key?(tag)
return replacement
end
|
ruby
|
def replacement(tag, original)
replacement = nil
replacement = @dictionary[tag][original] if @dictionary.key?(tag)
return replacement
end
|
[
"def",
"replacement",
"(",
"tag",
",",
"original",
")",
"replacement",
"=",
"nil",
"replacement",
"=",
"@dictionary",
"[",
"tag",
"]",
"[",
"original",
"]",
"if",
"@dictionary",
".",
"key?",
"(",
"tag",
")",
"return",
"replacement",
"end"
] |
Retrieves the replacement value used for the given combination of tag & original value.
@param [String] tag the tag string (e.q. '0010,0010')
@param [String, Integer, Float] original the original value (e.q. 'John Doe')
@return [String, Integer, Float] the replacement value of the given tag
|
[
"Retrieves",
"the",
"replacement",
"value",
"used",
"for",
"the",
"given",
"combination",
"of",
"tag",
"&",
"original",
"value",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/audit_trail.rb#L87-L91
|
22,365 |
dicom/ruby-dicom
|
lib/dicom/d_object.rb
|
DICOM.DObject.encode_segments
|
def encode_segments(max_size, transfer_syntax=IMPLICIT_LITTLE_ENDIAN)
raise ArgumentError, "Invalid argument. Expected an Integer, got #{max_size.class}." unless max_size.is_a?(Integer)
raise ArgumentError, "Argument too low (#{max_size}), please specify a bigger Integer." unless max_size > 16
raise "Can not encode binary segments for an empty DICOM object." if children.length == 0
encode_in_segments(max_size, :syntax => transfer_syntax)
end
|
ruby
|
def encode_segments(max_size, transfer_syntax=IMPLICIT_LITTLE_ENDIAN)
raise ArgumentError, "Invalid argument. Expected an Integer, got #{max_size.class}." unless max_size.is_a?(Integer)
raise ArgumentError, "Argument too low (#{max_size}), please specify a bigger Integer." unless max_size > 16
raise "Can not encode binary segments for an empty DICOM object." if children.length == 0
encode_in_segments(max_size, :syntax => transfer_syntax)
end
|
[
"def",
"encode_segments",
"(",
"max_size",
",",
"transfer_syntax",
"=",
"IMPLICIT_LITTLE_ENDIAN",
")",
"raise",
"ArgumentError",
",",
"\"Invalid argument. Expected an Integer, got #{max_size.class}.\"",
"unless",
"max_size",
".",
"is_a?",
"(",
"Integer",
")",
"raise",
"ArgumentError",
",",
"\"Argument too low (#{max_size}), please specify a bigger Integer.\"",
"unless",
"max_size",
">",
"16",
"raise",
"\"Can not encode binary segments for an empty DICOM object.\"",
"if",
"children",
".",
"length",
"==",
"0",
"encode_in_segments",
"(",
"max_size",
",",
":syntax",
"=>",
"transfer_syntax",
")",
"end"
] |
Encodes the DICOM object into a series of binary string segments with a specified maximum length.
Returns the encoded binary strings in an array.
@param [Integer] max_size the maximum allowed size of the binary data strings to be encoded
@param [String] transfer_syntax the transfer syntax string to be used when encoding the DICOM object to string segments. When this method is used for making network packets, the transfer_syntax is not part of the object, and thus needs to be specified.
@return [Array<String>] the encoded DICOM strings
@example Encode the DObject to strings of max length 2^14 bytes
encoded_strings = dcm.encode_segments(16384)
|
[
"Encodes",
"the",
"DICOM",
"object",
"into",
"a",
"series",
"of",
"binary",
"string",
"segments",
"with",
"a",
"specified",
"maximum",
"length",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_object.rb#L230-L235
|
22,366 |
dicom/ruby-dicom
|
lib/dicom/d_object.rb
|
DICOM.DObject.summary
|
def summary
# FIXME: Perhaps this method should be split up in one or two separate methods
# which just builds the information arrays, and a third method for printing this to the screen.
sys_info = Array.new
info = Array.new
# Version of Ruby DICOM used:
sys_info << "Ruby DICOM version: #{VERSION}"
# System endian:
cpu = (CPU_ENDIAN ? "Big Endian" : "Little Endian")
sys_info << "Byte Order (CPU): #{cpu}"
# Source (file name):
if @source
if @source == :str
source = "Binary string #{@read_success ? '(successfully parsed)' : '(failed to parse)'}"
else
source = "File #{@read_success ? '(successfully read)' : '(failed to read)'}: #{@source}"
end
else
source = 'Created from scratch'
end
info << "Source: #{source}"
# Modality:
modality = (LIBRARY.uid(value('0008,0016')) ? LIBRARY.uid(value('0008,0016')).name : "SOP Class unknown or not specified!")
info << "Modality: #{modality}"
# Meta header presence (Simply check for the presence of the transfer syntax data element), VR and byte order:
ts_status = self['0002,0010'] ? '' : ' (Assumed)'
ts = LIBRARY.uid(transfer_syntax)
explicit = ts ? ts.explicit? : true
endian = ts ? ts.big_endian? : false
meta_comment = ts ? "" : " (But unknown/invalid transfer syntax: #{transfer_syntax})"
info << "Meta Header: #{self['0002,0010'] ? 'Yes' : 'No'}#{meta_comment}"
info << "Value Representation: #{explicit ? 'Explicit' : 'Implicit'}#{ts_status}"
info << "Byte Order (File): #{endian ? 'Big Endian' : 'Little Endian'}#{ts_status}"
# Pixel data:
pixels = self[PIXEL_TAG]
unless pixels
info << "Pixel Data: No"
else
info << "Pixel Data: Yes"
# Image size:
cols = (exists?("0028,0011") ? self["0028,0011"].value : "Columns missing")
rows = (exists?("0028,0010") ? self["0028,0010"].value : "Rows missing")
info << "Image Size: #{cols}*#{rows}"
# Frames:
frames = value("0028,0008") || "1"
unless frames == "1" or frames == 1
# Encapsulated or 3D pixel data:
if pixels.is_a?(Element)
frames = frames.to_s + " (3D Pixel Data)"
else
frames = frames.to_s + " (Encapsulated Multiframe Image)"
end
end
info << "Number of frames: #{frames}"
# Color:
colors = (exists?("0028,0004") ? self["0028,0004"].value : "Not specified")
info << "Photometry: #{colors}"
# Compression:
compression = (ts ? (ts.compressed_pixels? ? ts.name : 'No') : 'No' )
info << "Compression: #{compression}#{ts_status}"
# Pixel bits (allocated):
bits = (exists?("0028,0100") ? self["0028,0100"].value : "Not specified")
info << "Bits per Pixel: #{bits}"
end
# Print the DICOM object's key properties:
separator = "-------------------------------------------"
puts "System Properties:"
puts separator + "\n"
puts sys_info
puts "\n"
puts "DICOM Object Properties:"
puts separator
puts info
puts separator
return info
end
|
ruby
|
def summary
# FIXME: Perhaps this method should be split up in one or two separate methods
# which just builds the information arrays, and a third method for printing this to the screen.
sys_info = Array.new
info = Array.new
# Version of Ruby DICOM used:
sys_info << "Ruby DICOM version: #{VERSION}"
# System endian:
cpu = (CPU_ENDIAN ? "Big Endian" : "Little Endian")
sys_info << "Byte Order (CPU): #{cpu}"
# Source (file name):
if @source
if @source == :str
source = "Binary string #{@read_success ? '(successfully parsed)' : '(failed to parse)'}"
else
source = "File #{@read_success ? '(successfully read)' : '(failed to read)'}: #{@source}"
end
else
source = 'Created from scratch'
end
info << "Source: #{source}"
# Modality:
modality = (LIBRARY.uid(value('0008,0016')) ? LIBRARY.uid(value('0008,0016')).name : "SOP Class unknown or not specified!")
info << "Modality: #{modality}"
# Meta header presence (Simply check for the presence of the transfer syntax data element), VR and byte order:
ts_status = self['0002,0010'] ? '' : ' (Assumed)'
ts = LIBRARY.uid(transfer_syntax)
explicit = ts ? ts.explicit? : true
endian = ts ? ts.big_endian? : false
meta_comment = ts ? "" : " (But unknown/invalid transfer syntax: #{transfer_syntax})"
info << "Meta Header: #{self['0002,0010'] ? 'Yes' : 'No'}#{meta_comment}"
info << "Value Representation: #{explicit ? 'Explicit' : 'Implicit'}#{ts_status}"
info << "Byte Order (File): #{endian ? 'Big Endian' : 'Little Endian'}#{ts_status}"
# Pixel data:
pixels = self[PIXEL_TAG]
unless pixels
info << "Pixel Data: No"
else
info << "Pixel Data: Yes"
# Image size:
cols = (exists?("0028,0011") ? self["0028,0011"].value : "Columns missing")
rows = (exists?("0028,0010") ? self["0028,0010"].value : "Rows missing")
info << "Image Size: #{cols}*#{rows}"
# Frames:
frames = value("0028,0008") || "1"
unless frames == "1" or frames == 1
# Encapsulated or 3D pixel data:
if pixels.is_a?(Element)
frames = frames.to_s + " (3D Pixel Data)"
else
frames = frames.to_s + " (Encapsulated Multiframe Image)"
end
end
info << "Number of frames: #{frames}"
# Color:
colors = (exists?("0028,0004") ? self["0028,0004"].value : "Not specified")
info << "Photometry: #{colors}"
# Compression:
compression = (ts ? (ts.compressed_pixels? ? ts.name : 'No') : 'No' )
info << "Compression: #{compression}#{ts_status}"
# Pixel bits (allocated):
bits = (exists?("0028,0100") ? self["0028,0100"].value : "Not specified")
info << "Bits per Pixel: #{bits}"
end
# Print the DICOM object's key properties:
separator = "-------------------------------------------"
puts "System Properties:"
puts separator + "\n"
puts sys_info
puts "\n"
puts "DICOM Object Properties:"
puts separator
puts info
puts separator
return info
end
|
[
"def",
"summary",
"# FIXME: Perhaps this method should be split up in one or two separate methods",
"# which just builds the information arrays, and a third method for printing this to the screen.",
"sys_info",
"=",
"Array",
".",
"new",
"info",
"=",
"Array",
".",
"new",
"# Version of Ruby DICOM used:",
"sys_info",
"<<",
"\"Ruby DICOM version: #{VERSION}\"",
"# System endian:",
"cpu",
"=",
"(",
"CPU_ENDIAN",
"?",
"\"Big Endian\"",
":",
"\"Little Endian\"",
")",
"sys_info",
"<<",
"\"Byte Order (CPU): #{cpu}\"",
"# Source (file name):",
"if",
"@source",
"if",
"@source",
"==",
":str",
"source",
"=",
"\"Binary string #{@read_success ? '(successfully parsed)' : '(failed to parse)'}\"",
"else",
"source",
"=",
"\"File #{@read_success ? '(successfully read)' : '(failed to read)'}: #{@source}\"",
"end",
"else",
"source",
"=",
"'Created from scratch'",
"end",
"info",
"<<",
"\"Source: #{source}\"",
"# Modality:",
"modality",
"=",
"(",
"LIBRARY",
".",
"uid",
"(",
"value",
"(",
"'0008,0016'",
")",
")",
"?",
"LIBRARY",
".",
"uid",
"(",
"value",
"(",
"'0008,0016'",
")",
")",
".",
"name",
":",
"\"SOP Class unknown or not specified!\"",
")",
"info",
"<<",
"\"Modality: #{modality}\"",
"# Meta header presence (Simply check for the presence of the transfer syntax data element), VR and byte order:",
"ts_status",
"=",
"self",
"[",
"'0002,0010'",
"]",
"?",
"''",
":",
"' (Assumed)'",
"ts",
"=",
"LIBRARY",
".",
"uid",
"(",
"transfer_syntax",
")",
"explicit",
"=",
"ts",
"?",
"ts",
".",
"explicit?",
":",
"true",
"endian",
"=",
"ts",
"?",
"ts",
".",
"big_endian?",
":",
"false",
"meta_comment",
"=",
"ts",
"?",
"\"\"",
":",
"\" (But unknown/invalid transfer syntax: #{transfer_syntax})\"",
"info",
"<<",
"\"Meta Header: #{self['0002,0010'] ? 'Yes' : 'No'}#{meta_comment}\"",
"info",
"<<",
"\"Value Representation: #{explicit ? 'Explicit' : 'Implicit'}#{ts_status}\"",
"info",
"<<",
"\"Byte Order (File): #{endian ? 'Big Endian' : 'Little Endian'}#{ts_status}\"",
"# Pixel data:",
"pixels",
"=",
"self",
"[",
"PIXEL_TAG",
"]",
"unless",
"pixels",
"info",
"<<",
"\"Pixel Data: No\"",
"else",
"info",
"<<",
"\"Pixel Data: Yes\"",
"# Image size:",
"cols",
"=",
"(",
"exists?",
"(",
"\"0028,0011\"",
")",
"?",
"self",
"[",
"\"0028,0011\"",
"]",
".",
"value",
":",
"\"Columns missing\"",
")",
"rows",
"=",
"(",
"exists?",
"(",
"\"0028,0010\"",
")",
"?",
"self",
"[",
"\"0028,0010\"",
"]",
".",
"value",
":",
"\"Rows missing\"",
")",
"info",
"<<",
"\"Image Size: #{cols}*#{rows}\"",
"# Frames:",
"frames",
"=",
"value",
"(",
"\"0028,0008\"",
")",
"||",
"\"1\"",
"unless",
"frames",
"==",
"\"1\"",
"or",
"frames",
"==",
"1",
"# Encapsulated or 3D pixel data:",
"if",
"pixels",
".",
"is_a?",
"(",
"Element",
")",
"frames",
"=",
"frames",
".",
"to_s",
"+",
"\" (3D Pixel Data)\"",
"else",
"frames",
"=",
"frames",
".",
"to_s",
"+",
"\" (Encapsulated Multiframe Image)\"",
"end",
"end",
"info",
"<<",
"\"Number of frames: #{frames}\"",
"# Color:",
"colors",
"=",
"(",
"exists?",
"(",
"\"0028,0004\"",
")",
"?",
"self",
"[",
"\"0028,0004\"",
"]",
".",
"value",
":",
"\"Not specified\"",
")",
"info",
"<<",
"\"Photometry: #{colors}\"",
"# Compression:",
"compression",
"=",
"(",
"ts",
"?",
"(",
"ts",
".",
"compressed_pixels?",
"?",
"ts",
".",
"name",
":",
"'No'",
")",
":",
"'No'",
")",
"info",
"<<",
"\"Compression: #{compression}#{ts_status}\"",
"# Pixel bits (allocated):",
"bits",
"=",
"(",
"exists?",
"(",
"\"0028,0100\"",
")",
"?",
"self",
"[",
"\"0028,0100\"",
"]",
".",
"value",
":",
"\"Not specified\"",
")",
"info",
"<<",
"\"Bits per Pixel: #{bits}\"",
"end",
"# Print the DICOM object's key properties:",
"separator",
"=",
"\"-------------------------------------------\"",
"puts",
"\"System Properties:\"",
"puts",
"separator",
"+",
"\"\\n\"",
"puts",
"sys_info",
"puts",
"\"\\n\"",
"puts",
"\"DICOM Object Properties:\"",
"puts",
"separator",
"puts",
"info",
"puts",
"separator",
"return",
"info",
"end"
] |
Gathers key information about the DObject as well as some system data, and prints this information to the screen.
This information includes properties like encoding, byte order, modality and various image properties.
@return [Array<String>] strings describing the properties of the DICOM object
|
[
"Gathers",
"key",
"information",
"about",
"the",
"DObject",
"as",
"well",
"as",
"some",
"system",
"data",
"and",
"prints",
"this",
"information",
"to",
"the",
"screen",
".",
"This",
"information",
"includes",
"properties",
"like",
"encoding",
"byte",
"order",
"modality",
"and",
"various",
"image",
"properties",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_object.rb#L261-L336
|
22,367 |
dicom/ruby-dicom
|
lib/dicom/d_object.rb
|
DICOM.DObject.transfer_syntax=
|
def transfer_syntax=(new_syntax)
# Verify old and new transfer syntax:
new_uid = LIBRARY.uid(new_syntax)
old_uid = LIBRARY.uid(transfer_syntax)
raise ArgumentError, "Invalid/unknown transfer syntax specified: #{new_syntax}" unless new_uid && new_uid.transfer_syntax?
raise ArgumentError, "Invalid/unknown existing transfer syntax: #{new_syntax} Unable to reliably handle byte order encoding. Modify the transfer syntax element directly instead." unless old_uid && old_uid.transfer_syntax?
# Set the new transfer syntax:
if exists?("0002,0010")
self["0002,0010"].value = new_syntax
else
add(Element.new("0002,0010", new_syntax))
end
# Update our Stream instance with the new encoding:
@stream.endian = new_uid.big_endian?
# If endianness is changed, re-encode elements (only elements depending on endianness will actually be re-encoded):
encode_children(old_uid.big_endian?) if old_uid.big_endian? != new_uid.big_endian?
end
|
ruby
|
def transfer_syntax=(new_syntax)
# Verify old and new transfer syntax:
new_uid = LIBRARY.uid(new_syntax)
old_uid = LIBRARY.uid(transfer_syntax)
raise ArgumentError, "Invalid/unknown transfer syntax specified: #{new_syntax}" unless new_uid && new_uid.transfer_syntax?
raise ArgumentError, "Invalid/unknown existing transfer syntax: #{new_syntax} Unable to reliably handle byte order encoding. Modify the transfer syntax element directly instead." unless old_uid && old_uid.transfer_syntax?
# Set the new transfer syntax:
if exists?("0002,0010")
self["0002,0010"].value = new_syntax
else
add(Element.new("0002,0010", new_syntax))
end
# Update our Stream instance with the new encoding:
@stream.endian = new_uid.big_endian?
# If endianness is changed, re-encode elements (only elements depending on endianness will actually be re-encoded):
encode_children(old_uid.big_endian?) if old_uid.big_endian? != new_uid.big_endian?
end
|
[
"def",
"transfer_syntax",
"=",
"(",
"new_syntax",
")",
"# Verify old and new transfer syntax:",
"new_uid",
"=",
"LIBRARY",
".",
"uid",
"(",
"new_syntax",
")",
"old_uid",
"=",
"LIBRARY",
".",
"uid",
"(",
"transfer_syntax",
")",
"raise",
"ArgumentError",
",",
"\"Invalid/unknown transfer syntax specified: #{new_syntax}\"",
"unless",
"new_uid",
"&&",
"new_uid",
".",
"transfer_syntax?",
"raise",
"ArgumentError",
",",
"\"Invalid/unknown existing transfer syntax: #{new_syntax} Unable to reliably handle byte order encoding. Modify the transfer syntax element directly instead.\"",
"unless",
"old_uid",
"&&",
"old_uid",
".",
"transfer_syntax?",
"# Set the new transfer syntax:",
"if",
"exists?",
"(",
"\"0002,0010\"",
")",
"self",
"[",
"\"0002,0010\"",
"]",
".",
"value",
"=",
"new_syntax",
"else",
"add",
"(",
"Element",
".",
"new",
"(",
"\"0002,0010\"",
",",
"new_syntax",
")",
")",
"end",
"# Update our Stream instance with the new encoding:",
"@stream",
".",
"endian",
"=",
"new_uid",
".",
"big_endian?",
"# If endianness is changed, re-encode elements (only elements depending on endianness will actually be re-encoded):",
"encode_children",
"(",
"old_uid",
".",
"big_endian?",
")",
"if",
"old_uid",
".",
"big_endian?",
"!=",
"new_uid",
".",
"big_endian?",
"end"
] |
Changes the transfer syntax Element of the DObject instance, and performs re-encoding of all
numerical values if a switch of endianness is implied.
@note This method does not change the compressed state of the pixel data element. Changing
the transfer syntax between an uncompressed and compressed state will NOT change the pixel
data accordingly (this must be taken care of manually).
@param [String] new_syntax the new transfer syntax string to be applied to the DObject
|
[
"Changes",
"the",
"transfer",
"syntax",
"Element",
"of",
"the",
"DObject",
"instance",
"and",
"performs",
"re",
"-",
"encoding",
"of",
"all",
"numerical",
"values",
"if",
"a",
"switch",
"of",
"endianness",
"is",
"implied",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_object.rb#L365-L381
|
22,368 |
dicom/ruby-dicom
|
lib/dicom/d_object.rb
|
DICOM.DObject.write
|
def write(file_name, options={})
raise ArgumentError, "Invalid file_name. Expected String, got #{file_name.class}." unless file_name.is_a?(String)
@include_empty_parents = options[:include_empty_parents]
insert_missing_meta unless options[:ignore_meta]
write_elements(:file_name => file_name, :signature => true, :syntax => transfer_syntax)
end
|
ruby
|
def write(file_name, options={})
raise ArgumentError, "Invalid file_name. Expected String, got #{file_name.class}." unless file_name.is_a?(String)
@include_empty_parents = options[:include_empty_parents]
insert_missing_meta unless options[:ignore_meta]
write_elements(:file_name => file_name, :signature => true, :syntax => transfer_syntax)
end
|
[
"def",
"write",
"(",
"file_name",
",",
"options",
"=",
"{",
"}",
")",
"raise",
"ArgumentError",
",",
"\"Invalid file_name. Expected String, got #{file_name.class}.\"",
"unless",
"file_name",
".",
"is_a?",
"(",
"String",
")",
"@include_empty_parents",
"=",
"options",
"[",
":include_empty_parents",
"]",
"insert_missing_meta",
"unless",
"options",
"[",
":ignore_meta",
"]",
"write_elements",
"(",
":file_name",
"=>",
"file_name",
",",
":signature",
"=>",
"true",
",",
":syntax",
"=>",
"transfer_syntax",
")",
"end"
] |
Writes the DICOM object to file.
@note The goal of the Ruby DICOM library is to yield maximum conformance with the DICOM
standard when outputting DICOM files. Therefore, when encoding the DICOM file, manipulation
of items such as the meta group, group lengths and header signature may occur. Therefore,
the file that is written may not be an exact bitwise copy of the file that was read, even if no
DObject manipulation has been done by the user.
@param [String] file_name the path of the DICOM file which is to be written to disk
@param [Hash] options the options to use for writing the DICOM file
@option options [Boolean] :ignore_meta if true, no manipulation of the DICOM object's meta group will be performed before the DObject is written to file
@option options [Boolean] :include_empty_parents if true, childless parents (sequences & items) are written to the DICOM file
@example Encode a DICOM file from a DObject
dcm.write('C:/dicom/test.dcm')
|
[
"Writes",
"the",
"DICOM",
"object",
"to",
"file",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_object.rb#L398-L403
|
22,369 |
dicom/ruby-dicom
|
lib/dicom/d_object.rb
|
DICOM.DObject.meta_group_length
|
def meta_group_length
group_length = 0
meta_elements = group(META_GROUP)
tag = 4
vr = 2
meta_elements.each do |element|
case element.vr
when "OB","OW","OF","SQ","UN","UT"
length = 6
else
length = 2
end
group_length += tag + vr + length + element.bin.length
end
group_length
end
|
ruby
|
def meta_group_length
group_length = 0
meta_elements = group(META_GROUP)
tag = 4
vr = 2
meta_elements.each do |element|
case element.vr
when "OB","OW","OF","SQ","UN","UT"
length = 6
else
length = 2
end
group_length += tag + vr + length + element.bin.length
end
group_length
end
|
[
"def",
"meta_group_length",
"group_length",
"=",
"0",
"meta_elements",
"=",
"group",
"(",
"META_GROUP",
")",
"tag",
"=",
"4",
"vr",
"=",
"2",
"meta_elements",
".",
"each",
"do",
"|",
"element",
"|",
"case",
"element",
".",
"vr",
"when",
"\"OB\"",
",",
"\"OW\"",
",",
"\"OF\"",
",",
"\"SQ\"",
",",
"\"UN\"",
",",
"\"UT\"",
"length",
"=",
"6",
"else",
"length",
"=",
"2",
"end",
"group_length",
"+=",
"tag",
"+",
"vr",
"+",
"length",
"+",
"element",
".",
"bin",
".",
"length",
"end",
"group_length",
"end"
] |
Determines the length of the meta group in the DObject instance.
@return [Integer] the length of the file meta group string
|
[
"Determines",
"the",
"length",
"of",
"the",
"meta",
"group",
"in",
"the",
"DObject",
"instance",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_object.rb#L438-L453
|
22,370 |
dicom/ruby-dicom
|
lib/dicom/image_item.rb
|
DICOM.ImageItem.add_element
|
def add_element(tag, value, options={})
add(e = Element.new(tag, value, options))
e
end
|
ruby
|
def add_element(tag, value, options={})
add(e = Element.new(tag, value, options))
e
end
|
[
"def",
"add_element",
"(",
"tag",
",",
"value",
",",
"options",
"=",
"{",
"}",
")",
"add",
"(",
"e",
"=",
"Element",
".",
"new",
"(",
"tag",
",",
"value",
",",
"options",
")",
")",
"e",
"end"
] |
Creates an Element with the given arguments and connects it to self.
@param [String] tag an element tag
@param [String, Integer, Float, Array, NilClass] value an element value
@param [Hash] options any options used for creating the element (see Element.new documentation)
|
[
"Creates",
"an",
"Element",
"with",
"the",
"given",
"arguments",
"and",
"connects",
"it",
"to",
"self",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/image_item.rb#L23-L26
|
22,371 |
dicom/ruby-dicom
|
lib/dicom/image_item.rb
|
DICOM.ImageItem.add_sequence
|
def add_sequence(tag, options={})
add(s = Sequence.new(tag, options))
s
end
|
ruby
|
def add_sequence(tag, options={})
add(s = Sequence.new(tag, options))
s
end
|
[
"def",
"add_sequence",
"(",
"tag",
",",
"options",
"=",
"{",
"}",
")",
"add",
"(",
"s",
"=",
"Sequence",
".",
"new",
"(",
"tag",
",",
"options",
")",
")",
"s",
"end"
] |
Creates a Sequence with the given arguments and connects it to self.
@param [String] tag a sequence tag
@param [Hash] options any options used for creating the sequence (see Sequence.new documentation)
|
[
"Creates",
"a",
"Sequence",
"with",
"the",
"given",
"arguments",
"and",
"connects",
"it",
"to",
"self",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/image_item.rb#L33-L36
|
22,372 |
dicom/ruby-dicom
|
lib/dicom/image_item.rb
|
DICOM.ImageItem.color?
|
def color?
# "Photometric Interpretation" is contained in the data element "0028,0004":
begin
photometric = photometry
if photometric.include?('COLOR') or photometric.include?('RGB') or photometric.include?('YBR')
return true
else
return false
end
rescue
return false
end
end
|
ruby
|
def color?
# "Photometric Interpretation" is contained in the data element "0028,0004":
begin
photometric = photometry
if photometric.include?('COLOR') or photometric.include?('RGB') or photometric.include?('YBR')
return true
else
return false
end
rescue
return false
end
end
|
[
"def",
"color?",
"# \"Photometric Interpretation\" is contained in the data element \"0028,0004\":",
"begin",
"photometric",
"=",
"photometry",
"if",
"photometric",
".",
"include?",
"(",
"'COLOR'",
")",
"or",
"photometric",
".",
"include?",
"(",
"'RGB'",
")",
"or",
"photometric",
".",
"include?",
"(",
"'YBR'",
")",
"return",
"true",
"else",
"return",
"false",
"end",
"rescue",
"return",
"false",
"end",
"end"
] |
Checks if colored pixel data is present.
@return [Boolean] true if the object contains colored pixels, and false if not
|
[
"Checks",
"if",
"colored",
"pixel",
"data",
"is",
"present",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/image_item.rb#L42-L54
|
22,373 |
dicom/ruby-dicom
|
lib/dicom/image_item.rb
|
DICOM.ImageItem.decode_pixels
|
def decode_pixels(bin, stream=@stream)
raise ArgumentError, "Expected String, got #{bin.class}." unless bin.is_a?(String)
pixels = false
# We need to know what kind of bith depth and integer type the pixel data is saved with:
bit_depth_element = self['0028,0100']
pixel_representation_element = self['0028,0103']
if bit_depth_element and pixel_representation_element
# Load the binary pixel data to the Stream instance:
stream.set_string(bin)
template = template_string(bit_depth_element.value.to_i)
pixels = stream.decode_all(template) if template
else
raise "The Element specifying Bit Depth (0028,0100) is missing. Unable to decode pixel data." unless bit_depth_element
raise "The Element specifying Pixel Representation (0028,0103) is missing. Unable to decode pixel data." unless pixel_representation_element
end
return pixels
end
|
ruby
|
def decode_pixels(bin, stream=@stream)
raise ArgumentError, "Expected String, got #{bin.class}." unless bin.is_a?(String)
pixels = false
# We need to know what kind of bith depth and integer type the pixel data is saved with:
bit_depth_element = self['0028,0100']
pixel_representation_element = self['0028,0103']
if bit_depth_element and pixel_representation_element
# Load the binary pixel data to the Stream instance:
stream.set_string(bin)
template = template_string(bit_depth_element.value.to_i)
pixels = stream.decode_all(template) if template
else
raise "The Element specifying Bit Depth (0028,0100) is missing. Unable to decode pixel data." unless bit_depth_element
raise "The Element specifying Pixel Representation (0028,0103) is missing. Unable to decode pixel data." unless pixel_representation_element
end
return pixels
end
|
[
"def",
"decode_pixels",
"(",
"bin",
",",
"stream",
"=",
"@stream",
")",
"raise",
"ArgumentError",
",",
"\"Expected String, got #{bin.class}.\"",
"unless",
"bin",
".",
"is_a?",
"(",
"String",
")",
"pixels",
"=",
"false",
"# We need to know what kind of bith depth and integer type the pixel data is saved with:",
"bit_depth_element",
"=",
"self",
"[",
"'0028,0100'",
"]",
"pixel_representation_element",
"=",
"self",
"[",
"'0028,0103'",
"]",
"if",
"bit_depth_element",
"and",
"pixel_representation_element",
"# Load the binary pixel data to the Stream instance:",
"stream",
".",
"set_string",
"(",
"bin",
")",
"template",
"=",
"template_string",
"(",
"bit_depth_element",
".",
"value",
".",
"to_i",
")",
"pixels",
"=",
"stream",
".",
"decode_all",
"(",
"template",
")",
"if",
"template",
"else",
"raise",
"\"The Element specifying Bit Depth (0028,0100) is missing. Unable to decode pixel data.\"",
"unless",
"bit_depth_element",
"raise",
"\"The Element specifying Pixel Representation (0028,0103) is missing. Unable to decode pixel data.\"",
"unless",
"pixel_representation_element",
"end",
"return",
"pixels",
"end"
] |
Unpacks pixel values from a binary pixel string. The decode is performed
using values defined in the image related elements of the DObject instance.
@param [String] bin a binary string containing the pixels to be decoded
@param [Stream] stream a Stream instance to be used for decoding the pixels (optional)
@return [Array<Integer>] decoded pixel values
|
[
"Unpacks",
"pixel",
"values",
"from",
"a",
"binary",
"pixel",
"string",
".",
"The",
"decode",
"is",
"performed",
"using",
"values",
"defined",
"in",
"the",
"image",
"related",
"elements",
"of",
"the",
"DObject",
"instance",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/image_item.rb#L76-L92
|
22,374 |
dicom/ruby-dicom
|
lib/dicom/image_item.rb
|
DICOM.ImageItem.encode_pixels
|
def encode_pixels(pixels, stream=@stream)
raise ArgumentError, "Expected Array, got #{pixels.class}." unless pixels.is_a?(Array)
bin = false
# We need to know what kind of bith depth and integer type the pixel data is saved with:
bit_depth_element = self['0028,0100']
pixel_representation_element = self['0028,0103']
if bit_depth_element and pixel_representation_element
template = template_string(bit_depth_element.value.to_i)
bin = stream.encode(pixels, template) if template
else
raise "The Element specifying Bit Depth (0028,0100) is missing. Unable to encode the pixel data." unless bit_depth_element
raise "The Element specifying Pixel Representation (0028,0103) is missing. Unable to encode the pixel data." unless pixel_representation_element
end
return bin
end
|
ruby
|
def encode_pixels(pixels, stream=@stream)
raise ArgumentError, "Expected Array, got #{pixels.class}." unless pixels.is_a?(Array)
bin = false
# We need to know what kind of bith depth and integer type the pixel data is saved with:
bit_depth_element = self['0028,0100']
pixel_representation_element = self['0028,0103']
if bit_depth_element and pixel_representation_element
template = template_string(bit_depth_element.value.to_i)
bin = stream.encode(pixels, template) if template
else
raise "The Element specifying Bit Depth (0028,0100) is missing. Unable to encode the pixel data." unless bit_depth_element
raise "The Element specifying Pixel Representation (0028,0103) is missing. Unable to encode the pixel data." unless pixel_representation_element
end
return bin
end
|
[
"def",
"encode_pixels",
"(",
"pixels",
",",
"stream",
"=",
"@stream",
")",
"raise",
"ArgumentError",
",",
"\"Expected Array, got #{pixels.class}.\"",
"unless",
"pixels",
".",
"is_a?",
"(",
"Array",
")",
"bin",
"=",
"false",
"# We need to know what kind of bith depth and integer type the pixel data is saved with:",
"bit_depth_element",
"=",
"self",
"[",
"'0028,0100'",
"]",
"pixel_representation_element",
"=",
"self",
"[",
"'0028,0103'",
"]",
"if",
"bit_depth_element",
"and",
"pixel_representation_element",
"template",
"=",
"template_string",
"(",
"bit_depth_element",
".",
"value",
".",
"to_i",
")",
"bin",
"=",
"stream",
".",
"encode",
"(",
"pixels",
",",
"template",
")",
"if",
"template",
"else",
"raise",
"\"The Element specifying Bit Depth (0028,0100) is missing. Unable to encode the pixel data.\"",
"unless",
"bit_depth_element",
"raise",
"\"The Element specifying Pixel Representation (0028,0103) is missing. Unable to encode the pixel data.\"",
"unless",
"pixel_representation_element",
"end",
"return",
"bin",
"end"
] |
Packs a pixel value array to a binary pixel string. The encoding is performed
using values defined in the image related elements of the DObject instance.
@param [Array<Integer>] pixels an array containing the pixel values to be encoded
@param [Stream] stream a Stream instance to be used for encoding the pixels (optional)
@return [String] encoded pixel string
|
[
"Packs",
"a",
"pixel",
"value",
"array",
"to",
"a",
"binary",
"pixel",
"string",
".",
"The",
"encoding",
"is",
"performed",
"using",
"values",
"defined",
"in",
"the",
"image",
"related",
"elements",
"of",
"the",
"DObject",
"instance",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/image_item.rb#L101-L115
|
22,375 |
dicom/ruby-dicom
|
lib/dicom/image_item.rb
|
DICOM.ImageItem.images
|
def images(options={})
images = Array.new
if exists?(PIXEL_TAG)
# Gather the pixel data strings, and pick a single frame if indicated by options:
strings = image_strings(split_to_frames=true)
strings = [strings[options[:frame]]] if options[:frame]
if compression?
# Decompress, either to numbers (RLE) or to an image object (image based compressions):
if [TXS_RLE].include?(transfer_syntax)
pixel_frames = Array.new
strings.each {|string| pixel_frames << decode_rle(num_cols, num_rows, string)}
else
images = decompress(strings) || Array.new
logger.warn("Decompressing pixel values has failed (unsupported transfer syntax: '#{transfer_syntax}' - #{LIBRARY.uid(transfer_syntax) ? LIBRARY.uid(transfer_syntax).name : 'Unknown transfer syntax!'})") unless images.length > 0
end
else
# Uncompressed: Decode to numbers.
pixel_frames = Array.new
strings.each {|string| pixel_frames << decode_pixels(string)}
end
if pixel_frames
images = Array.new
pixel_frames.each do |pixels|
# Pixel values and pixel order may need to be rearranged if we have color data:
pixels = process_colors(pixels) if color?
if pixels
images << read_image(pixels, num_cols, num_rows, options)
else
logger.warn("Processing pixel values for this particular color mode failed, unable to construct image(s).")
end
end
end
end
return images
end
|
ruby
|
def images(options={})
images = Array.new
if exists?(PIXEL_TAG)
# Gather the pixel data strings, and pick a single frame if indicated by options:
strings = image_strings(split_to_frames=true)
strings = [strings[options[:frame]]] if options[:frame]
if compression?
# Decompress, either to numbers (RLE) or to an image object (image based compressions):
if [TXS_RLE].include?(transfer_syntax)
pixel_frames = Array.new
strings.each {|string| pixel_frames << decode_rle(num_cols, num_rows, string)}
else
images = decompress(strings) || Array.new
logger.warn("Decompressing pixel values has failed (unsupported transfer syntax: '#{transfer_syntax}' - #{LIBRARY.uid(transfer_syntax) ? LIBRARY.uid(transfer_syntax).name : 'Unknown transfer syntax!'})") unless images.length > 0
end
else
# Uncompressed: Decode to numbers.
pixel_frames = Array.new
strings.each {|string| pixel_frames << decode_pixels(string)}
end
if pixel_frames
images = Array.new
pixel_frames.each do |pixels|
# Pixel values and pixel order may need to be rearranged if we have color data:
pixels = process_colors(pixels) if color?
if pixels
images << read_image(pixels, num_cols, num_rows, options)
else
logger.warn("Processing pixel values for this particular color mode failed, unable to construct image(s).")
end
end
end
end
return images
end
|
[
"def",
"images",
"(",
"options",
"=",
"{",
"}",
")",
"images",
"=",
"Array",
".",
"new",
"if",
"exists?",
"(",
"PIXEL_TAG",
")",
"# Gather the pixel data strings, and pick a single frame if indicated by options:",
"strings",
"=",
"image_strings",
"(",
"split_to_frames",
"=",
"true",
")",
"strings",
"=",
"[",
"strings",
"[",
"options",
"[",
":frame",
"]",
"]",
"]",
"if",
"options",
"[",
":frame",
"]",
"if",
"compression?",
"# Decompress, either to numbers (RLE) or to an image object (image based compressions):",
"if",
"[",
"TXS_RLE",
"]",
".",
"include?",
"(",
"transfer_syntax",
")",
"pixel_frames",
"=",
"Array",
".",
"new",
"strings",
".",
"each",
"{",
"|",
"string",
"|",
"pixel_frames",
"<<",
"decode_rle",
"(",
"num_cols",
",",
"num_rows",
",",
"string",
")",
"}",
"else",
"images",
"=",
"decompress",
"(",
"strings",
")",
"||",
"Array",
".",
"new",
"logger",
".",
"warn",
"(",
"\"Decompressing pixel values has failed (unsupported transfer syntax: '#{transfer_syntax}' - #{LIBRARY.uid(transfer_syntax) ? LIBRARY.uid(transfer_syntax).name : 'Unknown transfer syntax!'})\"",
")",
"unless",
"images",
".",
"length",
">",
"0",
"end",
"else",
"# Uncompressed: Decode to numbers.",
"pixel_frames",
"=",
"Array",
".",
"new",
"strings",
".",
"each",
"{",
"|",
"string",
"|",
"pixel_frames",
"<<",
"decode_pixels",
"(",
"string",
")",
"}",
"end",
"if",
"pixel_frames",
"images",
"=",
"Array",
".",
"new",
"pixel_frames",
".",
"each",
"do",
"|",
"pixels",
"|",
"# Pixel values and pixel order may need to be rearranged if we have color data:",
"pixels",
"=",
"process_colors",
"(",
"pixels",
")",
"if",
"color?",
"if",
"pixels",
"images",
"<<",
"read_image",
"(",
"pixels",
",",
"num_cols",
",",
"num_rows",
",",
"options",
")",
"else",
"logger",
".",
"warn",
"(",
"\"Processing pixel values for this particular color mode failed, unable to construct image(s).\"",
")",
"end",
"end",
"end",
"end",
"return",
"images",
"end"
] |
Extracts an array of image objects, created from the encoded pixel data using
the image related elements in the DICOM object.
@note Creates an array of image objects in accordance with the selected image processor. Available processors are :rmagick and :mini_magick.
@param [Hash] options the options to use for extracting the images
@option options [Integer] :frame makes the method return an array containing only the image object corresponding to the specified frame number
@option options [TrueClass, Array<Integer>] :level if true, window leveling is performed using default values from the DICOM object, or if an array ([center, width]) is specified, these custom values are used instead
@option options [Boolean] :narray if true, forces the use of NArray for the pixel remap process (for faster execution)
@option options [Boolean] :remap if true, the returned pixel values are remapped to presentation values
@return [Array<MagickImage, NilClass>] an array of image objects, alternatively an empty array (if no image present or image decode failed)
@example Retrieve the pixel data as RMagick image objects
images = dcm.images
@example Retrieve the pixel data as RMagick image objects, remapped to presentation values (but without any leveling)
images = dcm.images(:remap => true)
@example Retrieve the pixel data as RMagick image objects, remapped to presentation values and leveled using the default center/width values in the DICOM object
images = dcm.images(:level => true)
@example Retrieve the pixel data as RMagick image objects, remapped to presentation values, leveled with the specified center/width values and using numerical array for the rescaling (~twice as fast)
images = dcm.images(:level => [-200,1000], :narray => true)
|
[
"Extracts",
"an",
"array",
"of",
"image",
"objects",
"created",
"from",
"the",
"encoded",
"pixel",
"data",
"using",
"the",
"image",
"related",
"elements",
"in",
"the",
"DICOM",
"object",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/image_item.rb#L164-L198
|
22,376 |
dicom/ruby-dicom
|
lib/dicom/image_item.rb
|
DICOM.ImageItem.image_to_file
|
def image_to_file(file)
raise ArgumentError, "Expected #{String}, got #{file.class}." unless file.is_a?(String)
# Split the file name in case of multiple fragments:
parts = file.split('.')
if parts.length > 1
base = parts[0..-2].join
extension = '.' + parts.last
else
base = file
extension = ''
end
# Get the binary image strings and dump them to the file(s):
images = image_strings
images.each_index do |i|
if images.length == 1
f = File.new(file, 'wb')
else
f = File.new("#{base}-#{i}#{extension}", 'wb')
end
f.write(images[i])
f.close
end
end
|
ruby
|
def image_to_file(file)
raise ArgumentError, "Expected #{String}, got #{file.class}." unless file.is_a?(String)
# Split the file name in case of multiple fragments:
parts = file.split('.')
if parts.length > 1
base = parts[0..-2].join
extension = '.' + parts.last
else
base = file
extension = ''
end
# Get the binary image strings and dump them to the file(s):
images = image_strings
images.each_index do |i|
if images.length == 1
f = File.new(file, 'wb')
else
f = File.new("#{base}-#{i}#{extension}", 'wb')
end
f.write(images[i])
f.close
end
end
|
[
"def",
"image_to_file",
"(",
"file",
")",
"raise",
"ArgumentError",
",",
"\"Expected #{String}, got #{file.class}.\"",
"unless",
"file",
".",
"is_a?",
"(",
"String",
")",
"# Split the file name in case of multiple fragments:",
"parts",
"=",
"file",
".",
"split",
"(",
"'.'",
")",
"if",
"parts",
".",
"length",
">",
"1",
"base",
"=",
"parts",
"[",
"0",
"..",
"-",
"2",
"]",
".",
"join",
"extension",
"=",
"'.'",
"+",
"parts",
".",
"last",
"else",
"base",
"=",
"file",
"extension",
"=",
"''",
"end",
"# Get the binary image strings and dump them to the file(s):",
"images",
"=",
"image_strings",
"images",
".",
"each_index",
"do",
"|",
"i",
"|",
"if",
"images",
".",
"length",
"==",
"1",
"f",
"=",
"File",
".",
"new",
"(",
"file",
",",
"'wb'",
")",
"else",
"f",
"=",
"File",
".",
"new",
"(",
"\"#{base}-#{i}#{extension}\"",
",",
"'wb'",
")",
"end",
"f",
".",
"write",
"(",
"images",
"[",
"i",
"]",
")",
"f",
".",
"close",
"end",
"end"
] |
Dumps the binary content of the Pixel Data element to the specified file.
If the DICOM object contains multi-fragment pixel data, each fragment
will be dumped to separate files (e.q. 'fragment-0.dat', 'fragment-1.dat').
@param [String] file a string which specifies the file path to use when dumping the pixel data
@example Dumping the pixel data to a file
dcm.image_to_file("exported_image.dat")
|
[
"Dumps",
"the",
"binary",
"content",
"of",
"the",
"Pixel",
"Data",
"element",
"to",
"the",
"specified",
"file",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/image_item.rb#L251-L273
|
22,377 |
dicom/ruby-dicom
|
lib/dicom/image_item.rb
|
DICOM.ImageItem.pixels
|
def pixels(options={})
pixels = nil
if exists?(PIXEL_TAG)
# For now we only support returning pixel data of the first frame, if the image is located in multiple pixel data items:
if compression?
pixels = decompress(image_strings.first)
else
pixels = decode_pixels(image_strings.first)
end
if pixels
# Remap the image from pixel values to presentation values if the user has requested this:
if options[:remap] or options[:level]
if options[:narray]
# Use numerical array (faster):
pixels = process_presentation_values_narray(pixels, -65535, 65535, options[:level]).to_a
else
# Use standard Ruby array (slower):
pixels = process_presentation_values(pixels, -65535, 65535, options[:level])
end
end
else
logger.warn("Decompressing the Pixel Data failed. Pixel values can not be extracted.")
end
end
return pixels
end
|
ruby
|
def pixels(options={})
pixels = nil
if exists?(PIXEL_TAG)
# For now we only support returning pixel data of the first frame, if the image is located in multiple pixel data items:
if compression?
pixels = decompress(image_strings.first)
else
pixels = decode_pixels(image_strings.first)
end
if pixels
# Remap the image from pixel values to presentation values if the user has requested this:
if options[:remap] or options[:level]
if options[:narray]
# Use numerical array (faster):
pixels = process_presentation_values_narray(pixels, -65535, 65535, options[:level]).to_a
else
# Use standard Ruby array (slower):
pixels = process_presentation_values(pixels, -65535, 65535, options[:level])
end
end
else
logger.warn("Decompressing the Pixel Data failed. Pixel values can not be extracted.")
end
end
return pixels
end
|
[
"def",
"pixels",
"(",
"options",
"=",
"{",
"}",
")",
"pixels",
"=",
"nil",
"if",
"exists?",
"(",
"PIXEL_TAG",
")",
"# For now we only support returning pixel data of the first frame, if the image is located in multiple pixel data items:",
"if",
"compression?",
"pixels",
"=",
"decompress",
"(",
"image_strings",
".",
"first",
")",
"else",
"pixels",
"=",
"decode_pixels",
"(",
"image_strings",
".",
"first",
")",
"end",
"if",
"pixels",
"# Remap the image from pixel values to presentation values if the user has requested this:",
"if",
"options",
"[",
":remap",
"]",
"or",
"options",
"[",
":level",
"]",
"if",
"options",
"[",
":narray",
"]",
"# Use numerical array (faster):",
"pixels",
"=",
"process_presentation_values_narray",
"(",
"pixels",
",",
"-",
"65535",
",",
"65535",
",",
"options",
"[",
":level",
"]",
")",
".",
"to_a",
"else",
"# Use standard Ruby array (slower):",
"pixels",
"=",
"process_presentation_values",
"(",
"pixels",
",",
"-",
"65535",
",",
"65535",
",",
"options",
"[",
":level",
"]",
")",
"end",
"end",
"else",
"logger",
".",
"warn",
"(",
"\"Decompressing the Pixel Data failed. Pixel values can not be extracted.\"",
")",
"end",
"end",
"return",
"pixels",
"end"
] |
Extracts the Pixel Data values in an ordinary Ruby Array.
Returns nil if no pixel data is present, and false if it fails to retrieve pixel data which is present.
The returned array does not carry the dimensions of the pixel data:
It is put in a one dimensional Array (vector).
@param [Hash] options the options to use for extracting the pixel data
@option options [TrueClass, Array<Integer>] :level if true, window leveling is performed using default values from the DICOM object, or if an array ([center, width]) is specified, these custom values are used instead
@option options [Boolean] :narray if true, forces the use of NArray for the pixel remap process (for faster execution)
@option options [Boolean] :remap if true, the returned pixel values are remapped to presentation values
@return [Array, NilClass, FalseClass] an Array of pixel values, alternatively nil (if no image present) or false (if image decode failed)
@example Simply retrieve the pixel data
pixels = dcm.pixels
@example Retrieve the pixel data remapped to presentation values according to window center/width settings
pixels = dcm.pixels(:remap => true)
@example Retrieve the remapped pixel data while using numerical array (~twice as fast)
pixels = dcm.pixels(:remap => true, :narray => true)
|
[
"Extracts",
"the",
"Pixel",
"Data",
"values",
"in",
"an",
"ordinary",
"Ruby",
"Array",
".",
"Returns",
"nil",
"if",
"no",
"pixel",
"data",
"is",
"present",
"and",
"false",
"if",
"it",
"fails",
"to",
"retrieve",
"pixel",
"data",
"which",
"is",
"present",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/image_item.rb#L392-L417
|
22,378 |
dicom/ruby-dicom
|
lib/dicom/image_item.rb
|
DICOM.ImageItem.decode_rle
|
def decode_rle(cols, rows, string)
# FIXME: Remove cols and rows (were only added for debugging).
pixels = Array.new
# RLE header specifying the number of segments:
header = string[0...64].unpack('L*')
image_segments = Array.new
# Extracting all start and endpoints of the different segments:
header.each_index do |n|
if n == 0
# This one need no processing.
elsif n == header[0]
# It's the last one
image_segments << [header[n], -1]
break
else
image_segments << [header[n], header[n + 1] - 1]
end
end
# Iterate over each segment and extract pixel data:
image_segments.each do |range|
segment_data = Array.new
next_bytes = -1
next_multiplier = 0
# Iterate this segment's pixel string:
string[range[0]..range[1]].each_byte do |b|
if next_multiplier > 0
next_multiplier.times { segment_data << b }
next_multiplier = 0
elsif next_bytes > 0
segment_data << b
next_bytes -= 1
elsif b <= 127
next_bytes = b + 1
else
# Explaining the 257 at this point is a little bit complicate. Basically it has something
# to do with the algorithm described in the DICOM standard and that the value -1 as uint8 is 255.
# TODO: Is this architectur safe or does it only work on Intel systems???
next_multiplier = 257 - b
end
end
# Verify that the RLE decoding has executed properly:
throw "Size mismatch #{segment_data.size} != #{rows * cols}" if segment_data.size != rows * cols
pixels += segment_data
end
return pixels
end
|
ruby
|
def decode_rle(cols, rows, string)
# FIXME: Remove cols and rows (were only added for debugging).
pixels = Array.new
# RLE header specifying the number of segments:
header = string[0...64].unpack('L*')
image_segments = Array.new
# Extracting all start and endpoints of the different segments:
header.each_index do |n|
if n == 0
# This one need no processing.
elsif n == header[0]
# It's the last one
image_segments << [header[n], -1]
break
else
image_segments << [header[n], header[n + 1] - 1]
end
end
# Iterate over each segment and extract pixel data:
image_segments.each do |range|
segment_data = Array.new
next_bytes = -1
next_multiplier = 0
# Iterate this segment's pixel string:
string[range[0]..range[1]].each_byte do |b|
if next_multiplier > 0
next_multiplier.times { segment_data << b }
next_multiplier = 0
elsif next_bytes > 0
segment_data << b
next_bytes -= 1
elsif b <= 127
next_bytes = b + 1
else
# Explaining the 257 at this point is a little bit complicate. Basically it has something
# to do with the algorithm described in the DICOM standard and that the value -1 as uint8 is 255.
# TODO: Is this architectur safe or does it only work on Intel systems???
next_multiplier = 257 - b
end
end
# Verify that the RLE decoding has executed properly:
throw "Size mismatch #{segment_data.size} != #{rows * cols}" if segment_data.size != rows * cols
pixels += segment_data
end
return pixels
end
|
[
"def",
"decode_rle",
"(",
"cols",
",",
"rows",
",",
"string",
")",
"# FIXME: Remove cols and rows (were only added for debugging).",
"pixels",
"=",
"Array",
".",
"new",
"# RLE header specifying the number of segments:",
"header",
"=",
"string",
"[",
"0",
"...",
"64",
"]",
".",
"unpack",
"(",
"'L*'",
")",
"image_segments",
"=",
"Array",
".",
"new",
"# Extracting all start and endpoints of the different segments:",
"header",
".",
"each_index",
"do",
"|",
"n",
"|",
"if",
"n",
"==",
"0",
"# This one need no processing.",
"elsif",
"n",
"==",
"header",
"[",
"0",
"]",
"# It's the last one",
"image_segments",
"<<",
"[",
"header",
"[",
"n",
"]",
",",
"-",
"1",
"]",
"break",
"else",
"image_segments",
"<<",
"[",
"header",
"[",
"n",
"]",
",",
"header",
"[",
"n",
"+",
"1",
"]",
"-",
"1",
"]",
"end",
"end",
"# Iterate over each segment and extract pixel data:",
"image_segments",
".",
"each",
"do",
"|",
"range",
"|",
"segment_data",
"=",
"Array",
".",
"new",
"next_bytes",
"=",
"-",
"1",
"next_multiplier",
"=",
"0",
"# Iterate this segment's pixel string:",
"string",
"[",
"range",
"[",
"0",
"]",
"..",
"range",
"[",
"1",
"]",
"]",
".",
"each_byte",
"do",
"|",
"b",
"|",
"if",
"next_multiplier",
">",
"0",
"next_multiplier",
".",
"times",
"{",
"segment_data",
"<<",
"b",
"}",
"next_multiplier",
"=",
"0",
"elsif",
"next_bytes",
">",
"0",
"segment_data",
"<<",
"b",
"next_bytes",
"-=",
"1",
"elsif",
"b",
"<=",
"127",
"next_bytes",
"=",
"b",
"+",
"1",
"else",
"# Explaining the 257 at this point is a little bit complicate. Basically it has something",
"# to do with the algorithm described in the DICOM standard and that the value -1 as uint8 is 255.",
"# TODO: Is this architectur safe or does it only work on Intel systems???",
"next_multiplier",
"=",
"257",
"-",
"b",
"end",
"end",
"# Verify that the RLE decoding has executed properly:",
"throw",
"\"Size mismatch #{segment_data.size} != #{rows * cols}\"",
"if",
"segment_data",
".",
"size",
"!=",
"rows",
"*",
"cols",
"pixels",
"+=",
"segment_data",
"end",
"return",
"pixels",
"end"
] |
Performs a run length decoding on the input stream.
@note For details on RLE encoding, refer to the DICOM standard, PS3.5, Section 8.2.2 as well as Annex G.
@param [Integer] cols number of colums of the encoded image
@param [Integer] rows number of rows of the encoded image
@param [Integer] string the encoded pixel string
@return [Array<Integer>] the decoded pixel values
|
[
"Performs",
"a",
"run",
"length",
"decoding",
"on",
"the",
"input",
"stream",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/image_item.rb#L491-L536
|
22,379 |
dicom/ruby-dicom
|
lib/dicom/image_item.rb
|
DICOM.ImageItem.process_presentation_values
|
def process_presentation_values(pixel_data, min_allowed, max_allowed, level=nil)
# Process pixel data for presentation according to the image information in the DICOM object:
center, width, intercept, slope = window_level_values
# Have image leveling been requested?
if level
# If custom values are specified in an array, use those. If not, the default values from the DICOM object are used:
if level.is_a?(Array)
center = level[0]
width = level[1]
end
else
center, width = false, false
end
# PixelOutput = slope * pixel_values + intercept
if intercept != 0 or slope != 1
pixel_data.collect!{|x| (slope * x) + intercept}
end
# Contrast enhancement by black and white thresholding:
if center and width
low = center - width/2
high = center + width/2
pixel_data.each_index do |i|
if pixel_data[i] < low
pixel_data[i] = low
elsif pixel_data[i] > high
pixel_data[i] = high
end
end
end
# Need to introduce an offset?
min_pixel_value = pixel_data.min
if min_allowed
if min_pixel_value < min_allowed
offset = min_pixel_value.abs
pixel_data.collect!{|x| x + offset}
end
end
# Downscale pixel range?
max_pixel_value = pixel_data.max
if max_allowed
if max_pixel_value > max_allowed
factor = (max_pixel_value.to_f/max_allowed.to_f).ceil
pixel_data.collect!{|x| x / factor}
end
end
return pixel_data
end
|
ruby
|
def process_presentation_values(pixel_data, min_allowed, max_allowed, level=nil)
# Process pixel data for presentation according to the image information in the DICOM object:
center, width, intercept, slope = window_level_values
# Have image leveling been requested?
if level
# If custom values are specified in an array, use those. If not, the default values from the DICOM object are used:
if level.is_a?(Array)
center = level[0]
width = level[1]
end
else
center, width = false, false
end
# PixelOutput = slope * pixel_values + intercept
if intercept != 0 or slope != 1
pixel_data.collect!{|x| (slope * x) + intercept}
end
# Contrast enhancement by black and white thresholding:
if center and width
low = center - width/2
high = center + width/2
pixel_data.each_index do |i|
if pixel_data[i] < low
pixel_data[i] = low
elsif pixel_data[i] > high
pixel_data[i] = high
end
end
end
# Need to introduce an offset?
min_pixel_value = pixel_data.min
if min_allowed
if min_pixel_value < min_allowed
offset = min_pixel_value.abs
pixel_data.collect!{|x| x + offset}
end
end
# Downscale pixel range?
max_pixel_value = pixel_data.max
if max_allowed
if max_pixel_value > max_allowed
factor = (max_pixel_value.to_f/max_allowed.to_f).ceil
pixel_data.collect!{|x| x / factor}
end
end
return pixel_data
end
|
[
"def",
"process_presentation_values",
"(",
"pixel_data",
",",
"min_allowed",
",",
"max_allowed",
",",
"level",
"=",
"nil",
")",
"# Process pixel data for presentation according to the image information in the DICOM object:",
"center",
",",
"width",
",",
"intercept",
",",
"slope",
"=",
"window_level_values",
"# Have image leveling been requested?",
"if",
"level",
"# If custom values are specified in an array, use those. If not, the default values from the DICOM object are used:",
"if",
"level",
".",
"is_a?",
"(",
"Array",
")",
"center",
"=",
"level",
"[",
"0",
"]",
"width",
"=",
"level",
"[",
"1",
"]",
"end",
"else",
"center",
",",
"width",
"=",
"false",
",",
"false",
"end",
"# PixelOutput = slope * pixel_values + intercept",
"if",
"intercept",
"!=",
"0",
"or",
"slope",
"!=",
"1",
"pixel_data",
".",
"collect!",
"{",
"|",
"x",
"|",
"(",
"slope",
"*",
"x",
")",
"+",
"intercept",
"}",
"end",
"# Contrast enhancement by black and white thresholding:",
"if",
"center",
"and",
"width",
"low",
"=",
"center",
"-",
"width",
"/",
"2",
"high",
"=",
"center",
"+",
"width",
"/",
"2",
"pixel_data",
".",
"each_index",
"do",
"|",
"i",
"|",
"if",
"pixel_data",
"[",
"i",
"]",
"<",
"low",
"pixel_data",
"[",
"i",
"]",
"=",
"low",
"elsif",
"pixel_data",
"[",
"i",
"]",
">",
"high",
"pixel_data",
"[",
"i",
"]",
"=",
"high",
"end",
"end",
"end",
"# Need to introduce an offset?",
"min_pixel_value",
"=",
"pixel_data",
".",
"min",
"if",
"min_allowed",
"if",
"min_pixel_value",
"<",
"min_allowed",
"offset",
"=",
"min_pixel_value",
".",
"abs",
"pixel_data",
".",
"collect!",
"{",
"|",
"x",
"|",
"x",
"+",
"offset",
"}",
"end",
"end",
"# Downscale pixel range?",
"max_pixel_value",
"=",
"pixel_data",
".",
"max",
"if",
"max_allowed",
"if",
"max_pixel_value",
">",
"max_allowed",
"factor",
"=",
"(",
"max_pixel_value",
".",
"to_f",
"/",
"max_allowed",
".",
"to_f",
")",
".",
"ceil",
"pixel_data",
".",
"collect!",
"{",
"|",
"x",
"|",
"x",
"/",
"factor",
"}",
"end",
"end",
"return",
"pixel_data",
"end"
] |
Converts original pixel data values to presentation values.
@param [Array<Integer>] pixel_data an array of pixel values (integers)
@param [Integer] min_allowed the minimum value allowed in the pixel data
@param [Integer] max_allowed the maximum value allowed in the pixel data
@param [Boolean, Array<Integer>] level if true, window leveling is performed using default values from the DICOM object, or if an array ([center, width]) is specified, these custom values are used instead
@return [Array<Integer>] presentation values
|
[
"Converts",
"original",
"pixel",
"data",
"values",
"to",
"presentation",
"values",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/image_item.rb#L609-L655
|
22,380 |
dicom/ruby-dicom
|
lib/dicom/image_item.rb
|
DICOM.ImageItem.process_presentation_values_narray
|
def process_presentation_values_narray(pixel_data, min_allowed, max_allowed, level=nil)
# Process pixel data for presentation according to the image information in the DICOM object:
center, width, intercept, slope = window_level_values
# Have image leveling been requested?
if level
# If custom values are specified in an array, use those. If not, the default values from the DICOM object are used:
if level.is_a?(Array)
center = level[0]
width = level[1]
end
else
center, width = false, false
end
# Need to convert to NArray?
if pixel_data.is_a?(Array)
n_arr = Numo::NArray[*pixel_data]
else
n_arr = pixel_data
end
# Remap:
# PixelOutput = slope * pixel_values + intercept
if intercept != 0 or slope != 1
n_arr = slope * n_arr + intercept
end
# Contrast enhancement by black and white thresholding:
if center and width
low = center - width/2
high = center + width/2
n_arr[n_arr < low] = low
n_arr[n_arr > high] = high
end
# Need to introduce an offset?
min_pixel_value = n_arr.min
if min_allowed
if min_pixel_value < min_allowed
offset = min_pixel_value.abs
n_arr = n_arr + offset
end
end
# Downscale pixel range?
max_pixel_value = n_arr.max
if max_allowed
if max_pixel_value > max_allowed
factor = (max_pixel_value.to_f/max_allowed.to_f).ceil
n_arr = n_arr / factor
end
end
return n_arr
end
|
ruby
|
def process_presentation_values_narray(pixel_data, min_allowed, max_allowed, level=nil)
# Process pixel data for presentation according to the image information in the DICOM object:
center, width, intercept, slope = window_level_values
# Have image leveling been requested?
if level
# If custom values are specified in an array, use those. If not, the default values from the DICOM object are used:
if level.is_a?(Array)
center = level[0]
width = level[1]
end
else
center, width = false, false
end
# Need to convert to NArray?
if pixel_data.is_a?(Array)
n_arr = Numo::NArray[*pixel_data]
else
n_arr = pixel_data
end
# Remap:
# PixelOutput = slope * pixel_values + intercept
if intercept != 0 or slope != 1
n_arr = slope * n_arr + intercept
end
# Contrast enhancement by black and white thresholding:
if center and width
low = center - width/2
high = center + width/2
n_arr[n_arr < low] = low
n_arr[n_arr > high] = high
end
# Need to introduce an offset?
min_pixel_value = n_arr.min
if min_allowed
if min_pixel_value < min_allowed
offset = min_pixel_value.abs
n_arr = n_arr + offset
end
end
# Downscale pixel range?
max_pixel_value = n_arr.max
if max_allowed
if max_pixel_value > max_allowed
factor = (max_pixel_value.to_f/max_allowed.to_f).ceil
n_arr = n_arr / factor
end
end
return n_arr
end
|
[
"def",
"process_presentation_values_narray",
"(",
"pixel_data",
",",
"min_allowed",
",",
"max_allowed",
",",
"level",
"=",
"nil",
")",
"# Process pixel data for presentation according to the image information in the DICOM object:",
"center",
",",
"width",
",",
"intercept",
",",
"slope",
"=",
"window_level_values",
"# Have image leveling been requested?",
"if",
"level",
"# If custom values are specified in an array, use those. If not, the default values from the DICOM object are used:",
"if",
"level",
".",
"is_a?",
"(",
"Array",
")",
"center",
"=",
"level",
"[",
"0",
"]",
"width",
"=",
"level",
"[",
"1",
"]",
"end",
"else",
"center",
",",
"width",
"=",
"false",
",",
"false",
"end",
"# Need to convert to NArray?",
"if",
"pixel_data",
".",
"is_a?",
"(",
"Array",
")",
"n_arr",
"=",
"Numo",
"::",
"NArray",
"[",
"pixel_data",
"]",
"else",
"n_arr",
"=",
"pixel_data",
"end",
"# Remap:",
"# PixelOutput = slope * pixel_values + intercept",
"if",
"intercept",
"!=",
"0",
"or",
"slope",
"!=",
"1",
"n_arr",
"=",
"slope",
"*",
"n_arr",
"+",
"intercept",
"end",
"# Contrast enhancement by black and white thresholding:",
"if",
"center",
"and",
"width",
"low",
"=",
"center",
"-",
"width",
"/",
"2",
"high",
"=",
"center",
"+",
"width",
"/",
"2",
"n_arr",
"[",
"n_arr",
"<",
"low",
"]",
"=",
"low",
"n_arr",
"[",
"n_arr",
">",
"high",
"]",
"=",
"high",
"end",
"# Need to introduce an offset?",
"min_pixel_value",
"=",
"n_arr",
".",
"min",
"if",
"min_allowed",
"if",
"min_pixel_value",
"<",
"min_allowed",
"offset",
"=",
"min_pixel_value",
".",
"abs",
"n_arr",
"=",
"n_arr",
"+",
"offset",
"end",
"end",
"# Downscale pixel range?",
"max_pixel_value",
"=",
"n_arr",
".",
"max",
"if",
"max_allowed",
"if",
"max_pixel_value",
">",
"max_allowed",
"factor",
"=",
"(",
"max_pixel_value",
".",
"to_f",
"/",
"max_allowed",
".",
"to_f",
")",
".",
"ceil",
"n_arr",
"=",
"n_arr",
"/",
"factor",
"end",
"end",
"return",
"n_arr",
"end"
] |
Converts original pixel data values to presentation values, using the efficient NArray library.
@note If a Ruby Array is supplied, the method returns a one-dimensional NArray object (i.e. no columns & rows).
@note If a NArray is supplied, the NArray is returned with its original dimensions.
@param [Array<Integer>, NArray] pixel_data pixel values
@param [Integer] min_allowed the minimum value allowed in the pixel data
@param [Integer] max_allowed the maximum value allowed in the pixel data
@param [Boolean, Array<Integer>] level if true, window leveling is performed using default values from the DICOM object, or if an array ([center, width]) is specified, these custom values are used instead
@return [Array<Integer>, NArray] presentation values
|
[
"Converts",
"original",
"pixel",
"data",
"values",
"to",
"presentation",
"values",
"using",
"the",
"efficient",
"NArray",
"library",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/image_item.rb#L668-L716
|
22,381 |
dicom/ruby-dicom
|
lib/dicom/image_item.rb
|
DICOM.ImageItem.read_image
|
def read_image(pixel_data, columns, rows, options={})
raise ArgumentError, "Expected Array for pixel_data, got #{pixel_data.class}" unless pixel_data.is_a?(Array)
raise ArgumentError, "Expected Integer for columns, got #{columns.class}" unless columns.is_a?(Integer)
raise ArgumentError, "Expected Rows for columns, got #{rows.class}" unless rows.is_a?(Integer)
raise ArgumentError, "Size of pixel_data must be at least equal to columns*rows. Got #{columns}*#{rows}=#{columns*rows}, which is less than the array size #{pixel_data.length}" if columns * rows > pixel_data.length
# Remap the image from pixel values to presentation values if the user has requested this:
if options[:remap] or options[:level]
# How to perform the remapping? NArray (fast) or Ruby Array (slow)?
if options[:narray] == true
pixel_data = process_presentation_values_narray(pixel_data, 0, 65535, options[:level]).to_a
else
pixel_data = process_presentation_values(pixel_data, 0, 65535, options[:level])
end
else
# No remapping, but make sure that we pass on unsigned pixel values to the image processor:
pixel_data = pixel_data.to_unsigned(bit_depth) if signed_pixels?
end
image = import_pixels(pixel_data.to_blob(actual_bit_depth), columns, rows, actual_bit_depth, photometry)
return image
end
|
ruby
|
def read_image(pixel_data, columns, rows, options={})
raise ArgumentError, "Expected Array for pixel_data, got #{pixel_data.class}" unless pixel_data.is_a?(Array)
raise ArgumentError, "Expected Integer for columns, got #{columns.class}" unless columns.is_a?(Integer)
raise ArgumentError, "Expected Rows for columns, got #{rows.class}" unless rows.is_a?(Integer)
raise ArgumentError, "Size of pixel_data must be at least equal to columns*rows. Got #{columns}*#{rows}=#{columns*rows}, which is less than the array size #{pixel_data.length}" if columns * rows > pixel_data.length
# Remap the image from pixel values to presentation values if the user has requested this:
if options[:remap] or options[:level]
# How to perform the remapping? NArray (fast) or Ruby Array (slow)?
if options[:narray] == true
pixel_data = process_presentation_values_narray(pixel_data, 0, 65535, options[:level]).to_a
else
pixel_data = process_presentation_values(pixel_data, 0, 65535, options[:level])
end
else
# No remapping, but make sure that we pass on unsigned pixel values to the image processor:
pixel_data = pixel_data.to_unsigned(bit_depth) if signed_pixels?
end
image = import_pixels(pixel_data.to_blob(actual_bit_depth), columns, rows, actual_bit_depth, photometry)
return image
end
|
[
"def",
"read_image",
"(",
"pixel_data",
",",
"columns",
",",
"rows",
",",
"options",
"=",
"{",
"}",
")",
"raise",
"ArgumentError",
",",
"\"Expected Array for pixel_data, got #{pixel_data.class}\"",
"unless",
"pixel_data",
".",
"is_a?",
"(",
"Array",
")",
"raise",
"ArgumentError",
",",
"\"Expected Integer for columns, got #{columns.class}\"",
"unless",
"columns",
".",
"is_a?",
"(",
"Integer",
")",
"raise",
"ArgumentError",
",",
"\"Expected Rows for columns, got #{rows.class}\"",
"unless",
"rows",
".",
"is_a?",
"(",
"Integer",
")",
"raise",
"ArgumentError",
",",
"\"Size of pixel_data must be at least equal to columns*rows. Got #{columns}*#{rows}=#{columns*rows}, which is less than the array size #{pixel_data.length}\"",
"if",
"columns",
"*",
"rows",
">",
"pixel_data",
".",
"length",
"# Remap the image from pixel values to presentation values if the user has requested this:",
"if",
"options",
"[",
":remap",
"]",
"or",
"options",
"[",
":level",
"]",
"# How to perform the remapping? NArray (fast) or Ruby Array (slow)?",
"if",
"options",
"[",
":narray",
"]",
"==",
"true",
"pixel_data",
"=",
"process_presentation_values_narray",
"(",
"pixel_data",
",",
"0",
",",
"65535",
",",
"options",
"[",
":level",
"]",
")",
".",
"to_a",
"else",
"pixel_data",
"=",
"process_presentation_values",
"(",
"pixel_data",
",",
"0",
",",
"65535",
",",
"options",
"[",
":level",
"]",
")",
"end",
"else",
"# No remapping, but make sure that we pass on unsigned pixel values to the image processor:",
"pixel_data",
"=",
"pixel_data",
".",
"to_unsigned",
"(",
"bit_depth",
")",
"if",
"signed_pixels?",
"end",
"image",
"=",
"import_pixels",
"(",
"pixel_data",
".",
"to_blob",
"(",
"actual_bit_depth",
")",
",",
"columns",
",",
"rows",
",",
"actual_bit_depth",
",",
"photometry",
")",
"return",
"image",
"end"
] |
Creates an image object from the specified pixel value array, performing
presentation value processing if requested.
@note Definitions for Window Center and Width can be found in the DICOM standard, PS 3.3 C.11.2.1.2
@param [Array<Integer>] pixel_data an array of pixel values
@param [Integer] columns the number of columns in the pixel data
@param [Integer] rows the number of rows in the pixel data
@param [Hash] options the options to use for reading the image
@option options [Boolean] :remap if true, pixel values are remapped to presentation values (using intercept and slope values from the DICOM object)
@option options [Boolean, Array<Integer>] :level if true, window leveling is performed using default values from the DICOM object, or if an array ([center, width]) is specified, these custom values are used instead
@option options [Boolean] :narray if true, forces the use of NArray for the pixel remap process (for faster execution)
@return [MagickImage] the extracted image object
|
[
"Creates",
"an",
"image",
"object",
"from",
"the",
"specified",
"pixel",
"value",
"array",
"performing",
"presentation",
"value",
"processing",
"if",
"requested",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/image_item.rb#L732-L751
|
22,382 |
dicom/ruby-dicom
|
lib/dicom/image_item.rb
|
DICOM.ImageItem.window_level_values
|
def window_level_values
center = (self['0028,1050'].is_a?(Element) == true ? self['0028,1050'].value.to_i : nil)
width = (self['0028,1051'].is_a?(Element) == true ? self['0028,1051'].value.to_i : nil)
intercept = (self['0028,1052'].is_a?(Element) == true ? self['0028,1052'].value.to_i : 0)
slope = (self['0028,1053'].is_a?(Element) == true ? self['0028,1053'].value.to_i : 1)
return center, width, intercept, slope
end
|
ruby
|
def window_level_values
center = (self['0028,1050'].is_a?(Element) == true ? self['0028,1050'].value.to_i : nil)
width = (self['0028,1051'].is_a?(Element) == true ? self['0028,1051'].value.to_i : nil)
intercept = (self['0028,1052'].is_a?(Element) == true ? self['0028,1052'].value.to_i : 0)
slope = (self['0028,1053'].is_a?(Element) == true ? self['0028,1053'].value.to_i : 1)
return center, width, intercept, slope
end
|
[
"def",
"window_level_values",
"center",
"=",
"(",
"self",
"[",
"'0028,1050'",
"]",
".",
"is_a?",
"(",
"Element",
")",
"==",
"true",
"?",
"self",
"[",
"'0028,1050'",
"]",
".",
"value",
".",
"to_i",
":",
"nil",
")",
"width",
"=",
"(",
"self",
"[",
"'0028,1051'",
"]",
".",
"is_a?",
"(",
"Element",
")",
"==",
"true",
"?",
"self",
"[",
"'0028,1051'",
"]",
".",
"value",
".",
"to_i",
":",
"nil",
")",
"intercept",
"=",
"(",
"self",
"[",
"'0028,1052'",
"]",
".",
"is_a?",
"(",
"Element",
")",
"==",
"true",
"?",
"self",
"[",
"'0028,1052'",
"]",
".",
"value",
".",
"to_i",
":",
"0",
")",
"slope",
"=",
"(",
"self",
"[",
"'0028,1053'",
"]",
".",
"is_a?",
"(",
"Element",
")",
"==",
"true",
"?",
"self",
"[",
"'0028,1053'",
"]",
".",
"value",
".",
"to_i",
":",
"1",
")",
"return",
"center",
",",
"width",
",",
"intercept",
",",
"slope",
"end"
] |
Collects the window level values needed to convert the original pixel
values to presentation values.
@note If some of these values are missing in the DObject instance,
default values are used instead for intercept and slope, while center
and width are set to nil. No errors are raised.
@return [Array<Integer, NilClass>] center, width, intercept and slope
|
[
"Collects",
"the",
"window",
"level",
"values",
"needed",
"to",
"convert",
"the",
"original",
"pixel",
"values",
"to",
"presentation",
"values",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/image_item.rb#L813-L819
|
22,383 |
dicom/ruby-dicom
|
lib/dicom/image_item.rb
|
DICOM.ImageItem.write_pixels
|
def write_pixels(bin)
if self.exists?(PIXEL_TAG)
# Update existing Data Element:
self[PIXEL_TAG].bin = bin
else
# Create new Data Element:
pixel_element = Element.new(PIXEL_TAG, bin, :encoded => true, :parent => self)
end
end
|
ruby
|
def write_pixels(bin)
if self.exists?(PIXEL_TAG)
# Update existing Data Element:
self[PIXEL_TAG].bin = bin
else
# Create new Data Element:
pixel_element = Element.new(PIXEL_TAG, bin, :encoded => true, :parent => self)
end
end
|
[
"def",
"write_pixels",
"(",
"bin",
")",
"if",
"self",
".",
"exists?",
"(",
"PIXEL_TAG",
")",
"# Update existing Data Element:",
"self",
"[",
"PIXEL_TAG",
"]",
".",
"bin",
"=",
"bin",
"else",
"# Create new Data Element:",
"pixel_element",
"=",
"Element",
".",
"new",
"(",
"PIXEL_TAG",
",",
"bin",
",",
":encoded",
"=>",
"true",
",",
":parent",
"=>",
"self",
")",
"end",
"end"
] |
Transfers a pre-encoded binary string to the pixel data element, either by
overwriting the existing element value, or creating a new "Pixel Data" element.
@param [String] bin a binary string containing encoded pixel data
|
[
"Transfers",
"a",
"pre",
"-",
"encoded",
"binary",
"string",
"to",
"the",
"pixel",
"data",
"element",
"either",
"by",
"overwriting",
"the",
"existing",
"element",
"value",
"or",
"creating",
"a",
"new",
"Pixel",
"Data",
"element",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/image_item.rb#L826-L834
|
22,384 |
dicom/ruby-dicom
|
lib/dicom/d_read.rb
|
DICOM.Parent.parse
|
def parse(bin, syntax, switched=false, explicit=true)
raise ArgumentError, "Invalid argument 'bin'. Expected String, got #{bin.class}." unless bin.is_a?(String)
raise ArgumentError, "Invalid argument 'syntax'. Expected String, got #{syntax.class}." unless syntax.is_a?(String)
read(bin, signature=false, :syntax => syntax, :switched => switched, :explicit => explicit)
end
|
ruby
|
def parse(bin, syntax, switched=false, explicit=true)
raise ArgumentError, "Invalid argument 'bin'. Expected String, got #{bin.class}." unless bin.is_a?(String)
raise ArgumentError, "Invalid argument 'syntax'. Expected String, got #{syntax.class}." unless syntax.is_a?(String)
read(bin, signature=false, :syntax => syntax, :switched => switched, :explicit => explicit)
end
|
[
"def",
"parse",
"(",
"bin",
",",
"syntax",
",",
"switched",
"=",
"false",
",",
"explicit",
"=",
"true",
")",
"raise",
"ArgumentError",
",",
"\"Invalid argument 'bin'. Expected String, got #{bin.class}.\"",
"unless",
"bin",
".",
"is_a?",
"(",
"String",
")",
"raise",
"ArgumentError",
",",
"\"Invalid argument 'syntax'. Expected String, got #{syntax.class}.\"",
"unless",
"syntax",
".",
"is_a?",
"(",
"String",
")",
"read",
"(",
"bin",
",",
"signature",
"=",
"false",
",",
":syntax",
"=>",
"syntax",
",",
":switched",
"=>",
"switched",
",",
":explicit",
"=>",
"explicit",
")",
"end"
] |
Loads data from an encoded DICOM string and creates
items and elements which are linked to this instance.
@param [String] bin an encoded binary string containing DICOM information
@param [String] syntax the transfer syntax to use when decoding the DICOM string
@param [Boolean] switched indicating whether the transfer syntax 'switch' has occured in the data stream of this object
|
[
"Loads",
"data",
"from",
"an",
"encoded",
"DICOM",
"string",
"and",
"creates",
"items",
"and",
"elements",
"which",
"are",
"linked",
"to",
"this",
"instance",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_read.rb#L12-L16
|
22,385 |
dicom/ruby-dicom
|
lib/dicom/d_read.rb
|
DICOM.Parent.check_duplicate
|
def check_duplicate(tag, elemental)
if @current_parent[tag]
gp = @current_parent.parent ? "#{@current_parent.parent.representation} => " : ''
p = @current_parent.representation
logger.warn("Duplicate #{elemental} (#{tag}) detected at level: #{gp}#{p}")
end
end
|
ruby
|
def check_duplicate(tag, elemental)
if @current_parent[tag]
gp = @current_parent.parent ? "#{@current_parent.parent.representation} => " : ''
p = @current_parent.representation
logger.warn("Duplicate #{elemental} (#{tag}) detected at level: #{gp}#{p}")
end
end
|
[
"def",
"check_duplicate",
"(",
"tag",
",",
"elemental",
")",
"if",
"@current_parent",
"[",
"tag",
"]",
"gp",
"=",
"@current_parent",
".",
"parent",
"?",
"\"#{@current_parent.parent.representation} => \"",
":",
"''",
"p",
"=",
"@current_parent",
".",
"representation",
"logger",
".",
"warn",
"(",
"\"Duplicate #{elemental} (#{tag}) detected at level: #{gp}#{p}\"",
")",
"end",
"end"
] |
Checks whether the given tag is a duplicate of an existing tag with this parent.
@param [String] tag the tag of the candidate duplicate elemental
@param [String] elemental the duplicate elemental type (e.g. Sequence, Element)
|
[
"Checks",
"whether",
"the",
"given",
"tag",
"is",
"a",
"duplicate",
"of",
"an",
"existing",
"tag",
"with",
"this",
"parent",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_read.rb#L27-L33
|
22,386 |
dicom/ruby-dicom
|
lib/dicom/d_read.rb
|
DICOM.Parent.check_header
|
def check_header
# According to the official DICOM standard, a DICOM file shall contain 128 consequtive (zero) bytes,
# followed by 4 bytes that spell the string 'DICM'. Apparently, some providers seems to skip this in their DICOM files.
# Check that the string is long enough to contain a valid header:
if @str.length < 132
# This does not seem to be a valid DICOM string and so we return.
return nil
else
@stream.skip(128)
# Next 4 bytes should spell "DICM":
identifier = @stream.decode(4, "STR")
@header_length += 132
if identifier != "DICM" then
# Header signature is not valid (we will still try to parse it is a DICOM string though):
logger.warn("This string does not contain the expected DICOM header. Will try to parse the string anyway (assuming a missing header).")
# As the string is not conforming to the DICOM standard, it is possible that it does not contain a
# transfer syntax element, and as such, we attempt to choose the most probable encoding values here:
@explicit = false
return false
else
# Header signature is valid:
@signature = true
return true
end
end
end
|
ruby
|
def check_header
# According to the official DICOM standard, a DICOM file shall contain 128 consequtive (zero) bytes,
# followed by 4 bytes that spell the string 'DICM'. Apparently, some providers seems to skip this in their DICOM files.
# Check that the string is long enough to contain a valid header:
if @str.length < 132
# This does not seem to be a valid DICOM string and so we return.
return nil
else
@stream.skip(128)
# Next 4 bytes should spell "DICM":
identifier = @stream.decode(4, "STR")
@header_length += 132
if identifier != "DICM" then
# Header signature is not valid (we will still try to parse it is a DICOM string though):
logger.warn("This string does not contain the expected DICOM header. Will try to parse the string anyway (assuming a missing header).")
# As the string is not conforming to the DICOM standard, it is possible that it does not contain a
# transfer syntax element, and as such, we attempt to choose the most probable encoding values here:
@explicit = false
return false
else
# Header signature is valid:
@signature = true
return true
end
end
end
|
[
"def",
"check_header",
"# According to the official DICOM standard, a DICOM file shall contain 128 consequtive (zero) bytes,",
"# followed by 4 bytes that spell the string 'DICM'. Apparently, some providers seems to skip this in their DICOM files.",
"# Check that the string is long enough to contain a valid header:",
"if",
"@str",
".",
"length",
"<",
"132",
"# This does not seem to be a valid DICOM string and so we return.",
"return",
"nil",
"else",
"@stream",
".",
"skip",
"(",
"128",
")",
"# Next 4 bytes should spell \"DICM\":",
"identifier",
"=",
"@stream",
".",
"decode",
"(",
"4",
",",
"\"STR\"",
")",
"@header_length",
"+=",
"132",
"if",
"identifier",
"!=",
"\"DICM\"",
"then",
"# Header signature is not valid (we will still try to parse it is a DICOM string though):",
"logger",
".",
"warn",
"(",
"\"This string does not contain the expected DICOM header. Will try to parse the string anyway (assuming a missing header).\"",
")",
"# As the string is not conforming to the DICOM standard, it is possible that it does not contain a",
"# transfer syntax element, and as such, we attempt to choose the most probable encoding values here:",
"@explicit",
"=",
"false",
"return",
"false",
"else",
"# Header signature is valid:",
"@signature",
"=",
"true",
"return",
"true",
"end",
"end",
"end"
] |
Checks for the official DICOM header signature.
@return [Boolean] true if the proper signature is present, false if not, and nil if the string was shorter then the length of the DICOM signature
|
[
"Checks",
"for",
"the",
"official",
"DICOM",
"header",
"signature",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_read.rb#L39-L64
|
22,387 |
dicom/ruby-dicom
|
lib/dicom/d_read.rb
|
DICOM.Parent.process_data_element
|
def process_data_element
# FIXME: This method has grown a bit messy and isn't very pleasant to read. Cleanup possible?
# After having been into a possible unknown sequence with undefined length, we may need to reset
# explicitness from implicit to explicit:
if !@original_explicit.nil? && @explicitness_reset_parent == @current_parent
@explicit = @original_explicit
end
# STEP 1:
# Attempt to read data element tag:
tag = read_tag
# Return nil if we have (naturally) reached the end of the data string.
return nil unless tag
# STEP 2:
# Access library to retrieve the data element name and VR from the tag we just read:
# (Note: VR will be overwritten in the next step if the DICOM string contains VR (explicit encoding))
name, vr = LIBRARY.name_and_vr(tag)
# STEP 3:
# Read VR (if it exists) and the length value:
vr, length = read_vr_length(vr,tag)
level_vr = vr
# STEP 4:
# Reading value of data element.
# Special handling needed for items in encapsulated image data:
if @enc_image and tag == ITEM_TAG
# 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.
vr = "OW" # how about alternatives like OB?
# Modify name of item if this is an item that holds pixel data:
if @current_element.tag != PIXEL_TAG
name = PIXEL_ITEM_NAME
end
end
# Read the binary string of the element:
bin = read_bin(length) if length > 0
# Read the value of the element (if it contains data, and it is not a sequence or ordinary item):
if length > 0 and vr != "SQ" and tag != ITEM_TAG
# Read the element's processed value:
value = read_value(vr, length)
else
# Data element has no value (data).
value = nil
# Special case: Check if pixel data element is sequenced:
if tag == PIXEL_TAG
# Change name and vr of pixel data element if it does not contain data itself:
name = ENCAPSULATED_PIXEL_NAME
level_vr = "SQ"
@enc_image = true
end
end
# Create an Element from the gathered data:
# if vr is UN ("unknown") and length is -1, treat as a sequence (sec. 6.2.2 of DICOM standard)
if level_vr == "SQ" or tag == ITEM_TAG or (level_vr == "UN" and length == -1)
if level_vr == "SQ" or (level_vr == "UN" and length == -1)
check_duplicate(tag, 'Sequence')
# If we get an unknown sequence with undefined length, we must switch to implicit for decoding its content:
if level_vr == "UN" and length == -1
@original_explicit = @explicit
@explicit = false
@explicitness_reset_parent = @current_parent
end
unless @current_parent[tag] and !@overwrite
@current_element = Sequence.new(tag, :length => length, :name => name, :parent => @current_parent, :vr => vr)
else
# We have skipped a sequence. This means that any following children
# of this sequence must be skipped as well. We solve this by creating an 'orphaned'
# sequence that has a parent defined, but does not add itself to this parent:
@current_element = Sequence.new(tag, :length => length, :name => name, :vr => vr)
@current_element.set_parent(@current_parent)
end
elsif tag == ITEM_TAG
# Create an Item:
if @enc_image
@current_element = Item.new(:bin => bin, :length => length, :name => name, :parent => @current_parent, :vr => vr)
else
@current_element = Item.new(:length => length, :name => name, :parent => @current_parent, :vr => vr)
end
end
# Common operations on the two types of parent elements:
if length == 0 and @enc_image
# Set as parent. Exceptions when parent will not be set:
# Item/Sequence has zero length & Item is a pixel item (which contains pixels, not child elements).
@current_parent = @current_element
elsif length != 0
@current_parent = @current_element unless name == PIXEL_ITEM_NAME
end
# If length is specified (no delimitation items), load a new DRead instance to read these child elements
# and load them into the current sequence. The exception is when we have a pixel data item.
if length > 0 and not @enc_image
@current_element.parse(bin, @transfer_syntax, switched=@switched, @explicit)
@current_parent = @current_parent.parent
return false unless @read_success
end
elsif DELIMITER_TAGS.include?(tag)
# We do not create an element for the delimiter items.
# The occurance of such a tag indicates that a sequence or item has ended, and the parent must be changed:
@current_parent = @current_parent.parent
else
check_duplicate(tag, 'Element')
unless @current_parent[tag] and !@overwrite
@current_element = Element.new(tag, value, :bin => bin, :name => name, :parent => @current_parent, :vr => vr)
# Check that the data stream didn't end abruptly:
raise "The actual length of the value (#{@current_element.bin.length}) does not match its specified length (#{length}) for Data Element #{@current_element.tag}" if length != @current_element.bin.length
end
end
# Return true to indicate success:
return true
end
|
ruby
|
def process_data_element
# FIXME: This method has grown a bit messy and isn't very pleasant to read. Cleanup possible?
# After having been into a possible unknown sequence with undefined length, we may need to reset
# explicitness from implicit to explicit:
if !@original_explicit.nil? && @explicitness_reset_parent == @current_parent
@explicit = @original_explicit
end
# STEP 1:
# Attempt to read data element tag:
tag = read_tag
# Return nil if we have (naturally) reached the end of the data string.
return nil unless tag
# STEP 2:
# Access library to retrieve the data element name and VR from the tag we just read:
# (Note: VR will be overwritten in the next step if the DICOM string contains VR (explicit encoding))
name, vr = LIBRARY.name_and_vr(tag)
# STEP 3:
# Read VR (if it exists) and the length value:
vr, length = read_vr_length(vr,tag)
level_vr = vr
# STEP 4:
# Reading value of data element.
# Special handling needed for items in encapsulated image data:
if @enc_image and tag == ITEM_TAG
# 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.
vr = "OW" # how about alternatives like OB?
# Modify name of item if this is an item that holds pixel data:
if @current_element.tag != PIXEL_TAG
name = PIXEL_ITEM_NAME
end
end
# Read the binary string of the element:
bin = read_bin(length) if length > 0
# Read the value of the element (if it contains data, and it is not a sequence or ordinary item):
if length > 0 and vr != "SQ" and tag != ITEM_TAG
# Read the element's processed value:
value = read_value(vr, length)
else
# Data element has no value (data).
value = nil
# Special case: Check if pixel data element is sequenced:
if tag == PIXEL_TAG
# Change name and vr of pixel data element if it does not contain data itself:
name = ENCAPSULATED_PIXEL_NAME
level_vr = "SQ"
@enc_image = true
end
end
# Create an Element from the gathered data:
# if vr is UN ("unknown") and length is -1, treat as a sequence (sec. 6.2.2 of DICOM standard)
if level_vr == "SQ" or tag == ITEM_TAG or (level_vr == "UN" and length == -1)
if level_vr == "SQ" or (level_vr == "UN" and length == -1)
check_duplicate(tag, 'Sequence')
# If we get an unknown sequence with undefined length, we must switch to implicit for decoding its content:
if level_vr == "UN" and length == -1
@original_explicit = @explicit
@explicit = false
@explicitness_reset_parent = @current_parent
end
unless @current_parent[tag] and !@overwrite
@current_element = Sequence.new(tag, :length => length, :name => name, :parent => @current_parent, :vr => vr)
else
# We have skipped a sequence. This means that any following children
# of this sequence must be skipped as well. We solve this by creating an 'orphaned'
# sequence that has a parent defined, but does not add itself to this parent:
@current_element = Sequence.new(tag, :length => length, :name => name, :vr => vr)
@current_element.set_parent(@current_parent)
end
elsif tag == ITEM_TAG
# Create an Item:
if @enc_image
@current_element = Item.new(:bin => bin, :length => length, :name => name, :parent => @current_parent, :vr => vr)
else
@current_element = Item.new(:length => length, :name => name, :parent => @current_parent, :vr => vr)
end
end
# Common operations on the two types of parent elements:
if length == 0 and @enc_image
# Set as parent. Exceptions when parent will not be set:
# Item/Sequence has zero length & Item is a pixel item (which contains pixels, not child elements).
@current_parent = @current_element
elsif length != 0
@current_parent = @current_element unless name == PIXEL_ITEM_NAME
end
# If length is specified (no delimitation items), load a new DRead instance to read these child elements
# and load them into the current sequence. The exception is when we have a pixel data item.
if length > 0 and not @enc_image
@current_element.parse(bin, @transfer_syntax, switched=@switched, @explicit)
@current_parent = @current_parent.parent
return false unless @read_success
end
elsif DELIMITER_TAGS.include?(tag)
# We do not create an element for the delimiter items.
# The occurance of such a tag indicates that a sequence or item has ended, and the parent must be changed:
@current_parent = @current_parent.parent
else
check_duplicate(tag, 'Element')
unless @current_parent[tag] and !@overwrite
@current_element = Element.new(tag, value, :bin => bin, :name => name, :parent => @current_parent, :vr => vr)
# Check that the data stream didn't end abruptly:
raise "The actual length of the value (#{@current_element.bin.length}) does not match its specified length (#{length}) for Data Element #{@current_element.tag}" if length != @current_element.bin.length
end
end
# Return true to indicate success:
return true
end
|
[
"def",
"process_data_element",
"# FIXME: This method has grown a bit messy and isn't very pleasant to read. Cleanup possible?",
"# After having been into a possible unknown sequence with undefined length, we may need to reset",
"# explicitness from implicit to explicit:",
"if",
"!",
"@original_explicit",
".",
"nil?",
"&&",
"@explicitness_reset_parent",
"==",
"@current_parent",
"@explicit",
"=",
"@original_explicit",
"end",
"# STEP 1:",
"# Attempt to read data element tag:",
"tag",
"=",
"read_tag",
"# Return nil if we have (naturally) reached the end of the data string.",
"return",
"nil",
"unless",
"tag",
"# STEP 2:",
"# Access library to retrieve the data element name and VR from the tag we just read:",
"# (Note: VR will be overwritten in the next step if the DICOM string contains VR (explicit encoding))",
"name",
",",
"vr",
"=",
"LIBRARY",
".",
"name_and_vr",
"(",
"tag",
")",
"# STEP 3:",
"# Read VR (if it exists) and the length value:",
"vr",
",",
"length",
"=",
"read_vr_length",
"(",
"vr",
",",
"tag",
")",
"level_vr",
"=",
"vr",
"# STEP 4:",
"# Reading value of data element.",
"# Special handling needed for items in encapsulated image data:",
"if",
"@enc_image",
"and",
"tag",
"==",
"ITEM_TAG",
"# 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.",
"vr",
"=",
"\"OW\"",
"# how about alternatives like OB?",
"# Modify name of item if this is an item that holds pixel data:",
"if",
"@current_element",
".",
"tag",
"!=",
"PIXEL_TAG",
"name",
"=",
"PIXEL_ITEM_NAME",
"end",
"end",
"# Read the binary string of the element:",
"bin",
"=",
"read_bin",
"(",
"length",
")",
"if",
"length",
">",
"0",
"# Read the value of the element (if it contains data, and it is not a sequence or ordinary item):",
"if",
"length",
">",
"0",
"and",
"vr",
"!=",
"\"SQ\"",
"and",
"tag",
"!=",
"ITEM_TAG",
"# Read the element's processed value:",
"value",
"=",
"read_value",
"(",
"vr",
",",
"length",
")",
"else",
"# Data element has no value (data).",
"value",
"=",
"nil",
"# Special case: Check if pixel data element is sequenced:",
"if",
"tag",
"==",
"PIXEL_TAG",
"# Change name and vr of pixel data element if it does not contain data itself:",
"name",
"=",
"ENCAPSULATED_PIXEL_NAME",
"level_vr",
"=",
"\"SQ\"",
"@enc_image",
"=",
"true",
"end",
"end",
"# Create an Element from the gathered data:",
"# if vr is UN (\"unknown\") and length is -1, treat as a sequence (sec. 6.2.2 of DICOM standard)",
"if",
"level_vr",
"==",
"\"SQ\"",
"or",
"tag",
"==",
"ITEM_TAG",
"or",
"(",
"level_vr",
"==",
"\"UN\"",
"and",
"length",
"==",
"-",
"1",
")",
"if",
"level_vr",
"==",
"\"SQ\"",
"or",
"(",
"level_vr",
"==",
"\"UN\"",
"and",
"length",
"==",
"-",
"1",
")",
"check_duplicate",
"(",
"tag",
",",
"'Sequence'",
")",
"# If we get an unknown sequence with undefined length, we must switch to implicit for decoding its content:",
"if",
"level_vr",
"==",
"\"UN\"",
"and",
"length",
"==",
"-",
"1",
"@original_explicit",
"=",
"@explicit",
"@explicit",
"=",
"false",
"@explicitness_reset_parent",
"=",
"@current_parent",
"end",
"unless",
"@current_parent",
"[",
"tag",
"]",
"and",
"!",
"@overwrite",
"@current_element",
"=",
"Sequence",
".",
"new",
"(",
"tag",
",",
":length",
"=>",
"length",
",",
":name",
"=>",
"name",
",",
":parent",
"=>",
"@current_parent",
",",
":vr",
"=>",
"vr",
")",
"else",
"# We have skipped a sequence. This means that any following children",
"# of this sequence must be skipped as well. We solve this by creating an 'orphaned'",
"# sequence that has a parent defined, but does not add itself to this parent:",
"@current_element",
"=",
"Sequence",
".",
"new",
"(",
"tag",
",",
":length",
"=>",
"length",
",",
":name",
"=>",
"name",
",",
":vr",
"=>",
"vr",
")",
"@current_element",
".",
"set_parent",
"(",
"@current_parent",
")",
"end",
"elsif",
"tag",
"==",
"ITEM_TAG",
"# Create an Item:",
"if",
"@enc_image",
"@current_element",
"=",
"Item",
".",
"new",
"(",
":bin",
"=>",
"bin",
",",
":length",
"=>",
"length",
",",
":name",
"=>",
"name",
",",
":parent",
"=>",
"@current_parent",
",",
":vr",
"=>",
"vr",
")",
"else",
"@current_element",
"=",
"Item",
".",
"new",
"(",
":length",
"=>",
"length",
",",
":name",
"=>",
"name",
",",
":parent",
"=>",
"@current_parent",
",",
":vr",
"=>",
"vr",
")",
"end",
"end",
"# Common operations on the two types of parent elements:",
"if",
"length",
"==",
"0",
"and",
"@enc_image",
"# Set as parent. Exceptions when parent will not be set:",
"# Item/Sequence has zero length & Item is a pixel item (which contains pixels, not child elements).",
"@current_parent",
"=",
"@current_element",
"elsif",
"length",
"!=",
"0",
"@current_parent",
"=",
"@current_element",
"unless",
"name",
"==",
"PIXEL_ITEM_NAME",
"end",
"# If length is specified (no delimitation items), load a new DRead instance to read these child elements",
"# and load them into the current sequence. The exception is when we have a pixel data item.",
"if",
"length",
">",
"0",
"and",
"not",
"@enc_image",
"@current_element",
".",
"parse",
"(",
"bin",
",",
"@transfer_syntax",
",",
"switched",
"=",
"@switched",
",",
"@explicit",
")",
"@current_parent",
"=",
"@current_parent",
".",
"parent",
"return",
"false",
"unless",
"@read_success",
"end",
"elsif",
"DELIMITER_TAGS",
".",
"include?",
"(",
"tag",
")",
"# We do not create an element for the delimiter items.",
"# The occurance of such a tag indicates that a sequence or item has ended, and the parent must be changed:",
"@current_parent",
"=",
"@current_parent",
".",
"parent",
"else",
"check_duplicate",
"(",
"tag",
",",
"'Element'",
")",
"unless",
"@current_parent",
"[",
"tag",
"]",
"and",
"!",
"@overwrite",
"@current_element",
"=",
"Element",
".",
"new",
"(",
"tag",
",",
"value",
",",
":bin",
"=>",
"bin",
",",
":name",
"=>",
"name",
",",
":parent",
"=>",
"@current_parent",
",",
":vr",
"=>",
"vr",
")",
"# Check that the data stream didn't end abruptly:",
"raise",
"\"The actual length of the value (#{@current_element.bin.length}) does not match its specified length (#{length}) for Data Element #{@current_element.tag}\"",
"if",
"length",
"!=",
"@current_element",
".",
"bin",
".",
"length",
"end",
"end",
"# Return true to indicate success:",
"return",
"true",
"end"
] |
Handles the process of reading a data element from the DICOM string, and
creating an element object from the parsed data.
@return [Boolean] nil if end of string has been reached (in an expected way), false if the element parse failed, and true if an element was parsed successfully
|
[
"Handles",
"the",
"process",
"of",
"reading",
"a",
"data",
"element",
"from",
"the",
"DICOM",
"string",
"and",
"creating",
"an",
"element",
"object",
"from",
"the",
"parsed",
"data",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_read.rb#L71-L177
|
22,388 |
dicom/ruby-dicom
|
lib/dicom/d_read.rb
|
DICOM.Parent.read
|
def read(string, signature=true, options={})
# (Re)Set variables:
@str = string
@overwrite = options[:overwrite]
# Presence of the official DICOM signature:
@signature = false
# Default explicitness of start of DICOM string (if undefined it defaults to true):
@explicit = options[:explicit].nil? ? true : options[:explicit]
# Default endianness of start of DICOM string is little endian:
@str_endian = false
# A switch of endianness may occur after the initial meta group, an this needs to be monitored:
@switched_endian = false
# Explicitness of the remaining groups after the initial 0002 group:
@rest_explicit = false
# Endianness of the remaining groups after the first group:
@rest_endian = false
# When the string switch from group 0002 to a later group we will update encoding values, and this switch will keep track of that:
@switched = options[:switched] ? options[:switched] : false
# Keeping track of the data element parent status while parsing the DICOM string:
@current_parent = self
# Keeping track of what is the current data element:
@current_element = self
# Items contained under the pixel data element may contain data directly, so we need a variable to keep track of this:
@enc_image = false
# Assume header size is zero bytes until otherwise is determined:
@header_length = 0
# Assume string will be read successfully and toggle it later if we experience otherwise:
@read_success = true
# Our encoding instance:
@stream = Stream.new(@str, @str_endian)
# If a transfer syntax has been specified as an option for a DICOM object,
# make sure that it makes it into the object:
if options[:syntax]
@transfer_syntax = options[:syntax]
Element.new("0002,0010", options[:syntax], :parent => self) if self.is_a?(DObject)
end
# Check for header information if indicated:
if signature
# Read and verify the DICOM header:
header = check_header
# If the string is without the expected header, we will attempt
# to read data elements from the very start of the string:
if header == false
@stream.skip(-132)
elsif header.nil?
# Not a valid DICOM string, return:
@read_success = false
return
end
end
# Run a loop which parses Data Elements, one by one, until the end of the data string is reached:
data_element = true
while data_element do
# Using a rescue clause since processing Data Elements can cause errors when parsing an invalid DICOM string.
begin
# Extracting Data element information (nil is returned if end of the string is encountered in a normal way).
data_element = process_data_element
rescue Exception => msg
# The parse algorithm crashed. Set data_element as false to break
# the loop and toggle the success boolean to indicate failure.
@read_success = false
data_element = false
# Output the raised message as a warning:
logger.warn(msg.to_s)
# Ouput the backtrace as debug information:
logger.debug(msg.backtrace)
# Explain the failure as an error:
logger.error("Parsing a Data Element has failed. This is likely caused by an invalid DICOM encoding.")
end
end
end
|
ruby
|
def read(string, signature=true, options={})
# (Re)Set variables:
@str = string
@overwrite = options[:overwrite]
# Presence of the official DICOM signature:
@signature = false
# Default explicitness of start of DICOM string (if undefined it defaults to true):
@explicit = options[:explicit].nil? ? true : options[:explicit]
# Default endianness of start of DICOM string is little endian:
@str_endian = false
# A switch of endianness may occur after the initial meta group, an this needs to be monitored:
@switched_endian = false
# Explicitness of the remaining groups after the initial 0002 group:
@rest_explicit = false
# Endianness of the remaining groups after the first group:
@rest_endian = false
# When the string switch from group 0002 to a later group we will update encoding values, and this switch will keep track of that:
@switched = options[:switched] ? options[:switched] : false
# Keeping track of the data element parent status while parsing the DICOM string:
@current_parent = self
# Keeping track of what is the current data element:
@current_element = self
# Items contained under the pixel data element may contain data directly, so we need a variable to keep track of this:
@enc_image = false
# Assume header size is zero bytes until otherwise is determined:
@header_length = 0
# Assume string will be read successfully and toggle it later if we experience otherwise:
@read_success = true
# Our encoding instance:
@stream = Stream.new(@str, @str_endian)
# If a transfer syntax has been specified as an option for a DICOM object,
# make sure that it makes it into the object:
if options[:syntax]
@transfer_syntax = options[:syntax]
Element.new("0002,0010", options[:syntax], :parent => self) if self.is_a?(DObject)
end
# Check for header information if indicated:
if signature
# Read and verify the DICOM header:
header = check_header
# If the string is without the expected header, we will attempt
# to read data elements from the very start of the string:
if header == false
@stream.skip(-132)
elsif header.nil?
# Not a valid DICOM string, return:
@read_success = false
return
end
end
# Run a loop which parses Data Elements, one by one, until the end of the data string is reached:
data_element = true
while data_element do
# Using a rescue clause since processing Data Elements can cause errors when parsing an invalid DICOM string.
begin
# Extracting Data element information (nil is returned if end of the string is encountered in a normal way).
data_element = process_data_element
rescue Exception => msg
# The parse algorithm crashed. Set data_element as false to break
# the loop and toggle the success boolean to indicate failure.
@read_success = false
data_element = false
# Output the raised message as a warning:
logger.warn(msg.to_s)
# Ouput the backtrace as debug information:
logger.debug(msg.backtrace)
# Explain the failure as an error:
logger.error("Parsing a Data Element has failed. This is likely caused by an invalid DICOM encoding.")
end
end
end
|
[
"def",
"read",
"(",
"string",
",",
"signature",
"=",
"true",
",",
"options",
"=",
"{",
"}",
")",
"# (Re)Set variables:",
"@str",
"=",
"string",
"@overwrite",
"=",
"options",
"[",
":overwrite",
"]",
"# Presence of the official DICOM signature:",
"@signature",
"=",
"false",
"# Default explicitness of start of DICOM string (if undefined it defaults to true):",
"@explicit",
"=",
"options",
"[",
":explicit",
"]",
".",
"nil?",
"?",
"true",
":",
"options",
"[",
":explicit",
"]",
"# Default endianness of start of DICOM string is little endian:",
"@str_endian",
"=",
"false",
"# A switch of endianness may occur after the initial meta group, an this needs to be monitored:",
"@switched_endian",
"=",
"false",
"# Explicitness of the remaining groups after the initial 0002 group:",
"@rest_explicit",
"=",
"false",
"# Endianness of the remaining groups after the first group:",
"@rest_endian",
"=",
"false",
"# When the string switch from group 0002 to a later group we will update encoding values, and this switch will keep track of that:",
"@switched",
"=",
"options",
"[",
":switched",
"]",
"?",
"options",
"[",
":switched",
"]",
":",
"false",
"# Keeping track of the data element parent status while parsing the DICOM string:",
"@current_parent",
"=",
"self",
"# Keeping track of what is the current data element:",
"@current_element",
"=",
"self",
"# Items contained under the pixel data element may contain data directly, so we need a variable to keep track of this:",
"@enc_image",
"=",
"false",
"# Assume header size is zero bytes until otherwise is determined:",
"@header_length",
"=",
"0",
"# Assume string will be read successfully and toggle it later if we experience otherwise:",
"@read_success",
"=",
"true",
"# Our encoding instance:",
"@stream",
"=",
"Stream",
".",
"new",
"(",
"@str",
",",
"@str_endian",
")",
"# If a transfer syntax has been specified as an option for a DICOM object,",
"# make sure that it makes it into the object:",
"if",
"options",
"[",
":syntax",
"]",
"@transfer_syntax",
"=",
"options",
"[",
":syntax",
"]",
"Element",
".",
"new",
"(",
"\"0002,0010\"",
",",
"options",
"[",
":syntax",
"]",
",",
":parent",
"=>",
"self",
")",
"if",
"self",
".",
"is_a?",
"(",
"DObject",
")",
"end",
"# Check for header information if indicated:",
"if",
"signature",
"# Read and verify the DICOM header:",
"header",
"=",
"check_header",
"# If the string is without the expected header, we will attempt",
"# to read data elements from the very start of the string:",
"if",
"header",
"==",
"false",
"@stream",
".",
"skip",
"(",
"-",
"132",
")",
"elsif",
"header",
".",
"nil?",
"# Not a valid DICOM string, return:",
"@read_success",
"=",
"false",
"return",
"end",
"end",
"# Run a loop which parses Data Elements, one by one, until the end of the data string is reached:",
"data_element",
"=",
"true",
"while",
"data_element",
"do",
"# Using a rescue clause since processing Data Elements can cause errors when parsing an invalid DICOM string.",
"begin",
"# Extracting Data element information (nil is returned if end of the string is encountered in a normal way).",
"data_element",
"=",
"process_data_element",
"rescue",
"Exception",
"=>",
"msg",
"# The parse algorithm crashed. Set data_element as false to break",
"# the loop and toggle the success boolean to indicate failure.",
"@read_success",
"=",
"false",
"data_element",
"=",
"false",
"# Output the raised message as a warning:",
"logger",
".",
"warn",
"(",
"msg",
".",
"to_s",
")",
"# Ouput the backtrace as debug information:",
"logger",
".",
"debug",
"(",
"msg",
".",
"backtrace",
")",
"# Explain the failure as an error:",
"logger",
".",
"error",
"(",
"\"Parsing a Data Element has failed. This is likely caused by an invalid DICOM encoding.\"",
")",
"end",
"end",
"end"
] |
Builds a DICOM object by parsing an encoded DICOM string.
@param [String] string a binary DICOM string to be parsed
@param [Boolean] signature if true (default), the parsing algorithm will look for the DICOM header signature
@param [Hash] options the options to use for parsing the DICOM string
@option options [Boolean] :overwrite for the rare case of a DICOM file containing duplicate elements, setting this as true instructs the parsing algorithm to overwrite the original element with duplicates
@option options [String] :syntax if a syntax string is specified, the parsing algorithm is forced to use this transfer syntax when decoding the string
|
[
"Builds",
"a",
"DICOM",
"object",
"by",
"parsing",
"an",
"encoded",
"DICOM",
"string",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_read.rb#L187-L257
|
22,389 |
dicom/ruby-dicom
|
lib/dicom/d_write.rb
|
DICOM.Parent.add_with_segmentation
|
def add_with_segmentation(string)
# As the encoded DICOM string will be cut in multiple, smaller pieces, we need to monitor the length of our encoded strings:
if (string.length + @stream.length) > @max_size
split_and_add(string)
elsif (30 + @stream.length) > @max_size
# End the current segment, and start on a new segment for this string.
@segments << @stream.export
@stream.add_last(string)
else
# We are nowhere near the limit, simply add the string:
@stream.add_last(string)
end
end
|
ruby
|
def add_with_segmentation(string)
# As the encoded DICOM string will be cut in multiple, smaller pieces, we need to monitor the length of our encoded strings:
if (string.length + @stream.length) > @max_size
split_and_add(string)
elsif (30 + @stream.length) > @max_size
# End the current segment, and start on a new segment for this string.
@segments << @stream.export
@stream.add_last(string)
else
# We are nowhere near the limit, simply add the string:
@stream.add_last(string)
end
end
|
[
"def",
"add_with_segmentation",
"(",
"string",
")",
"# As the encoded DICOM string will be cut in multiple, smaller pieces, we need to monitor the length of our encoded strings:",
"if",
"(",
"string",
".",
"length",
"+",
"@stream",
".",
"length",
")",
">",
"@max_size",
"split_and_add",
"(",
"string",
")",
"elsif",
"(",
"30",
"+",
"@stream",
".",
"length",
")",
">",
"@max_size",
"# End the current segment, and start on a new segment for this string.",
"@segments",
"<<",
"@stream",
".",
"export",
"@stream",
".",
"add_last",
"(",
"string",
")",
"else",
"# We are nowhere near the limit, simply add the string:",
"@stream",
".",
"add_last",
"(",
"string",
")",
"end",
"end"
] |
Adds an encoded string to the output stream, while keeping track of the
accumulated size of the output stream, splitting it up as necessary, and
transferring the encoded string fragments to an array.
@param [String] string a pre-encoded string
|
[
"Adds",
"an",
"encoded",
"string",
"to",
"the",
"output",
"stream",
"while",
"keeping",
"track",
"of",
"the",
"accumulated",
"size",
"of",
"the",
"output",
"stream",
"splitting",
"it",
"up",
"as",
"necessary",
"and",
"transferring",
"the",
"encoded",
"string",
"fragments",
"to",
"an",
"array",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_write.rb#L31-L43
|
22,390 |
dicom/ruby-dicom
|
lib/dicom/d_write.rb
|
DICOM.Parent.check_encapsulated_image
|
def check_encapsulated_image(element)
# If DICOM object contains encapsulated pixel data, we need some special handling for its items:
if element.tag == PIXEL_TAG and element.parent.is_a?(DObject)
@enc_image = true if element.length <= 0
end
end
|
ruby
|
def check_encapsulated_image(element)
# If DICOM object contains encapsulated pixel data, we need some special handling for its items:
if element.tag == PIXEL_TAG and element.parent.is_a?(DObject)
@enc_image = true if element.length <= 0
end
end
|
[
"def",
"check_encapsulated_image",
"(",
"element",
")",
"# If DICOM object contains encapsulated pixel data, we need some special handling for its items:",
"if",
"element",
".",
"tag",
"==",
"PIXEL_TAG",
"and",
"element",
".",
"parent",
".",
"is_a?",
"(",
"DObject",
")",
"@enc_image",
"=",
"true",
"if",
"element",
".",
"length",
"<=",
"0",
"end",
"end"
] |
Toggles the status for enclosed pixel data.
@param [Element, Item, Sequence] element a data element
|
[
"Toggles",
"the",
"status",
"for",
"enclosed",
"pixel",
"data",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_write.rb#L49-L54
|
22,391 |
dicom/ruby-dicom
|
lib/dicom/d_write.rb
|
DICOM.Parent.encode_in_segments
|
def encode_in_segments(max_size, options={})
@max_size = max_size
@transfer_syntax = options[:syntax]
# Until a DICOM write has completed successfully the status is 'unsuccessful':
@write_success = false
# Default explicitness of start of DICOM file:
@explicit = true
# Default endianness of start of DICOM files (little endian):
@str_endian = false
# When the file switch from group 0002 to a later group we will update encoding values, and this switch will keep track of that:
@switched = false
# Items contained under the Pixel Data element needs some special attention to write correctly:
@enc_image = false
# Create a Stream instance to handle the encoding of content to a binary string:
@stream = Stream.new(nil, @str_endian)
@segments = Array.new
write_data_elements(children)
# Extract the remaining string in our stream instance to our array of strings:
@segments << @stream.export
# Mark this write session as successful:
@write_success = true
return @segments
end
|
ruby
|
def encode_in_segments(max_size, options={})
@max_size = max_size
@transfer_syntax = options[:syntax]
# Until a DICOM write has completed successfully the status is 'unsuccessful':
@write_success = false
# Default explicitness of start of DICOM file:
@explicit = true
# Default endianness of start of DICOM files (little endian):
@str_endian = false
# When the file switch from group 0002 to a later group we will update encoding values, and this switch will keep track of that:
@switched = false
# Items contained under the Pixel Data element needs some special attention to write correctly:
@enc_image = false
# Create a Stream instance to handle the encoding of content to a binary string:
@stream = Stream.new(nil, @str_endian)
@segments = Array.new
write_data_elements(children)
# Extract the remaining string in our stream instance to our array of strings:
@segments << @stream.export
# Mark this write session as successful:
@write_success = true
return @segments
end
|
[
"def",
"encode_in_segments",
"(",
"max_size",
",",
"options",
"=",
"{",
"}",
")",
"@max_size",
"=",
"max_size",
"@transfer_syntax",
"=",
"options",
"[",
":syntax",
"]",
"# Until a DICOM write has completed successfully the status is 'unsuccessful':",
"@write_success",
"=",
"false",
"# Default explicitness of start of DICOM file:",
"@explicit",
"=",
"true",
"# Default endianness of start of DICOM files (little endian):",
"@str_endian",
"=",
"false",
"# When the file switch from group 0002 to a later group we will update encoding values, and this switch will keep track of that:",
"@switched",
"=",
"false",
"# Items contained under the Pixel Data element needs some special attention to write correctly:",
"@enc_image",
"=",
"false",
"# Create a Stream instance to handle the encoding of content to a binary string:",
"@stream",
"=",
"Stream",
".",
"new",
"(",
"nil",
",",
"@str_endian",
")",
"@segments",
"=",
"Array",
".",
"new",
"write_data_elements",
"(",
"children",
")",
"# Extract the remaining string in our stream instance to our array of strings:",
"@segments",
"<<",
"@stream",
".",
"export",
"# Mark this write session as successful:",
"@write_success",
"=",
"true",
"return",
"@segments",
"end"
] |
Writes DICOM content to a series of size-limited binary strings, which is returned in an array.
This is typically used in preparation of transmitting DICOM objects through network connections.
@param [Integer] max_size the maximum segment string length
@param [Hash] options the options to use for encoding the DICOM strings
@option options [String] :syntax the transfer syntax used for the encoding settings of the post-meta part of the DICOM string
@return [Array<String>] the encoded DICOM strings
|
[
"Writes",
"DICOM",
"content",
"to",
"a",
"series",
"of",
"size",
"-",
"limited",
"binary",
"strings",
"which",
"is",
"returned",
"in",
"an",
"array",
".",
"This",
"is",
"typically",
"used",
"in",
"preparation",
"of",
"transmitting",
"DICOM",
"objects",
"through",
"network",
"connections",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_write.rb#L64-L86
|
22,392 |
dicom/ruby-dicom
|
lib/dicom/d_write.rb
|
DICOM.Parent.split_and_add
|
def split_and_add(string)
# Duplicate the string as not to ruin the binary of the data element with our slicing:
segment = string.dup
append = segment.slice!(0, @[email protected])
# Clear out the stream along with a small part of the string:
@segments << @stream.export + append
if (30 + segment.length) > @max_size
# The remaining part of the string is bigger than the max limit, fill up more segments:
# How many full segments will this string fill?
number = (segment.length/@max_size.to_f).floor
start_index = 0
number.times {
@segments << segment.slice(start_index, @max_size)
start_index += @max_size
}
# The remaining part is added to the stream:
@stream.add_last(segment.slice(start_index, segment.length - start_index))
else
# The rest of the string is small enough that it can be added to the stream:
@stream.add_last(segment)
end
end
|
ruby
|
def split_and_add(string)
# Duplicate the string as not to ruin the binary of the data element with our slicing:
segment = string.dup
append = segment.slice!(0, @[email protected])
# Clear out the stream along with a small part of the string:
@segments << @stream.export + append
if (30 + segment.length) > @max_size
# The remaining part of the string is bigger than the max limit, fill up more segments:
# How many full segments will this string fill?
number = (segment.length/@max_size.to_f).floor
start_index = 0
number.times {
@segments << segment.slice(start_index, @max_size)
start_index += @max_size
}
# The remaining part is added to the stream:
@stream.add_last(segment.slice(start_index, segment.length - start_index))
else
# The rest of the string is small enough that it can be added to the stream:
@stream.add_last(segment)
end
end
|
[
"def",
"split_and_add",
"(",
"string",
")",
"# Duplicate the string as not to ruin the binary of the data element with our slicing:",
"segment",
"=",
"string",
".",
"dup",
"append",
"=",
"segment",
".",
"slice!",
"(",
"0",
",",
"@max_size",
"-",
"@stream",
".",
"length",
")",
"# Clear out the stream along with a small part of the string:",
"@segments",
"<<",
"@stream",
".",
"export",
"+",
"append",
"if",
"(",
"30",
"+",
"segment",
".",
"length",
")",
">",
"@max_size",
"# The remaining part of the string is bigger than the max limit, fill up more segments:",
"# How many full segments will this string fill?",
"number",
"=",
"(",
"segment",
".",
"length",
"/",
"@max_size",
".",
"to_f",
")",
".",
"floor",
"start_index",
"=",
"0",
"number",
".",
"times",
"{",
"@segments",
"<<",
"segment",
".",
"slice",
"(",
"start_index",
",",
"@max_size",
")",
"start_index",
"+=",
"@max_size",
"}",
"# The remaining part is added to the stream:",
"@stream",
".",
"add_last",
"(",
"segment",
".",
"slice",
"(",
"start_index",
",",
"segment",
".",
"length",
"-",
"start_index",
")",
")",
"else",
"# The rest of the string is small enough that it can be added to the stream:",
"@stream",
".",
"add_last",
"(",
"segment",
")",
"end",
"end"
] |
Splits a pre-encoded string in parts and adds it to the segments instance
array.
@param [String] string a pre-encoded string
|
[
"Splits",
"a",
"pre",
"-",
"encoded",
"string",
"in",
"parts",
"and",
"adds",
"it",
"to",
"the",
"segments",
"instance",
"array",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_write.rb#L127-L148
|
22,393 |
dicom/ruby-dicom
|
lib/dicom/d_write.rb
|
DICOM.Parent.write_data_element
|
def write_data_element(element)
# Step 1: Write tag:
write_tag(element.tag)
# Step 2: Write [VR] and value length:
write_vr_length(element.tag, element.vr, element.length)
# Step 3: Write value (Insert the already encoded binary string):
write_value(element.bin)
check_encapsulated_image(element)
end
|
ruby
|
def write_data_element(element)
# Step 1: Write tag:
write_tag(element.tag)
# Step 2: Write [VR] and value length:
write_vr_length(element.tag, element.vr, element.length)
# Step 3: Write value (Insert the already encoded binary string):
write_value(element.bin)
check_encapsulated_image(element)
end
|
[
"def",
"write_data_element",
"(",
"element",
")",
"# Step 1: Write tag:",
"write_tag",
"(",
"element",
".",
"tag",
")",
"# Step 2: Write [VR] and value length:",
"write_vr_length",
"(",
"element",
".",
"tag",
",",
"element",
".",
"vr",
",",
"element",
".",
"length",
")",
"# Step 3: Write value (Insert the already encoded binary string):",
"write_value",
"(",
"element",
".",
"bin",
")",
"check_encapsulated_image",
"(",
"element",
")",
"end"
] |
Encodes and writes a single data element.
@param [Element, Item, Sequence] element a data element
|
[
"Encodes",
"and",
"writes",
"a",
"single",
"data",
"element",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_write.rb#L154-L162
|
22,394 |
dicom/ruby-dicom
|
lib/dicom/d_write.rb
|
DICOM.Parent.write_delimiter
|
def write_delimiter(element)
delimiter_tag = (element.tag == ITEM_TAG ? ITEM_DELIMITER : SEQUENCE_DELIMITER)
write_tag(delimiter_tag)
write_vr_length(delimiter_tag, ITEM_VR, 0)
end
|
ruby
|
def write_delimiter(element)
delimiter_tag = (element.tag == ITEM_TAG ? ITEM_DELIMITER : SEQUENCE_DELIMITER)
write_tag(delimiter_tag)
write_vr_length(delimiter_tag, ITEM_VR, 0)
end
|
[
"def",
"write_delimiter",
"(",
"element",
")",
"delimiter_tag",
"=",
"(",
"element",
".",
"tag",
"==",
"ITEM_TAG",
"?",
"ITEM_DELIMITER",
":",
"SEQUENCE_DELIMITER",
")",
"write_tag",
"(",
"delimiter_tag",
")",
"write_vr_length",
"(",
"delimiter_tag",
",",
"ITEM_VR",
",",
"0",
")",
"end"
] |
Encodes and writes an Item or Sequence delimiter.
@param [Item, Sequence] element a parent element
|
[
"Encodes",
"and",
"writes",
"an",
"Item",
"or",
"Sequence",
"delimiter",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_write.rb#L212-L216
|
22,395 |
dicom/ruby-dicom
|
lib/dicom/d_write.rb
|
DICOM.Parent.write_elements
|
def write_elements(options={})
# Check if we are able to create given file:
open_file(options[:file_name])
# Go ahead and write if the file was opened successfully:
if @file
# Initiate necessary variables:
@transfer_syntax = options[:syntax]
# Until a DICOM write has completed successfully the status is 'unsuccessful':
@write_success = false
# Default explicitness of start of DICOM file:
@explicit = true
# Default endianness of start of DICOM files (little endian):
@str_endian = false
# When the file switch from group 0002 to a later group we will update encoding values, and this switch will keep track of that:
@switched = false
# Items contained under the Pixel Data element needs some special attention to write correctly:
@enc_image = false
# Create a Stream instance to handle the encoding of content to a binary string:
@stream = Stream.new(nil, @str_endian)
# Tell the Stream instance which file to write to:
@stream.set_file(@file)
# Write the DICOM signature:
write_signature if options[:signature]
write_data_elements(children)
# As file has been written successfully, it can be closed.
@file.close
# Mark this write session as successful:
@write_success = true
end
end
|
ruby
|
def write_elements(options={})
# Check if we are able to create given file:
open_file(options[:file_name])
# Go ahead and write if the file was opened successfully:
if @file
# Initiate necessary variables:
@transfer_syntax = options[:syntax]
# Until a DICOM write has completed successfully the status is 'unsuccessful':
@write_success = false
# Default explicitness of start of DICOM file:
@explicit = true
# Default endianness of start of DICOM files (little endian):
@str_endian = false
# When the file switch from group 0002 to a later group we will update encoding values, and this switch will keep track of that:
@switched = false
# Items contained under the Pixel Data element needs some special attention to write correctly:
@enc_image = false
# Create a Stream instance to handle the encoding of content to a binary string:
@stream = Stream.new(nil, @str_endian)
# Tell the Stream instance which file to write to:
@stream.set_file(@file)
# Write the DICOM signature:
write_signature if options[:signature]
write_data_elements(children)
# As file has been written successfully, it can be closed.
@file.close
# Mark this write session as successful:
@write_success = true
end
end
|
[
"def",
"write_elements",
"(",
"options",
"=",
"{",
"}",
")",
"# Check if we are able to create given file:",
"open_file",
"(",
"options",
"[",
":file_name",
"]",
")",
"# Go ahead and write if the file was opened successfully:",
"if",
"@file",
"# Initiate necessary variables:",
"@transfer_syntax",
"=",
"options",
"[",
":syntax",
"]",
"# Until a DICOM write has completed successfully the status is 'unsuccessful':",
"@write_success",
"=",
"false",
"# Default explicitness of start of DICOM file:",
"@explicit",
"=",
"true",
"# Default endianness of start of DICOM files (little endian):",
"@str_endian",
"=",
"false",
"# When the file switch from group 0002 to a later group we will update encoding values, and this switch will keep track of that:",
"@switched",
"=",
"false",
"# Items contained under the Pixel Data element needs some special attention to write correctly:",
"@enc_image",
"=",
"false",
"# Create a Stream instance to handle the encoding of content to a binary string:",
"@stream",
"=",
"Stream",
".",
"new",
"(",
"nil",
",",
"@str_endian",
")",
"# Tell the Stream instance which file to write to:",
"@stream",
".",
"set_file",
"(",
"@file",
")",
"# Write the DICOM signature:",
"write_signature",
"if",
"options",
"[",
":signature",
"]",
"write_data_elements",
"(",
"children",
")",
"# As file has been written successfully, it can be closed.",
"@file",
".",
"close",
"# Mark this write session as successful:",
"@write_success",
"=",
"true",
"end",
"end"
] |
Handles the encoding of DICOM information to string as well as writing it to file.
@param [Hash] options the options to use for encoding the DICOM string
@option options [String] :file_name the path & name of the DICOM file which is to be written to disk
@option options [Boolean] :signature if true, the 128 byte preamble and 'DICM' signature is prepended to the encoded string
@option options [String] :syntax the transfer syntax used for the encoding settings of the post-meta part of the DICOM string
|
[
"Handles",
"the",
"encoding",
"of",
"DICOM",
"information",
"to",
"string",
"as",
"well",
"as",
"writing",
"it",
"to",
"file",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_write.rb#L225-L254
|
22,396 |
dicom/ruby-dicom
|
lib/dicom/elemental.rb
|
DICOM.Elemental.stream
|
def stream
if top_parent.is_a?(DObject)
return top_parent.stream
else
return Stream.new(nil, file_endian=false)
end
end
|
ruby
|
def stream
if top_parent.is_a?(DObject)
return top_parent.stream
else
return Stream.new(nil, file_endian=false)
end
end
|
[
"def",
"stream",
"if",
"top_parent",
".",
"is_a?",
"(",
"DObject",
")",
"return",
"top_parent",
".",
"stream",
"else",
"return",
"Stream",
".",
"new",
"(",
"nil",
",",
"file_endian",
"=",
"false",
")",
"end",
"end"
] |
Returns a Stream instance which can be used for encoding a value to binary.
@note Retrieves the Stream instance of the top parent DObject instance.
If this fails, a new Stream instance is created (with little endian encoding assumed).
|
[
"Returns",
"a",
"Stream",
"instance",
"which",
"can",
"be",
"used",
"for",
"encoding",
"a",
"value",
"to",
"binary",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/elemental.rb#L93-L99
|
22,397 |
dicom/ruby-dicom
|
lib/dicom/d_library.rb
|
DICOM.DLibrary.add_element
|
def add_element(element)
raise ArgumentError, "Invalid argument 'element'. Expected DictionaryElement, got #{element.class}" unless element.is_a?(DictionaryElement)
# We store the elements in a hash with tag as key and the element instance as value:
@elements[element.tag] = element
# Populate the method conversion hashes with element data:
method = element.name.to_element_method
@methods_from_names[element.name] = method
@names_from_methods[method] = element.name
end
|
ruby
|
def add_element(element)
raise ArgumentError, "Invalid argument 'element'. Expected DictionaryElement, got #{element.class}" unless element.is_a?(DictionaryElement)
# We store the elements in a hash with tag as key and the element instance as value:
@elements[element.tag] = element
# Populate the method conversion hashes with element data:
method = element.name.to_element_method
@methods_from_names[element.name] = method
@names_from_methods[method] = element.name
end
|
[
"def",
"add_element",
"(",
"element",
")",
"raise",
"ArgumentError",
",",
"\"Invalid argument 'element'. Expected DictionaryElement, got #{element.class}\"",
"unless",
"element",
".",
"is_a?",
"(",
"DictionaryElement",
")",
"# We store the elements in a hash with tag as key and the element instance as value:",
"@elements",
"[",
"element",
".",
"tag",
"]",
"=",
"element",
"# Populate the method conversion hashes with element data:",
"method",
"=",
"element",
".",
"name",
".",
"to_element_method",
"@methods_from_names",
"[",
"element",
".",
"name",
"]",
"=",
"method",
"@names_from_methods",
"[",
"method",
"]",
"=",
"element",
".",
"name",
"end"
] |
Creates a DLibrary instance.
Adds a custom DictionaryElement to the ruby-dicom element dictionary.
@param [DictionaryElement] element the custom dictionary element to be added
|
[
"Creates",
"a",
"DLibrary",
"instance",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_library.rb#L40-L48
|
22,398 |
dicom/ruby-dicom
|
lib/dicom/d_library.rb
|
DICOM.DLibrary.add_element_dictionary
|
def add_element_dictionary(file)
File.open(file, :encoding => 'utf-8').each do |record|
fields = record.split("\t")
add_element(DictionaryElement.new(fields[0], fields[1], fields[2].split(","), fields[3].rstrip, fields[4].rstrip))
end
end
|
ruby
|
def add_element_dictionary(file)
File.open(file, :encoding => 'utf-8').each do |record|
fields = record.split("\t")
add_element(DictionaryElement.new(fields[0], fields[1], fields[2].split(","), fields[3].rstrip, fields[4].rstrip))
end
end
|
[
"def",
"add_element_dictionary",
"(",
"file",
")",
"File",
".",
"open",
"(",
"file",
",",
":encoding",
"=>",
"'utf-8'",
")",
".",
"each",
"do",
"|",
"record",
"|",
"fields",
"=",
"record",
".",
"split",
"(",
"\"\\t\"",
")",
"add_element",
"(",
"DictionaryElement",
".",
"new",
"(",
"fields",
"[",
"0",
"]",
",",
"fields",
"[",
"1",
"]",
",",
"fields",
"[",
"2",
"]",
".",
"split",
"(",
"\",\"",
")",
",",
"fields",
"[",
"3",
"]",
".",
"rstrip",
",",
"fields",
"[",
"4",
"]",
".",
"rstrip",
")",
")",
"end",
"end"
] |
Adds a custom dictionary file to the ruby-dicom element dictionary.
@note The format of the dictionary is a tab-separated text file with 5 columns:
* Tag, Name, VR, VM & Retired status
* For samples check out ruby-dicom's element dictionaries in the git repository
@param [String] file the path to the dictionary file to be added
|
[
"Adds",
"a",
"custom",
"dictionary",
"file",
"to",
"the",
"ruby",
"-",
"dicom",
"element",
"dictionary",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_library.rb#L57-L62
|
22,399 |
dicom/ruby-dicom
|
lib/dicom/d_library.rb
|
DICOM.DLibrary.add_uid_dictionary
|
def add_uid_dictionary(file)
File.open(file, :encoding => 'utf-8').each do |record|
fields = record.split("\t")
add_uid(UID.new(fields[0], fields[1], fields[2].rstrip, fields[3].rstrip))
end
end
|
ruby
|
def add_uid_dictionary(file)
File.open(file, :encoding => 'utf-8').each do |record|
fields = record.split("\t")
add_uid(UID.new(fields[0], fields[1], fields[2].rstrip, fields[3].rstrip))
end
end
|
[
"def",
"add_uid_dictionary",
"(",
"file",
")",
"File",
".",
"open",
"(",
"file",
",",
":encoding",
"=>",
"'utf-8'",
")",
".",
"each",
"do",
"|",
"record",
"|",
"fields",
"=",
"record",
".",
"split",
"(",
"\"\\t\"",
")",
"add_uid",
"(",
"UID",
".",
"new",
"(",
"fields",
"[",
"0",
"]",
",",
"fields",
"[",
"1",
"]",
",",
"fields",
"[",
"2",
"]",
".",
"rstrip",
",",
"fields",
"[",
"3",
"]",
".",
"rstrip",
")",
")",
"end",
"end"
] |
Adds a custom dictionary file to the ruby-dicom uid dictionary.
@note The format of the dictionary is a tab-separated text file with 4 columns:
* Value, Name, Type & Retired status
* For samples check out ruby-dicom's uid dictionaries in the git repository
@param [String] file the path to the dictionary file to be added
|
[
"Adds",
"a",
"custom",
"dictionary",
"file",
"to",
"the",
"ruby",
"-",
"dicom",
"uid",
"dictionary",
"."
] |
3ffcfe21edc8dcd31298f945781990789fc832ab
|
https://github.com/dicom/ruby-dicom/blob/3ffcfe21edc8dcd31298f945781990789fc832ab/lib/dicom/d_library.rb#L81-L86
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.