# encoding: utf-8 require 'pp' require 'rubygems'; require 'yaml'; # require 'sqlite3'; require 'dicom' # Implements a collection of metadata associated with a raw image file. In # this case, by image we mean one single file. For the case of Pfiles one file # corresponds to a complete 4D data set. For dicoms one file corresponds to a single # 2D slice, many of which are assembled later during reconstruction to create a # 4D data set. The motivation for this class is to provide access to the metadata # stored in image file headers so that they can be later reconstructed into nifti # data sets. # # Primarily used to instantiate a #RawImageDataset class RawImageFile #:stopdoc: MIN_HDR_LENGTH = 400 DICOM_HDR = "dicom_hdr" RDGEHDR = "rdgehdr" PRINTRAW = "printraw" RUBYDICOM_HDR = "rubydicom" VALID_HEADERS = [DICOM_HDR, PRINTRAW, RDGEHDR, RUBYDICOM_HDR] MONTHS = { :jan => "01", :feb => "02", :mar => "03", :apr => "04", :may => "05", :jun => "06", :jul => "07", :aug => "08", :sep => "09", :oct => "10", :nov => "11", :dec => "12" } #:startdoc: # The file name that the instance represents. attr_reader :filename # Which header reading utility reads this file, currently 'rdgehdr'(old p-files&wimr) or 'dicom_hdr' or 'printraw'(new p-files->waisman). attr_reader :hdr_reader # File types are either 'dicom' or 'pfile'. attr_reader :file_type # The date on which this scan was acquired, this is a ruby DateTime object. attr_reader :timestamp # The scanner used to perform this scan, e.g. 'Andys3T'. attr_reader :source # An identifier unique to a 'visit', these are assigned by the scanner techs at scan time. attr_reader :rmr_number # An identifier unique to a Study Session - AKA Exam Number attr_reader :exam_number # A short string describing the acquisition sequence. These come from the scanner. # code and are used to initialise SeriesDescription objects to find related attributes. attr_reader :series_description # A short string describing the study sequence. These come from the scanner. attr_reader :study_description # A short string describing the study protocol. These come from the scanner. attr_reader :protocol_name # M or F. attr_reader :gender # Number of slices in the data set that includes this file, used by AFNI for reconstruction. attr_reader :num_slices # Given in millimeters. attr_reader :slice_thickness # Gap between slices in millimeters. attr_reader :slice_spacing # AKA Field of View, in millimeters. attr_reader :reconstruction_diameter # Voxels in x axis. attr_reader :acquisition_matrix_x # Voxels in y axis. attr_reader :acquisition_matrix_y # Time for each bold repetition, relevent for functional scans. attr_reader :rep_time # Number of bold reps in the complete functional task run. attr_reader :bold_reps # Import Warnings - Fields that could not be read. attr_reader :warnings # Serialized RubyDicomHeader Object (for DICOMs only) attr_reader :dicom_header # Hash of all DICOM Tags including their Names and Values (See #dicom_taghash for more information on the structure) attr_reader :dicom_taghash # DICOM SOP Instance UID (from the scanned file) attr_reader :dicom_image_uid # DICOM Series UID attr_reader :dicom_series_uid # DICOM Study UID attr_reader :dicom_study_uid # Scan Tech Initials attr_reader :operator_name # Patient "Name", usually StudyID or ENUM attr_reader :patient_name # Creates a new instance of the class given a path to a valid image file. # # Throws IOError if the file given is not found or if the available header reading # utilities cannot read the image header. Also raises IOError if any of the # attributes cannot be found in the header. Be aware that the filename used to # initialize your instance is used to set the "file" attribute. If you need to # unzip a file to a temporary location, be sure to keep the same filename for the # temporary file. def initialize(pathtofile) # raise an error if the file doesn't exist absfilepath = File.expand_path(pathtofile) raise(IOError, "File not found at #{absfilepath}.") if not File.exists?(absfilepath) @filename = File.basename(absfilepath) @warnings = [] # try to read the header, raise an IOError if unsuccessful begin @hdr_data, @hdr_reader = read_header(absfilepath) rescue Exception => e raise(IOError, "Header not readable for file #{@filename} using #{@current_hdr_reader ? @current_hdr_reader : "unknown header reader."}. #{e}") end # file type is based on file name but only if the header was read successfully @file_type = determine_file_type # try to import attributes from the header, raise an ScriptError or NoMethodError # if any required attributes are not found begin import_hdr rescue ScriptError, NoMethodError => e # puts e.backtrace raise e, "Could not find required DICOM Header Meta Element: #{e}" rescue StandardError => e raise e, "Header import failed for file #{@filename}. #{e} . Has the scanner software version changed? A new version of the p-file reading software (printraw or rdgehdr) might be needed. " end # deallocate the header data to save memory space. @hdr_data = nil end # Predicate method that tells whether or not the file is actually an image. This # judgement is based on whether one of the available header reading utilities can # actually read the header information. def image? return ( VALID_HEADERS.include? @hdr_reader ) end # Predicate simply returns true if "pfile" is stored in the @img_type instance variable. def pfile? return @file_type == "pfile" end # Predicate simply returns true if "dicom" is stored in the img_type instance variable. def dicom? return @file_type == "dicom" end def geifile? return @file_type == "geifile" end # Returns a yaml string based on a subset of the attributes. Specifically, # the @hdr_data is not included. This is used to generate .yaml files that are # placed in image directories for later scanning by YamlScanner. def to_yaml yamlhash = {} instance_variables.each do |var| yamlhash[var[1..-1]] = instance_variable_get(var) if (var != "@hdr_data") end return yamlhash.to_yaml end # Returns the internal, parsed data fields in an array. This is used when scanning # dicom slices, to compare each dicom slice in a folder and make sure they all hold the # same data. def to_array return [@filename, @timestamp, @source, @rmr_number, @series_description, @gender, @slice_thickness, @slice_spacing, @reconstruction_diameter, @acquisition_matrix_x, @acquisition_matrix_y] end # Returns an SQL statement to insert this image into the raw_images table of a # compatible database (sqlite3). This is intended for inserting into the rails # backend database. def db_insert(image_dataset_id) "INSERT INTO raw_image_files (filename, header_reader, file_type, timestamp, source, rmr_number, series_description, gender, num_slices, slice_thickness, slice_spacing, reconstruction_diameter, acquisition_matrix_x, acquisition_matrix_y, rep_time, bold_reps, created_at, updated_at, image_dataset_id) VALUES ('#{@filename}', '#{@hdr_reader}', '#{@file_type}', '#{@timestamp.to_s}', '#{@source}', '#{@rmr_number}', '#{@series_description}', '#{@gender}', #{@num_slices}, #{@slice_thickness}, #{@slice_spacing}, #{@reconstruction_diameter}, #{@acquisition_matrix_x}, #{@acquisition_matrix_y}, #{@rep_time}, #{@bold_reps}, '#{DateTime.now}', '#{DateTime.now}', #{image_dataset_id})" end # Returns an SQL statement to select this image file row from the raw_image_files table # of a compatible database. def db_fetch "SELECT *" + from_table_where + sql_match_conditions end # Returns and SQL statement to remove this image file from the raw_image_files table # of a compatible database. def db_remove "DELETE" + from_table_where + sql_match_conditions end # Uses the db_insert method to actually perform the database insert using the # specified database file. def db_insert!( db_file ) db = SQLite3::Database.new( db_file ) db.transaction do |database| if not database.execute( db_fetch ).empty? raise(IndexError, "Entry exists for #{filename}, #{@rmr_number}, #{@timestamp.to_s}... Skipping.") end database.execute( db_insert ) end db.close end # Removes this instance from the raw_image_files table of the specified database. def db_remove!( db_file ) db = SQLite3::Database.new( db_file ) db.execute( db_remove ) db.close end # Finds the row in the raw_image_files table of the given db file that matches this object. # ORM is based on combination of rmr_number, timestamp, and filename. The row is returned # as an array of values (see 'sqlite3' gem docs). def db_fetch!( db_file ) db = SQLite3::Database.new( db_file ) db_row = db.execute( db_fetch ) db.close return db_row end # The series ID (dicom_series_uid [dicom] or series_uid [pfile/ifile]) # This is unique for DICOM datasets, but not for PFiles def series_uid @dicom_series_uid || @series_uid end # The UID unique to the raw image file scanned def image_uid @dicom_image_uid || @image_uid end private def from_table_where " FROM raw_image_files WHERE " end def sql_match_conditions "rmr_number = '#{@rmr_number}' AND timestamp = '#{@timestamp.to_s}' AND filename = '#{@filename}'" end # Reads the file header using one of the available header reading utilities. # Returns both the header data as either a RubyDicom object or one big string, and the name of the utility # used to read it. # # Note: The rdgehdr is a binary file; the correct version for your architecture must be installed in the path. def read_header(absfilepath) case File.basename(absfilepath) when /^P.{5}\.7$|^I\..{3}/ # Try reading Pfiles or Genesis I-Files with GE's printraw # printraw works on the new waisman p-files # rdgehdr works on wimr p-files, and old waisman p-files @current_hdr_reader = PRINTRAW puts "aaaaaaa absfilepath="+absfilepath header = `#{PRINTRAW} '#{absfilepath}' 2> /dev/null` #header = `#{RDGEHDR} #{absfilepath}` #puts "bbbbb header="+header header = header.encode("UTF-8", :invalid => :replace, :undef => :replace, :replace => "").force_encoding('UTF-8') if ( header.chomp != "" and header.length > MIN_HDR_LENGTH ) @current_hdr_reader = nil return [ header, PRINTRAW ] end # Try reading Pfiles or Genesis I-Files with GE's rdgehdr -- rdgehdr newer version needs macos 10.8, adrcdev2 = 10.7.5 - # works on old headers, not on new header format ###@current_hdr_reader = RDGEHDR ###header = `#{RDGEHDR} '#{absfilepath}' 2> /dev/null` #header = `#{RDGEHDR} #{absfilepath}` ###if ( header.chomp != "" and ### header.length > MIN_HDR_LENGTH ) ### @current_hdr_reader = nil ### return [ header, RDGEHDR ] ### end else # Try reading with RubyDICOM @current_hdr_reader = RUBYDICOM_HDR header = DICOM::DObject.new(absfilepath) if defined? header.read_success && header.read_success @current_hdr_reader = nil return [header, RUBYDICOM_HDR] end # Try reading with AFNI's dicom_hdr @current_hdr_reader = DICOM_HDR header = `#{DICOM_HDR} '#{absfilepath}' 2> /dev/null` #header = `#{DICOM_HDR} #{absfilepath}` if ( header.index("ERROR") == nil and header.chomp != "" and header.length > MIN_HDR_LENGTH ) @current_hdr_reader = nil return [ header, DICOM_HDR ] end end @current_hdr_reader = nil return [ nil, nil ] end # Returns a string that indicates the file type. This is difficult because dicom # files have no consistent naming conventions/suffixes. Here we chose to call a # file a "pfile" if it is an image and the file name is of the form P*.7 # All other images are called "dicom". def determine_file_type return "pfile" if image? and (@filename =~ /^P.....\.7/) != nil return "geifile" if image? and (@filename =~ /^I\.\d*/) != nil return "dicom" if image? and (@filename =~ /^P.....\.7/) == nil return nil end # Parses the header data and extracts a collection of instance variables. If # @hdr_data and @hdr_reader are not already available, this function does nothing. def import_hdr raise(IndexError, "No Header Data Available.") if @hdr_data == nil case @hdr_reader when "rubydicom" then rubydicom_hdr_import when "dicom_hdr" then dicom_hdr_import when "printraw" then printraw_import when "rdgehdr" then rdgehdr_import end end # Extract a collection of metadata from @hdr_data retrieved using RubyDicom # # Here are some example DICOM Tags and Values # 0008,0022 Acquisition Date DA 8 20101103 # 0008,0030 Study Time TM 6 101538 # 0008,0080 Institution Name LO 4 Institution # 0008,1010 Station Name SH 8 Station # 0008,0018 SOP Instance UID 12 1.2.840.113619.2.155.3596.6906438.17031.1121881958.942 # 0008,1030 Study Description LO 12 PILOT Study # 0008,103E Series Description LO 12 3pl loc FGR # 0008,1070 Operators' Name PN 2 SP # 0008,1090 Manufacturer's Model Name LO 16 DISCOVERY MR750 # 0010,0010 Patient's Name PN 12 mosPilot # 0010,0020 Patient ID LO 12 RMREKKPilot # 0010,0040 Patient's Sex CS 2 F # 0010,1010 Patient's Age AS 4 027Y # 0010,1030 Patient's Weight DS 4 49.9 # 0018,0023 MR Acquisition Type CS 2 2D # 0018,0050 Slice Thickness DS 2 10 # 0018,0080 Repetition Time DS 6 5.032 # 0018,0081 Echo Time DS 6 1.396 # 0018,0082 Inversion Time DS 2 0 # 0018,0083 Number of Averages DS 2 1 # 0018,0087 Magnetic Field Strength DS 2 3 # 0018,0088 Spacing Between Slices DS 4 12.5 # 0018,0091 Echo Train Length IS 2 1 # 0018,0093 Percent Sampling DS 4 100 # 0018,0094 Percent Phase Field of View DS 4 100 # 0018,0095 Pixel Bandwidth DS 8 244.141 # 0018,1000 Device Serial Number LO 16 0000006080000 # 0018,1020 Software Version(s) LO 42 21\LX\MR Software release:20.. # 0018,1030 Protocol Name LO 22 MOSAIC Pilot 02Nov2010 # 0018,1100 Reconstruction Diameter DS 4 240 # 0018,1250 Receive Coil Name SH 8 8HRBRAIN # 0018,1310 Acquisition Matrix US 8 0\256\128\0 # 0018,1312 In-plane Phase Encoding Direction CS 4 ROW # 0018,1314 Flip Angle DS 2 30 # 0018,1315 Variable Flip Angle Flag CS 2 N # 0018,1316 SAR DS 8 0.498088 # 0020,000D Study Instance UID UI 52 1.2.840.113619.6.260.4.88937.. # 0020,000E Series Instance UID UI 54 1.2.840.113619.2.260.6945.23.. # 0020,0010 Study ID SH 4 1260 # 0020,0011 Series Number IS 2 1 # 0020,0012 Acquisition Number IS 2 1 # 0020,0013 Instance Number IS 2 1 # 0020,0032 Image Position (Patient) DS 22 -119.531\-159.531\-25 # 0020,1002 Images in Acquisition IS 2 15 # 0028,0010 Rows US 2 256 # 0028,0011 Columns US 2 256 # 0028,0030 Pixel Spacing DS 14 0.9375\0.9375 def rubydicom_hdr_import dicom_tag_attributes = { :source => "0008,0080", :series_description => "0008,103E", :study_description => "0008,1030", :operator_name => "0008,1070", :patient_name => "0010,0010", :rmr_number => "0010,0020", :gender => "0010,0040", :slice_thickness => "0018,0050", :reconstruction_diameter => "0018,1100", :rep_time => "0018,0080", :pixel_spacing => "0028,0030", :flip_angle => "0018,1314", :field_strength => "0018,0087", :slice_spacing => "0018,0088", :software_version => "0018,1020", :protocol_name => "0018,1030", :bold_reps => "0020,0105", :dicom_image_uid => "0008,0018", # Each DICOM Image (i.e. raw image file) has a unique SOP Instance UID :dicom_series_uid => "0020,000E", # Series UID (shared by all dicoms in the same series) :dicom_study_uid => "0020,000D", :exam_number => "0020,0010", :num_slices => "0020,1002", :acquisition_matrix_x => "0028,0010", :acquisition_matrix_y => "0028,0011" } dicom_tag_attributes.each_pair do |name, tag| begin # next if tag_hash[:type] == :datetime value = @hdr_data[tag].value if @hdr_data[tag] raise ScriptError, "No match found for #{name}" unless value instance_variable_set("@#{name.to_s}", value) rescue ScriptError => e @warnings << "Tag #{name} could not be found." end end @timestamp = DateTime.parse(@hdr_data["0008,0022"].value + @hdr_data["0008,0030"].value) @dicom_taghash = create_dicom_taghash(@hdr_data) # @dicom_header = remove_long_dicom_elements(@hdr_data) end # # Remove long data elements from a rubydicom header. This essentially strips # # lengthy image data. # def remove_long_dicom_elements(header) # raise ScriptError, "A DICOM::DObject instance is required" unless header.kind_of? DICOM::DObject # h = header.dup # h.children.select { |element| element.length > 100 }.each do |e| # h.remove(e.tag) # # puts "Removing #{e.tag}..." # end # return h # end # Create a super-lightweight representation of the DICOM header as a hash, where # the tags are they keys and name and value are stored as an attribute hash in value. # # Creates a hash like: # {"0018,0095"=>{:value=>"244.141", :name=>"Pixel Bandwidth"}, # "0008,1030"=>{:value=>"MOSAIC PILOT", :name=>"Study Description"} } # # When serialized with yaml, this looks like: # # 0018,0095: # :value: "244.141" # :name: Pixel Bandwidth # # 0008,1030: # :value: MOSAIC PILOT # :name: Study Description # # To filter and search, you can do something like: # tag_hash.each_pair {|tag, attributes| puts tag, attributes[:value] if attributes[:name] =~ /Description/i } def create_dicom_taghash(header) raise ScriptError, "A DICOM::DObject instance is required" unless header.kind_of? DICOM::DObject h = Hash.new header.children.each do |element| h[element.tag] = {:value => element.instance_variable_get(:@value), :name => element.name} end return h end # Extracts a collection of metadata from @hdr_data retrieved using the dicom_hdr # utility. def dicom_hdr_import dicom_tag_templates = {} dicom_tag_templates[:rmr_number] = { :type => :string, :pat => /[ID Accession Number|ID Study Description]\/\/(RMR.*)\n/i, :required => true } dicom_tag_templates[:exam_number] = { :type => :string, :pat => /STUDY ID\/\/([0-9]+)/i, :required => true } dicom_tag_templates[:slice_thickness] = { :type => :float, :pat => /ACQ SLICE THICKNESS\/\/(.*)\n/i, :required => false } dicom_tag_templates[:slice_spacing] = { :type => :float, :pat => /ACQ SPACING BETWEEN SLICES\/\/(.*)\n/i, :required => false } dicom_tag_templates[:source] = { :type => :string, :pat => /ID INSTITUTION NAME\/\/(.*)\n/i, :required => true } dicom_tag_templates[:series_description] = { :type => :string, :pat => /ID SERIES DESCRIPTION\/\/(.*)\n/i, :required => true } dicom_tag_templates[:gender] = { :type => :string, :pat => /PAT PATIENT SEX\/\/(.)/i, :required => false } dicom_tag_templates[:reconstruction_diameter] = { :type => :int, :pat => /ACQ RECONSTRUCTION DIAMETER\/\/([0-9]+)/i, :required => false } dicom_tag_templates[:acquisition_matrix_x] = { :type => :int, :pat => /IMG Rows\/\/ ([0-9]+)/i, :required => false } dicom_tag_templates[:acquisition_matrix_y] = { :type => :int, :pat => /IMG Columns\/\/ ([0-9]+)/i, :required => false } dicom_tag_templates[:num_slices] = { :type => :int, :pat => /REL Images in Acquisition\/\/([0-9]+)/i, :required => false } dicom_tag_templates[:bold_reps] = { :type => :int, :pat => /REL Number of Temporal Positions\/\/([0-9]+)/i, :required => false } dicom_tag_templates[:rep_time] = { :type => :float, :pat => /ACQ Repetition Time\/\/(.*)\n/i, :required => false } dicom_tag_templates[:date] = { :type => :datetime, :pat => /ID STUDY DATE\/\/(.*)\n/i #, # :required => false } dicom_tag_templates[:time] = { :type => :datetime, :pat => /ID Series Time\/\/(.*)\n/i #, # :required => false } dicom_tag_templates.each_pair do |name, tag_hash| begin next if tag_hash[:type] == :datetime tag_hash[:pat] =~ @hdr_data raise ScriptError, "No match found for #{name}" if ($1).nil? value = case tag_hash[:type] when :string then ($1).strip.chomp when :float then ($1).strip.chomp.to_f when :int then ($1).to_i end self.instance_variable_set("@#{name}", value) rescue ScriptError => e if tag_hash[:required] raise ScriptError, "#{name}" else @warnings << "Tag #{name} could not be found." end end end # Set Timestamp separately because it requires both Date and Time to be extracted. dicom_tag_templates[:date][:pat] =~ @hdr_data date = $1 dicom_tag_templates[:time][:pat] =~ @hdr_data time = $1 @timestamp = DateTime.parse(date + time) end def printraw_import source_pat = /hospital [Nn]ame: ([[:graph:]\t ]+)/i num_slices_pat = /rdb_hdr_nslices = ([0-9]+)/i slice_thickness_pat = /slthick = ([[:graph:]]+)/i slice_spacing_pat = /scanspacing = ([[:graph:]]+)/i date_pat = /ex_datetime = (.*)\n/i gender_pat = /patsex = (1|2)/i acquisition_matrix_x_pat = /imatrix_X = ([0-9]+)/i acquisition_matrix_y_pat = /imatrix_Y = ([0-9]+)/i series_description_pat = /se_desc = ([[:graph:] \t]+)/i recon_diam_pat = /dfov = ([0-9]+)/i rmr_number_pat = /Patient ID for this exam: ([[:graph:]]+)/i bold_reps_pat = /nex = ([0-9]+)/i rep_time_pat = /reptime = ([0-9]+)/i # not sure ifg this is right study_uid_pat = /Ssop_uid = ([[:graph:]]+)/i series_uid_pat = /series_uid = ([[:graph:]]+)/i image_uid_pat = /image_uid = (.*)/i #([[:graph:]]+)/i # @hdr_data = @hdr_data.encode("UTF-8", :invalid => :replace, :undef => :replace, :replace => "").force_encoding('UTF-8') #@hdr_data = @hdr_data.encode!('UTF-8', 'UTF-8', :invalid => :replace) #@hdr_data_2 = @hdr_data.encode("UTF-8") #@hdr_data.encode!("ISO-8859-1", :invalid => :replace).encode("UTF-8") #@hdr_data.encode("UTF-8", :invalid => :replace, :replace => "") == invalid byte sequence in UTF-8 #@hdr_data.encode!("UTF-8", :invalid => :replace, :replace => "") invalid byte sequence in UTF-8 #@hdr_data.encode("ISO-8859-1", :invalid => :replace) invalid byte sequence in UTF-8 #@hdr_data = @hdr_data.encode('UTF-8','binary', :invalid => :replace,:undef => :replace, :replace =>'') #Attribute was supposed to be a Hash, but was a String #@hdr_data = @hdr_data.encode('UTF-8','UTF-8', :invalid => :replace,:undef => :replace, :replace =>'') # invalid byte sequence in UTF-8 #@hdr_data.encode('UTF-8','UTF-8', :invalid => :replace,:undef => :replace, :replace =>'') # invalid byte sequence in UTF-8 hdr_data_bak = @hdr_data @hdr_data.encode!("ISO-8859-1", :invalid => :replace).encode("UTF-8") #Attribute was supposed to be a Hash, but was a String puts "aaaaaaaaaaa" rmr_number_pat =~ @hdr_data @rmr_number = ($1).nil? ? "rmr not found" : ($1).strip.chomp puts "bbbbbbbb " source_pat =~ @hdr_data @source = ($1).nil? ? "source not found" : ($1).strip.chomp num_slices_pat =~ @hdr_data @num_slices = ($1).to_i slice_thickness_pat =~ @hdr_data @slice_thickness = ($1).to_f slice_spacing_pat =~ @hdr_data @slice_spacing = ($1).to_f date_pat =~ @hdr_data @timestamp = Time.at($1.to_i).to_datetime # @timestamp = DateTime.parse($1) --- 2 rows- same start of line- first since epoch, 2nd date stamnp gender_pat =~ @hdr_data @gender = $1 == 1 ? "M" : "F" acquisition_matrix_x_pat =~ @hdr_data @acquisition_matrix_x = ($1).to_i acquisition_matrix_y_pat =~ @hdr_data @acquisition_matrix_y = ($1).to_i series_description_pat =~ @hdr_data @series_description = ($1).strip.chomp recon_diam_pat =~ @hdr_data @reconstruction_diameter = ($1).to_i bold_reps_pat =~ @hdr_data @bold_reps = ($1).to_i rep_time_pat =~ @hdr_data @rep_time = ($1).to_f / 1000000 study_uid_pat =~ @hdr_data @study_uid = ($1).strip.chomp unless $1.nil? series_uid_pat =~ @hdr_data @series_uid = ($1).strip.chomp unless $1.nil? image_uid_pat =~ @hdr_data @image_uid = ($1).strip.chomp unless $1.nil? puts "rrrrrr @image_uid ="+@image_uid .to_s @hdr_data = nil end # Extracts a collection of metadata from @hdr_data retrieved using the rdgehdr # utility. def rdgehdr_import source_pat = /hospital [Nn]ame: ([[:graph:]\t ]+)/i num_slices_pat = /Number of slices in this scan group: ([0-9]+)/i slice_thickness_pat = /slice thickness \(mm\): ([[:graph:]]+)/i slice_spacing_pat = /spacing between scans \(mm\??\): ([[:graph:]]+)/i date_pat = /actual image date\/time stamp: (.*)\n/i gender_pat = /Patient Sex: (1|2)/i acquisition_matrix_x_pat = /Image matrix size \- X: ([0-9]+)/i acquisition_matrix_y_pat = /Image matrix size \- Y: ([0-9]+)/i series_description_pat = /Series Description: ([[:graph:] \t]+)/i recon_diam_pat = /Display field of view \- X \(mm\): ([0-9]+)/i rmr_number_pat = /Patient ID for this exam: ([[:graph:]]+)/i bold_reps_pat = /Number of excitations: ([0-9]+)/i rep_time_pat = /Pulse repetition time \(usec\): ([0-9]+)/i study_uid_pat = /Study entity unique ID: ([[:graph:]]+)/i series_uid_pat = /Series entity unique ID: ([[:graph:]]+)/i image_uid_pat = /Image unique ID: ([[:graph:]]+)/i rmr_number_pat =~ @hdr_data @rmr_number = ($1).nil? ? "rmr not found" : ($1).strip.chomp source_pat =~ @hdr_data @source = ($1).nil? ? "source not found" : ($1).strip.chomp num_slices_pat =~ @hdr_data @num_slices = ($1).to_i slice_thickness_pat =~ @hdr_data @slice_thickness = ($1).to_f slice_spacing_pat =~ @hdr_data @slice_spacing = ($1).to_f date_pat =~ @hdr_data @timestamp = DateTime.parse($1) gender_pat =~ @hdr_data @gender = $1 == 1 ? "M" : "F" acquisition_matrix_x_pat =~ @hdr_data @acquisition_matrix_x = ($1).to_i acquisition_matrix_y_pat =~ @hdr_data @acquisition_matrix_y = ($1).to_i series_description_pat =~ @hdr_data @series_description = ($1).strip.chomp recon_diam_pat =~ @hdr_data @reconstruction_diameter = ($1).to_i bold_reps_pat =~ @hdr_data @bold_reps = ($1).to_i rep_time_pat =~ @hdr_data @rep_time = ($1).to_f / 1000000 study_uid_pat =~ @hdr_data @study_uid = ($1).strip.chomp unless $1.nil? series_uid_pat =~ @hdr_data @series_uid = ($1).strip.chomp unless $1.nil? image_uid_pat =~ @hdr_data @image_uid = ($1).strip.chomp unless $1.nil? end end