dicoms 1.0.0 → 1.2.0

data/lib/dicoms/histogram.rb

@@ -0,0 +1,50 @@
+require 'histogram/narray'
+
+class DicomS
+  def histogram(dicom_directory, options = {})
+    bins, freqs = compute_histogram(dicom_directory, options)
+    print_histogram bins, freqs, options
+  end
+
+  def compute_histogram(dicom_directory, options = {})
+    sequence = Sequence.new(dicom_directory)
+    bin_width = options[:bin_width]
+
+    if sequence.size == 1
+      data = sequence.first.narray
+    else
+      maxx = sequence.metadata.nx
+      maxy = sequence.metadata.ny
+      maxz = sequence.metadata.nz
+      data = NArray.sfloat(maxx, maxy, maxz)
+      sequence.each do |dicom, z, file|
+        data[true, true, z] = sequence.dicom_pixels(dicom)
+      end
+    end
+    bins, freqs = data.histogram(:scott, :bin_boundary => :min, bin_width: bin_width)
+    [bins, freqs]
+  end
+
+  def print_histogram(bins, freqs, options = {})
+    compact = options[:compact]
+    bin_labels = bins.to_a.map { |v| v.round.to_s }
+    label_width = bin_labels.map(&:size).max
+    sep = ": "
+    bar_width  = terminal_size.last.to_i - label_width - sep.size
+    div = [1, freqs.max / bar_width.to_f].max
+    compact = true
+    empty = false
+    bin_labels.zip(freqs.to_a).each do |bin, freq|
+      rep = ((freq/div).round)
+      if compact && rep == 0
+        unless empty
+          puts "%#{label_width}s" % ['...']
+          empty = true
+        end
+        next
+      end
+      puts "%#{label_width}s#{sep}%-#{bar_width}s" % [bin, '#'*rep]
+      empty = false
+    end
+  end
+end

data/lib/dicoms/info.rb

@@ -0,0 +1,43 @@
+require 'fileutils'
+
+class DicomS
+  def info(dicom_directory, options = {})
+    dicom_files = find_dicom_files(dicom_directory)
+    if dicom_files.empty?
+      raise "ERROR: no se han encontrado archivos DICOM en: \n #{dicom_directory}"
+    end
+    if options[:output]
+      if File.directory?(dicom_directory)
+        output_dir = options[:output]
+      else
+        output_file = options[:output]
+        if File.exists?(output_file)
+          raise "File #{output_file} already exits"
+        end
+        output = File.open(output_file, 'w')
+      end
+    end
+    if output_dir
+      FileUtils.mkdir_p output_dir
+      dicom_files.each do |file|
+        output_file = File.join(output_dir, File.basename(file,'.dcm')+'.txt')
+        File.open(output_file, 'w') do |output|
+          dicom = DICOM::DObject.read(file)
+          print_info dicom, output
+        end
+      end
+    else
+      dicom_files.each do |file|
+        dicom = DICOM::DObject.read(file)
+        print_info dicom, output || STDOUT
+      end
+      output.close if output
+    end
+  end
+
+  def print_info(dicom, output)
+    $stdout = output
+    dicom.print_all
+    $stdout = STDOUT
+  end
+end

data/lib/dicoms/progress.rb

@@ -6,14 +6,19 @@ class DicomS
       @progress = options[:initial_progress] || 0
       # TODO: if filename == :console, show progress on the console
       if filename
-        @file = SharedSettings.new(
-          filename,
-          replace_contents: {
-            process: description,
-            subprocess: options[:subprocess],
-            progress: @progress
+        if description
+          init_options = {
+            override_contents: {
+              process: description,
+              subprocess: options[:subprocess],
+              progress: @progress,
+              error: nil
+            }
           }
-        )
+        else
+          init_options = {}
+        end
+        @file = SharedSettings.new(filename, init_options)
       else
         @file = nil
       end
@@ -22,6 +27,16 @@ class DicomS
 
     attr_reader :progress
 
+    def persistent?
+      !!@file
+    end
+
+    def error!(code, message)
+      @file.update do |data|
+        data.merge error: code, error_message: message
+      end
+    end
+
     def finished?
       @progress >= 100
     end

data/lib/dicoms/projection.rb

@@ -69,13 +69,14 @@ class DicomS
       # volume = NArray.sint(maxx, maxy, maxz)
       volume = NArray.int(maxx, maxy, maxz)
     end
+    maxv = volume.max
     keeping_path do
       sequence.each do |dicom, z, file|
         slice = sequence.dicom_pixels(dicom, unsigned: true)
         volume[true, true, z] = slice
         if center_slice_projection?(options[:axial])
           minz_contents, maxz_contents = update_min_max_contents(
-            z, slice.max, maxy, minz_contents, maxz_contents
+            z, slice.max, maxv, minz_contents, maxz_contents
           )
         end
         progress.update_subprocess z
@@ -85,7 +86,7 @@ class DicomS
     if center_slice_projection?(options[:coronal])
       (0...maxy).each do |y|
         miny_contents, maxy_contents = update_min_max_contents(
-          y, volume[true, y, true].max, maxy, miny_contents, maxy_contents
+          y, volume[true, y, true].max, maxv, miny_contents, maxy_contents
         )
       end
     end
@@ -93,7 +94,7 @@ class DicomS
     if center_slice_projection?(options[:sagittal])
       (0...maxz).each do |z|
         minz_contents, maxz_contents = update_min_max_contents(
-          z, volume[true, true, z].max, maxz, minz_contents, maxz_contents
+          z, volume[true, true, z].max, maxv, minz_contents, maxz_contents
         )
       end
     end
@@ -129,7 +130,7 @@ class DicomS
     elsif middle_slice_projection?(options[:coronal])
       coronal_ys = [[maxy/2, 'm']]
     elsif full_projection?(options[:coronal])
-      coronal_ys = (0...maxx)
+      coronal_ys = (0...maxy)
     else
       coronal_ys = []
     end
@@ -275,8 +276,7 @@ class DicomS
     v.max(axis)
   end
 
-  def accumulated_attenuation_projection(float_v, axis, max_output_level, max=500)
-    k = 0.02
+  def accumulated_attenuation_projection(float_v, axis, max_output_level, max=500, k = 0.02)
     if ADJUST_AAP_FOR_WIDTH
       k *= 500.0/max
     end
@@ -284,8 +284,10 @@ class DicomS
     v.mul! -k
     v = NMath.exp(v)
     # Invert result (from attenuation to transmission)
-    v.mul! -max_output_level
-    v.add! max_output_level
+    if max_output_level
+      v.mul! -max_output_level
+      v.add! max_output_level
+    end
     v
   end
 
@@ -322,8 +324,6 @@ class DicomS
   end
 
   def projection_scaling(data, options = {})
-    sx = sy = sz = 1
-
     nx = data.nx
     ny = data.ny
     nz = data.nz
@@ -331,18 +331,37 @@ class DicomS
     dy = data.dy
     dz = data.dz
 
-    unless dx == dy && dy == dz
-      # need to cope with different scales in different axes.
-      # will always produce shrink factors (<1)
-      ref = [dx, dy, dz].max.to_f
+    sx = sy = sz = 1
+    scaled_nx = nx
+    scaled_ny = ny
+    scaled_nz = nz
+
+    adjust = ->(ref) {
       sx = dx/ref
       sy = dy/ref
       sz = dz/ref
-    end
+      scaled_nx = (nx*sx).round
+      scaled_ny = (ny*sy).round
+      scaled_nz = (nz*sz).round
+    }
+
+    # need to cope with different scales in different axes.
+    # will always produce shrink factors (<1)
+    adjust.call [dx, dy, dz].max.to_f
 
-    scaled_nx = (nx*sx).round
-    scaled_ny = (ny*sy).round
-    scaled_nz = (nz*sz).round
+    # Now we may have scaled down too much; we'll avoid going below
+    # requested minimum sizes for axes and/or image dimensions.
+    # Axis X is the columns of axial an coronal views
+    # Axis Y is the rows of axial and the columns of sagittal
+    # Axis Z is the rows of coronal and sagittal views
+    min_nx = [scaled_nx, options.min_x_pixels, options[:mincols]].compact.max
+    adjust[dx*nx.to_f/min_nx] if scaled_nx < min_nx
+
+    min_ny = [scaled_ny, options.min_y_pixels, options[:mincols], options[:minrows]].compact.max
+    adjust[dy*ny.to_f/min_ny] if scaled_ny < min_ny
+
+    min_nz = [scaled_nz, options.min_z_pixels, options[:minrows]].compact.max
+    adjust[dz*nz.to_f/min_nz] if scaled_nz > min_nz
 
     # further shrinking may be needed to avoid any projection
     # to be larger thant the maximum image size
@@ -350,22 +369,13 @@ class DicomS
     # Axis Y is the rows of axial and the columns of sagittal
     # Axis Z is the rows of coronal and sagittal views
     max_nx = [scaled_nx, options.max_x_pixels, options[:maxcols]].compact.min
-    if scaled_nx > max_nx
-      scaled_nx = max_nx
-      sx = scaled_nx/nx.to_f
-    end
+    adjust[dx*nx.to_f/max_nx] if scaled_nx > max_nx
 
     max_ny = [scaled_ny, options.max_y_pixels, options[:maxcols], options[:maxrows]].compact.min
-    if scaled_ny > max_ny
-      scaled_ny = max_ny
-      sy = scaled_ny/ny.to_f
-    end
+    adjust[dy*ny.to_f/max_ny] if scaled_ny > max_ny
 
     max_nz = [scaled_nz, options.max_z_pixels, options[:maxrows]].compact.min
-    if scaled_nz > max_nz
-      scaled_nz = max_nz
-      sz = scaled_nz/nz.to_f
-    end
+    adjust[dz*nz.to_f/max_nz] if scaled_nz > max_nz
 
     {
       scale_x: sx, scale_y: sy, scale_z: sz,

data/lib/dicoms/sequence.rb

@@ -79,6 +79,9 @@ class DicomS
       @strategy = options[:transfer]
       @metadata = Settings[version: 'DSPACK1']
 
+      if @files.empty?
+        raise InvaliddDICOM, 'No DICOM files found'
+      end
       # TODO: reuse existing metadata in options (via settings)
 
       if options[:reorder]
@@ -131,7 +134,7 @@ class DicomS
       dicom = DICOM::DObject.read(@files[i])
       sop_class = dicom['0002,0002'].value
       unless sop_class == '1.2.840.10008.5.1.4.1.1.2'
-        raise "Unsopported SOP Class #{sop_class}"
+        raise UnsupportedDICOM, "Unsopported SOP Class #{sop_class}"
       end
       # TODO: require known SOP Class:
       # (in tag 0002,0002, Media Storage SOP Class UID)
@@ -244,7 +247,7 @@ class DicomS
           end
           if bits
             if bits != dicom_bit_depth(dicom) || signed != dicom_signed?(dicom)
-              raise "Inconsistent slices"
+              raise InvalidDICOM, "Inconsistent slices"
             end
           else
             bits   = dicom_bit_depth(dicom)
@@ -252,7 +255,7 @@ class DicomS
           end
           if slope
             if slope != dicom_rescale_slope(dicom) || intercept != dicom_rescale_intercept(dicom)
-              raise "Inconsitent slices"
+              raise InvalidDICOM, "Inconsitent slices"
             end
           else
             slope = dicom_rescale_slope(dicom)
@@ -322,8 +325,6 @@ class DicomS
 
       total_n = size
 
-      n = last_i - first_i
-
       xaxis = decode_vector(first_md.xaxis)
       yaxis = decode_vector(first_md.yaxis)
       # assert xaxis == decode_vector(last_md.xaxis)
@@ -337,12 +338,16 @@ class DicomS
       @metadata.merge! Settings[first_md]
       @metadata.zaxis = encode_vector zaxis
       @metadata.nz = total_n
-      @metadata.dz = (last_md.slice_z - first_md.slice_z).abs/n
-
-      if xaxis[0].abs != 1 || xaxis[1] != 0 || xaxis[2] != 0 ||
-         yaxis[0] != 0 || yaxis[1] != 1 || yaxis[2] != 0 ||
-         zaxis[0] != 0 || zaxis[1] != 0 || zaxis[2].abs != 1
-        raise Error, "Unsupported orientation"
+      # Position coordinates are assumed at the voxel's center
+      # note that we divide the coordinate span z_last - z_first
+      # by the number of slices (voxels) minus one
+      @metadata.dz = (last_md.slice_z - first_md.slice_z).abs/(last_i - first_i)
+
+      tolerance = 0.05
+      if (xaxis.map(&:abs) - Vector[1,0,0]).magnitude > tolerance ||
+         (yaxis.map(&:abs) - Vector[0,1,0]).magnitude > tolerance ||
+         (zaxis.map(&:abs) - Vector[0,0,1]).magnitude > tolerance
+        raise UnsupportedDICOM, "Unsupported orientation"
       end
       @metadata.reverse_x = (xaxis[0] < 0) ? 1 : 0
       @metadata.reverse_y = (yaxis[1] < 0) ? 1 : 0

data/lib/dicoms/shared_settings.rb

@@ -24,6 +24,13 @@ class DicomS
       end
       contents = options[:replace_contents]
       write contents if contents
+      contents = options[:override_contents]
+      if contents
+        update do |data|
+          data ||= {}
+          data.merge contents
+        end
+      end
     end
 
     # Read a shared file and obtain a Settings object

data/lib/dicoms/sigmoid.rb

@@ -0,0 +1,121 @@
+require 'solver'
+require 'narray'
+
+class DicomS
+
+  # Compute sigmoid function s(x) = 1 - exp(-((x - x0)**gamma)/k) for x >= x0;
+  # with s(x) = 0 for x < x0).
+  #
+  # 0 <= s(x) < 1 for all x
+  #
+  # Defined by two parameters:
+  #
+  # * w width of the sigmoid
+  # * xc center of the sigmoid (s(xc) = 1/2)
+  #
+  # The interpretation of w is established by a constant 0 < k0 << 1
+  # where y1 = s(x1) = k0 and y2 = s(x2) = 1 - k0 and
+  # x1 = xc - w/2 and x2 = xc + w/2
+  #
+  # The gamma factor should be fixed a priori, e.g. gamma = 4
+  #
+  # k0 = 0.01
+  # w = 3.0
+  # xc = 7.0
+  # sigmod = Sigmoid.new(k0, w, xc)
+  # 0.5 == sigmoid[xc]
+  # k0 == sigmod[xc - w/2]
+  # 1 - k0 == sigmod[xc + w/2]
+  class Sigmoid
+
+    def initialize(options = {})
+      k0 = options[:k0] || 0.05
+      w  = options[:width]
+      xc = options[:center]
+      @gamma = options[:gamma] || 4.0
+      tolerance = options[:tolerance] || Flt::Tolerance(0.01, :relative)
+
+      # Compute the parameters x0 and gamma which define the sigmoid
+      # given k0, w and xc
+
+      yc = 0.5
+      x1 = xc - w/2
+      x2 = xc + w/2
+      y1 = k0
+      y2 = 1 - k0
+      @gamma = 4.0
+
+      # We have two equations to solve for x0, gamma:
+      # * yc == 1 - Math.exp(-((xc - x0)**gamma)/k)
+      # * y1 == 1 - Math.exp(-((x1 - x0)**gamma)/k)
+      # Equivalently we could substitute the latter for
+      # * y2 == 1 - Math.exp(-((x2 - x0)**gamma)/k)
+      #
+      # So, we use the first equation to substitute in the second
+      # one of these:
+      #
+      # * x0 = xc - (-k*Math.log(1 - yc))**(1/gamma)
+      # * k = - (xc - x0)**gamma / Math.log(1 - yc)
+      #
+      # * gamma = Math.log(-k*Math.log(1 - yc))/Math.log(xc - x0)
+      #
+      # So we could solve either this for k:
+      #
+      # * y1 == 1 - Math.exp(-((x1 - xc + (-k*Math.log(1 - yc))**(1/gamma))**gamma)/k)
+      #
+      # or this for x0
+      #
+      # * y1 == 1 - Math.exp(-((x1 - x0)**gamma)/(- (xc - x0)**gamma / Math.log(1 - yc)))
+      algorithm = Flt::Solver::RFSecantSolver
+
+      if true
+        g = @gamma
+        eq = ->(k) {
+          y1 - 1 + exp(-((x1 - xc + (-k*log(1 - yc))**(1/g))**g)/k) }
+        solver = algorithm.new(Float.context, tolerance, &eq)
+        @k = solver.root(1.0, 100.0)
+        @x0 = xc - (-@k*Math.log(1 - yc))**(1/@gamma)
+      else
+        g = @gamma
+        eq = ->(x0) { y1 - 1 + exp(-((x1 - x0)**g)/(- (xc - x0)**g / log(1 - yc))) }
+        solver = algorithm.new(Float.context, tolerance, &eq)
+        @x0 = solver.root(0.0, 100.0)
+        @k = - (xc - @x0)**@gamma / Math.log(1 - yc)
+      end
+    end
+
+    def [](x)
+      if x.is_a? NArray
+        narray_sigmoid x
+      else
+        if x <= @x0
+          0.0
+        else
+          1.0 - Math.exp(-((x - @x0)**@gamma)/@k)
+        end
+      end
+    end
+
+    attr_reader :gamma, :k, :x0
+
+    private
+
+    def narray_sigmoid(x)
+      x[x <= @x0] = 0
+      ne0 = x.ne(0)
+      y = x[ne0]
+      y.sbt! @x0
+      y = power(y, @gamma)
+      y.div! -@k
+      y = NMath.exp(y)
+      y.mul! -1
+      y.add! 1
+      x[ne0] = y
+      x
+    end
+
+    def power(x, y)
+      NMath.exp(y*NMath.log(x))
+    end
+  end
+end