dicoms 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3f1e0d49c4679975f1fcecf31adc7315f911b94a
-  data.tar.gz: 6c3646e777ca6bed2d63b1f984635e2711613a24
+  metadata.gz: 280aba2d5fdbf5adf3b30d288486c7c756df21e0
+  data.tar.gz: fa01e90238b33269969363cf4142e9314b4a6873
 SHA512:
-  metadata.gz: a9a0df47f50b523b2097186a1506edde051042c104f1a4af9b0fe34fb4d9b90852ec04dfcda823ecf884b8de30b3451e48ef0f174c9bdd8c138b083e30b68fcc
-  data.tar.gz: 308aa9e1db3fce6102d8b335adf7147d7ad43b39eef53ffa740039504de07e6ce8a9d085d9d87055fb755936e24b26e0577fa864e951cd7abb5ef5b1ccc7fb19
+  metadata.gz: 7aad5d1d1ab092b05cddc40b00f04be771b4335380b5e3b32576ed97ccdf5f1ba426f7dc416db36f3f099fbb466959d983caaf87f507370e9828fd97baf7698b
+  data.tar.gz: 03e9f692beed4c588ee7f83ca844448a041a2da9eb3453857396aadf6c2e748c18f04c73a4d3698d1ee2d55a7e3107220d4505fffbb061364dd799ca65681f05

data/LICENSE.md

@@ -1,5 +1,3 @@
-Copyright (c) 2015 Javier Goizueta - All Rights Reserved
-
 GNU GENERAL PUBLIC LICENSE
 ==========================
 

data/dicoms.gemspec

@@ -25,7 +25,8 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'modalsettings', '~> 1.0.1'
   spec.add_dependency 'narray', '~> 0.6'
   spec.add_dependency 'thor', '~> 0.19'
-
+  spec.add_dependency 'solver', '>= 0.2.0'
+  spec.add_dependency 'histogram', '~> 0.2.4'
 
   spec.add_development_dependency "bundler", "~> 1.10"
   spec.add_development_dependency "rake", "~> 10.0"

data/lib/dicoms.rb

@@ -19,6 +19,10 @@ require "dicoms/unpack"
 require "dicoms/stats"
 require "dicoms/projection"
 require "dicoms/remap"
+require "dicoms/explode"
+require "dicoms/sigmoid"
+require "dicoms/info"
+require "dicoms/histogram"
 
 class DicomS
 

data/lib/dicoms/cli.rb

@@ -1,6 +1,27 @@
 require 'thor'
 
 class DicomS
+
+  def self.handle_errors(options)
+    return yield if options.debug
+    options = CommandOptions[options]
+    progress = Progress.new(nil, options)
+    if progress.persistent?
+      begin
+        yield
+        0
+      rescue Error => error
+        progress.error! error.code, error.to_s
+        1
+      rescue => error
+        progress.error! 'unknown', error.to_s
+        2
+      end
+    else
+      yield
+    end
+  end
+
   class CLI < Thor
     check_unknown_options!
 
@@ -17,6 +38,7 @@ class DicomS
     class_option 'verbose', type: :boolean, default: false
     class_option 'settings', type: :string, desc: 'settings (read-only) file'
     class_option 'settings_io', type: :string, desc: 'settings file'
+    class_option 'debug', type: :boolean, default: false
 
     desc "pack DICOM-DIR", "pack a DICOM directory"
     option :output,   desc: 'output file', aliases: '-o'
@@ -35,22 +57,23 @@ class DicomS
         ignore_min: true
       }
       settings = {} # TODO: ...
-      unless File.directory?(dicom_dir)
-        raise Error, set_color("Directory not found: #{dicom_dir}", :red)
-        say options
-      end
       cmd_options = CommandOptions[
         settings: options.settings,
         settings_io: options.settings_io,
         output: options.output,
         tmp:  options.tmp,
         reorder: options.reorder,
-        dicom_metadata: true
+        dicom_metadata: true,
+        debug: options.debug
       ]
-      packer = DicomS.new(settings)
-      packer.pack dicom_dir, cmd_options
-      # rescue => raise Error?
-      0
+      DicomS.handle_errors(cmd_options) do
+        packer = DicomS.new(settings)
+        unless File.directory?(dicom_dir)
+          raise Error, set_color("Directory not found: #{dicom_dir}", :red)
+          say options
+        end
+        packer.pack dicom_dir, cmd_options
+      end
     end
 
     desc "unpack dspack", "unpack a dspack file"
@@ -59,20 +82,22 @@ class DicomS
     # TODO: parameters for dicom regeneration
     def unpack(dspack)
       DICOM.logger.level = Logger::FATAL
-      unless File.file?(dspack)
-        raise Error, set_color("File not found: #{dspack}", :red)
-        say options
-      end
       settings = {} # TODO: ...
-      packer = DicomS.new(settings)
-      packer.unpack(
-        dspack,
+      cmd_options = {
         settings: options.settings,
         settings_io: options.settings_io,
         output: options.output,
-        dicom_output: options.dicom
-      )
-      # rescue => raise Error?
+        dicom_output: options.dicom,
+        debug: options.debug
+      }
+      DicomS.handle_errors(cmd_options) do
+        packer = DicomS.new(settings)
+        unless File.file?(dspack)
+          raise Error, set_color("File not found: #{dspack}", :red)
+          say options
+        end
+        packer.unpack dspack, cmd_options
+      end
       0
     end
 
@@ -91,10 +116,6 @@ class DicomS
     def extract(dicom_dir)000
       DICOM.logger.level = Logger::FATAL
       settings = {} # TODO: ...
-      unless File.exists?(dicom_dir)
-        raise Error, set_color("Directory not found: #{dicom_dir}", :red)
-        say options
-      end
 
       raw = options.raw
       if options.big
@@ -105,15 +126,20 @@ class DicomS
         little_endian = true
       end
 
-      packer = DicomS.new(settings)
-      packer.extract(
-        dicom_dir,
+      cmd_options = {
         transfer: DicomS.transfer_options(options),
         output: options.output,
-        raw: raw, big_endian: big_endian, little_endian: little_endian
-      )
-      # rescue => raise Error?
-      0
+        raw: raw, big_endian: big_endian, little_endian: little_endian,
+        debug: options.debug
+      }
+      DicomS.handle_errors(cmd_options) do
+        packer = DicomS.new(settings)
+        unless File.exists?(dicom_dir)
+          raise Error, set_color("Directory not found: #{dicom_dir}", :red)
+          say options
+        end
+        packer.extract(dicom_dir, cmd_options)
+      end
     end
 
     desc "Level stats", "Level limits of one or more DICOM files"
@@ -126,6 +152,31 @@ class DicomS
       puts "  Minimum level: #{stats[:min]}"
       puts "  Next minimum level: #{stats[:next_min]}"
       puts "  Maximum level: #{stats[:max]}"
+      puts "Histogram:"
+      dicoms.print_histogram *stats[:histogram], compact: true
+      0
+    end
+
+    desc "Histogram", "Histogram of one or more DICOM files"
+    option :width,   desc: 'bin width', aliases: '-w'
+    option :compact,   desc: 'compact format', aliases: '-c'
+    def histogram(dicom_dir)
+      DICOM.logger.level = Logger::FATAL
+      settings = {} # TODO: ...
+      dicoms = DicomS.new(settings)
+      width = options.width && options.width.to_f
+      compact = !!options.compact
+      dicoms.histogram dicom_dir, bin_width: width, compact: compact
+      0
+    end
+
+    desc "Information", "Show DICOM metadata"
+    option :output,   desc: 'output directory or file', aliases: '-o'
+    def info(dicom_dir)
+      DICOM.logger.level = Logger::FATAL
+      settings = {} # TODO: ...
+      dicoms = DicomS.new(settings)
+      dicoms.info dicom_dir, output: options.output
       0
     end
 
@@ -145,14 +196,14 @@ class DicomS
     option :max_x_pixels, desc: 'maximum number of pixels in the X direction'
     option :max_y_pixels, desc: 'maximum number of pixels in the Y direction'
     option :max_z_pixels, desc: 'maximum number of pixels in the Z direction'
+    option :maxcols, desc: 'maximum number of image columns'
+    option :maxrows, desc: 'maximum number of image rows'
+    option :mincols, desc: 'minimum number of image columns'
+    option :minrows, desc: 'minimum number of image rows'
     option :reorder, desc: 'reorder slices based on instance number'
     def projection(dicom_dir)
       DICOM.logger.level = Logger::FATAL
       settings = {} # TODO: ...
-      unless File.directory?(dicom_dir)
-        raise Error, set_color("Directory not found: #{dicom_dir}", :red)
-        say options
-      end
       if options.settings_io || options.settings
         cmd_options = CommandOptions[
           settings: options.settings,
@@ -161,7 +212,12 @@ class DicomS
           max_x_pixels: options.max_x_pixels && options.max_x_pixels.to_i,
           max_y_pixels: options.max_y_pixels && options.max_y_pixels.to_i,
           max_z_pixels: options.max_z_pixels && options.max_z_pixels.to_i,
+          maxrows: options.maxrows && options.maxrows.to_i,
+          maxcols: options.maxcols && options.maxcols.to_i,
+          minrows: options.minrows && options.minrows.to_i,
+          mincols: options.mincols && options.mincols.to_i,
           reorder: options.reorder,
+          debug: options.debug
         ]
       else
         cmd_options = CommandOptions[
@@ -173,16 +229,84 @@ class DicomS
           max_x_pixels: options.max_x_pixels && options.max_x_pixels.to_i,
           max_y_pixels: options.max_y_pixels && options.max_y_pixels.to_i,
           max_z_pixels: options.max_z_pixels && options.max_z_pixels.to_i,
+          maxrows: options.maxrows && options.maxrows.to_i,
+          maxcols: options.maxcols && options.maxcols.to_i,
+          minrows: options.minrows && options.minrows.to_i,
+          mincols: options.mincols && options.mincols.to_i,
           reorder: options.reorder,
+          debug: options.debug
         ]
       end
-      unless cmd_options.axial || options.sagittal || options.coronal
-        raise Error, "Must specify at least one projection (axial/sagittal/coronal)"
+      DicomS.handle_errors(cmd_options) do
+        unless File.directory?(dicom_dir)
+          raise Error, set_color("Directory not found: #{dicom_dir}", :red)
+          say options
+        end
+        unless cmd_options.axial || options.sagittal || options.coronal
+          raise Error, "Must specify at least one projection (axial/sagittal/coronal)"
+        end
+        packer = DicomS.new(settings)
+        packer.projection(dicom_dir, cmd_options)
+      end
+    end
+
+    desc "explode DICOM-DIR", "extract all projected images from a DICOM sequence"
+    option :output,   desc: 'output directory', aliases: '-o'
+    option :transfer,   desc: 'transfer method', aliases: '-t', default: 'window'
+    # TODO: add :mip_transfer
+    # option :byte,       desc: 'transfer as bytes', aliases: '-b'
+    option :center,     desc: 'center (window transfer)', aliases: '-c'
+    option :width,      desc: 'window (window transfer)', aliases: '-w'
+    option :ignore_min, desc: 'ignore minimum (global/first/sample transfer)', aliases: '-i'
+    option :samples,    desc: 'number of samples (sample transfer)', aliases: '-s'
+    option :min,   desc: 'minimum value (fixed transfer)'
+    option :max,   desc: 'maximum value (fixed transfer)'
+    option :max_x_pixels, desc: 'maximum number of pixels in the X direction'
+    option :max_y_pixels, desc: 'maximum number of pixels in the Y direction'
+    option :max_z_pixels, desc: 'maximum number of pixels in the Z direction'
+    option :maxcols, desc: 'maximum number of image columns'
+    option :maxrows, desc: 'maximum number of image rows'
+    option :mincols, desc: 'minimum number of image columns'
+    option :minrows, desc: 'minimum number of image rows'
+    option :reorder, desc: 'reorder slices based on instance number'
+    option :no_axial, desc: 'omit axial slices extraction', type: :boolean, default: false
+    option :no_coronal, desc: 'omit coronal slices extraction', type: :boolean, default: false
+    option :no_sagittal, desc: 'omit sagittal slices extraction', type: :boolean, default: false
+    option :no_mip, desc: 'omit mip projection', type: :boolean, default: false
+    option :no_aap, desc: 'omit aap projection', type: :boolean, default: false
+    def explode(dicom_dir)
+      DICOM.logger.level = Logger::FATAL
+      settings = {} # TODO: ...
+      unless File.directory?(dicom_dir)
+        raise Error, set_color("Directory not found: #{dicom_dir}", :red)
+        say options
+      end
+      cmd_options = CommandOptions[
+        settings: options.settings,
+        settings_io: options.settings_io,
+        output: options.output,
+        max_x_pixels: options.max_x_pixels && options.max_x_pixels.to_i,
+        max_y_pixels: options.max_y_pixels && options.max_y_pixels.to_i,
+        max_z_pixels: options.max_z_pixels && options.max_z_pixels.to_i,
+        maxrows: options.maxrows && options.maxrows.to_i,
+        maxcols: options.maxcols && options.maxcols.to_i,
+        minrows: options.minrows && options.minrows.to_i,
+        mincols: options.mincols && options.mincols.to_i,
+        reorder: options.reorder,
+        no_axial: options.no_axial,
+        no_coronal: options.no_coronal,
+        no_sagittal: options.no_sagittal,
+        no_mip: options.no_mip,
+        no_aap: options.no_aap,
+        debug: options.debug
+      ]
+      unless options.settings_io || options.settings
+        cmd_options.merge! transfer: DicomS.transfer_options(options)
+      end
+      DicomS.handle_errors(cmd_options) do
+        packer = DicomS.new(settings)
+        packer.explode(dicom_dir, cmd_options)
       end
-      packer = DicomS.new(settings)
-      packer.projection(dicom_dir, cmd_options)
-      # rescue => raise Error?
-      0
     end
 
     desc "Remap DICOM-DIR", "convert DICOM pixel values"
@@ -199,18 +323,19 @@ class DicomS
     def remap(dicom_dir)
       DICOM.logger.level = Logger::FATAL
       settings = {} # TODO: ...
-      unless File.directory?(dicom_dir)
-        raise Error, set_color("Directory not found: #{dicom_dir}", :red)
-        say options
-      end
-      packer = DicomS.new(settings)
-      packer.remap(
-        dicom_dir,
+      cmd_options =  {
         transfer: DicomS.transfer_options(options),
-        output: options.output
-      )
-      # rescue => raise Error?
-      0
+        output: options.output,
+        debug: options.debug
+      }
+      DicomS.handle_errors(cmd_options) do
+        unless File.directory?(dicom_dir)
+          raise Error, set_color("Directory not found: #{dicom_dir}", :red)
+          say options
+        end
+        packer = DicomS.new(settings)
+        packer.remap(dicom_dir, cmd_options)
+      end
     end
   end
 

data/lib/dicoms/explode.rb

@@ -0,0 +1,421 @@
+require 'rmagick'
+
+class DicomS
+  # Extract all projected views (all slices in the three axis,
+  # plus aap and mip projectios)
+  def explode(dicom_directory, options = {})
+    options = CommandOptions[options]
+
+    progress = Progress.new('projecting', options)
+    progress.begin_subprocess 'reading_metadata', 1
+
+    # Create sequence without a transfer strategy
+    # (identity strategy with rescaling would also do)
+    # so that we're working with Hounsfield units
+    sequence = Sequence.new(
+      dicom_directory,
+      reorder: options[:reorder]
+    )
+
+    slice_transfer = define_transfer(
+      options,
+      :window,
+      output: :unsigned
+    )
+    mip_transfer = define_transfer(
+      { transfer: options[:mip_transfer] },
+      :fixed,
+      min: -1000, max: 2000,
+      output: :unsigned
+    )
+    aap_transfer = Transfer.strategy :fixed, min: 0.0, max: 1.0, float: true, output: :unsigned
+
+    extract_dir = options.path_option(
+      :output, File.join(File.expand_path(dicom_directory), 'images')
+    )
+    FileUtils.mkdir_p extract_dir
+
+    if sequence.metadata.lim_max <= 255
+      bits = 8
+    else
+      bits = 16
+    end
+
+    scaling = projection_scaling(sequence.metadata, options)
+    sequence.metadata.merge! scaling
+    scaling = Settings[scaling]
+
+    reverse_x = sequence.metadata.reverse_x.to_i == 1
+    reverse_y = sequence.metadata.reverse_y.to_i == 1
+    reverse_z = sequence.metadata.reverse_z.to_i == 1
+
+    maxx = sequence.metadata.nx
+    maxy = sequence.metadata.ny
+    maxz = sequence.metadata.nz
+
+    # minimum and maximum slices with non-(almost)-blank contents
+    minx_contents = maxx
+    maxx_contents = 0
+    miny_contents = maxy
+    maxy_contents = 0
+    minz_contents = maxz
+    maxz_contents = 0
+
+    axial_zs = options.no_axial ? [] : (0...maxz)
+    sagittal_xs = options.no_sagittal ? [] : (0...maxx)
+    coronal_ys = options.no_coronal ? [] : (0...maxy)
+
+    # Will determine first and last slice with noticeable contents in each axis
+    # Slices outside the range won't be generated to save space
+    # This information will also be used for the app projection
+    minx_contents = maxx
+    maxx_contents = 0
+    miny_contents = maxy
+    maxy_contents = 0
+    minz_contents = maxz
+    maxz_contents = 0
+
+    n_slices = axial_zs.size + sagittal_xs.size + coronal_ys.size
+    n_projections = 0
+    n_projections += 3 unless options.no_mip
+    n_projections += 3 unless options.no_aap
+
+    progress.begin_subprocess 'generating_volume', 50, maxz
+
+    # Load all the slices into a floating point 3D array
+    volume = NArray.sfloat(maxx, maxy, maxz)
+    keeping_path do
+      sequence.each do |dicom, z, file|
+        slice = sequence.dicom_pixels(dicom)
+        volume[true, true, z] = slice
+        progress.update_subprocess z
+      end
+    end
+
+    maxv = volume.max
+
+    # Generate slices
+    slices_percent = n_projections > 0 ? -70 : 100
+    progress.begin_subprocess 'generating_slices', slices_percent, n_slices if n_slices > 0
+    axial_zs.each_with_index do |z, i|
+      slice = volume[true, true, z]
+      minz_contents, maxz_contents = update_min_max_contents(
+        z, slice.max, maxv, minz_contents, maxz_contents
+      )
+      next unless (minz_contents..maxz_contents).include?(z)
+      output_image = output_file_name(extract_dir, 'axial_', z.to_s)
+      save_transferred_pixels sequence, slice_transfer, slice, output_image,
+        bit_depth: bits, reverse_x: reverse_x, reverse_y: reverse_y,
+        cols: scaling.scaled_nx, rows: scaling.scaled_ny,
+        normalize: false
+      progress.update_subprocess i
+    end
+    sagittal_xs.each_with_index do |x, i|
+      slice = volume[x, true, true]
+      minx_contents, maxx_contents = update_min_max_contents(
+        x, slice.max, maxv, minx_contents, maxx_contents
+      )
+      next unless (minx_contents..maxx_contents).include?(x)
+      output_image = output_file_name(extract_dir, 'sagittal_', x.to_s)
+      save_transferred_pixels sequence, slice_transfer, slice, output_image,
+        bit_depth: bits, reverse_x: !reverse_y, reverse_y: !reverse_z,
+        cols: scaling.scaled_ny, rows: scaling.scaled_nz,
+        normalize: false
+      progress.update_subprocess axial_zs.size + i
+    end
+    coronal_ys.each_with_index do |y, i|
+      slice = volume[true, y, true]
+      miny_contents, maxy_contents = update_min_max_contents(
+        y, slice.max, maxv, miny_contents, maxy_contents
+      )
+      next unless (miny_contents..maxy_contents).include?(y)
+      output_image = output_file_name(extract_dir, 'coronal_', y.to_s)
+      save_transferred_pixels sequence, slice_transfer, slice, output_image,
+        bit_depth: bits, reverse_x: reverse_x, reverse_y: !reverse_z,
+        cols: scaling.scaled_nx, rows: scaling.scaled_nz,
+        normalize: false
+      progress.update_subprocess axial_zs.size + sagittal_xs.size + i
+    end
+
+    progress.begin_subprocess 'generating_projections', 100, n_projections
+
+    projection_count = 0
+
+    unless options.no_mip
+      # Generate MIP projections
+      slice = maximum_intensity_projection(volume, Z_AXIS)
+      output_image = output_file_name(extract_dir, 'axial_', 'mip')
+      save_transferred_pixels sequence, mip_transfer, slice, output_image,
+        bit_depth: bits, reverse_x: reverse_x, reverse_y: reverse_y,
+        cols: scaling.scaled_nx, rows: scaling.scaled_ny,
+        normalize: true
+      projection_count += 1
+      progress.update_subprocess projection_count
+
+      slice = maximum_intensity_projection(volume, Y_AXIS)
+      output_image = output_file_name(extract_dir, 'coronal_', 'mip')
+      save_transferred_pixels sequence, mip_transfer, slice, output_image,
+        bit_depth: bits, reverse_x: reverse_x, reverse_y: !reverse_z,
+        cols: scaling.scaled_nx, rows: scaling.scaled_nz,
+        normalize: true
+      projection_count += 1
+      progress.update_subprocess projection_count
+
+      slice = maximum_intensity_projection(volume, X_AXIS)
+      output_image = output_file_name(extract_dir, 'sagittal_', 'mip')
+      save_transferred_pixels sequence, mip_transfer, slice, output_image,
+        bit_depth: bits, reverse_x: !reverse_y, reverse_y: !reverse_z,
+        cols: scaling.scaled_ny, rows: scaling.scaled_nz,
+        normalize: true
+      projection_count += 1
+      progress.update_subprocess projection_count
+    end
+
+    unless options.no_aap
+      # Generate AAP Projections
+      c = dicom_window_center(sequence.first)
+      w = dicom_window_width(sequence.first)
+      dx = sequence.metadata.dx
+      dy = sequence.metadata.dy
+      dz = sequence.metadata.dz
+      numx = maxx_contents - minx_contents + 1 if minx_contents <= maxx_contents
+      numy = maxy_contents - miny_contents + 1 if miny_contents <= maxy_contents
+      numz = maxz_contents - minz_contents + 1 if minz_contents <= maxz_contents
+      daap = DynamicAap.new(
+        volume,
+        center: c, width: w, dx: dx, dy: dy, dz: dz,
+        numx: numx, numy: numy, numz: numz
+      )
+      slice = daap.view(Z_AXIS)
+      output_image = output_file_name(extract_dir, 'axial_', 'aap')
+      save_transferred_pixels sequence, aap_transfer, slice, output_image,
+        bit_depth: bits, reverse_x: reverse_x, reverse_y: reverse_y,
+        cols: scaling.scaled_nx, rows: scaling.scaled_ny,
+        normalize: true
+      projection_count += 1
+      progress.update_subprocess projection_count
+
+      slice = daap.view(Y_AXIS)
+      output_image = output_file_name(extract_dir, 'coronal_', 'aap')
+      save_transferred_pixels sequence, aap_transfer, slice, output_image,
+        bit_depth: bits, reverse_x: reverse_x, reverse_y: !reverse_z,
+        cols: scaling.scaled_nx, rows: scaling.scaled_nz,
+        normalize: true
+      projection_count += 1
+      progress.update_subprocess projection_count
+
+      slice = daap.view(X_AXIS)
+      output_image = output_file_name(extract_dir, 'sagittal_', 'aap')
+      save_transferred_pixels sequence, aap_transfer, slice, output_image,
+        bit_depth: bits, reverse_x: !reverse_y, reverse_y: !reverse_z,
+        cols: scaling.scaled_ny, rows: scaling.scaled_nz,
+        normalize: true
+      projection_count += 1
+      progress.update_subprocess projection_count
+    end
+
+    volume = nil
+    sequence.metadata.merge!(
+      axial_first: minz_contents, axial_last: maxz_contents,
+      coronal_first: miny_contents, coronal_last: maxy_contents,
+      sagittal_first: minx_contents, sagittal_last: maxx_contents
+    )
+    options.save_settings 'projection', sequence.metadata
+    progress.finish
+  end
+
+  def power(data, factor)
+    NMath.exp(factor*NMath.log(data))
+  end
+
+  def save_transferred_pixels(sequence, transfer, pixels, output_image, options)
+    dicom = sequence.first
+    min, max = transfer.min_max(sequence)
+    pixels = transfer.transfer_rescaled_pixels(dicom, pixels, min, max)
+    save_pixels pixels, output_image, options
+  end
+
+  class DynamicAap
+
+    PRE_GAMMA = 8
+    SUM_NORMALIZATION = false
+    IMAGE_GAMMA = nil
+    IMAGE_ADJUSTMENT = true
+    WINDOW_BY_DEFAULT = true
+    NO_WINDOW = true
+    IMAGE_CONTRAST = nil
+
+    def initialize(data, options)
+      center = options[:center]
+      width = options[:width]
+      if center && width && !NO_WINDOW
+        # 1. Window level normalization
+        if options[:window_sigmod_gamma]
+          # 1.a using sigmod
+          gamma = options[:window_sigmod_gamma] || 3.0
+          k0 = options[:window_sigmod_k0] || 0.06
+          sigmoid = Sigmoid.new(center: center, width: width, gamma: gamma, k0: k0)
+          data = sigmoid[data]
+        elsif options[:k0] || WINDOW_BY_DEFAULT
+          # 1.b simpler linear pseudo-sigmoid
+          max = data.max
+          min = data.min
+          k0 = options[:k0] || 0.1
+          v_lo = center - width*0.5
+          v_hi = center + width*0.5
+          low_part = (data < v_lo)
+          high_part = (data > v_hi)
+          mid_part = (low_part | high_part).not
+
+          data[low_part] -= min
+          data[low_part] *= k0/(v_lo - min)
+
+          data[high_part] -= v_hi
+          data[high_part] *= k0/(max - v_hi)
+          data[high_part] += 1.0 - k0
+
+          data[mid_part] -= v_lo
+          data[mid_part] *= (1.0 - 2*k0)/width
+          data[mid_part] += k0
+        else
+          # 1.c clip to window (like 1.b with k0=0)
+          max = data.max
+          min = data.min
+          k0 = options[:k0] || 0.02
+          v_lo = center - width*0.5
+          v_hi = center + width*0.5
+
+          low_part = (data < v_lo)
+          high_part = (data > v_hi)
+          mid_part = (low_part | high_part).not
+
+          data[low_part] = 0
+          data[high_part] = 1
+
+          data[mid_part] -= v_lo
+          data[mid_part] *= 1.0/width
+        end
+      else
+        # Normalize to 0-1
+        data.add! -data.min
+        data.mul! 1.0/data.max
+      end
+
+      if PRE_GAMMA
+        if [2, 4, 8].include?(PRE_GAMMA)
+          g = PRE_GAMMA
+          while g > 1
+            data.mul! data
+            g /= 2
+          end
+        else
+          data = power(data, PRE_GAMMA)
+        end
+      end
+
+      @data = data
+      @ref_num = 512
+      @dx = options[:dx]
+      @dy = options[:dy]
+      @dz = options[:dz]
+      @numx = options[:numx] || @ref_num
+      @numy = options[:numy] || @ref_num
+      @numz = options[:numz] || @ref_num
+      @max_output_level = options[:max] || 1.0
+    end
+
+    def view(axis)
+      case axis
+      when Z_AXIS
+        d = @dz
+        num = @numz
+      when Y_AXIS
+        d = @dy
+        num = @numy
+      when X_AXIS
+        d = @dx
+        num = @numx
+      end
+
+      s = @data.sum(axis)
+      s.div! s.max if SUM_NORMALIZATION
+      s.mul! -d*@ref_num/num
+      s = NMath.exp(s)
+
+      if IMAGE_GAMMA
+        s.mul! -1
+        s.add! 1
+        s = power(s, IMAGE_GAMMA)
+        contrast! s, IMAGE_CONTRAST if IMAGE_CONTRAST
+        s.mul! @max_output_level if @max_output_level != 1
+      elsif IMAGE_ADJUSTMENT
+        s = adjust(s)
+        contrast! s, IMAGE_CONTRAST if IMAGE_CONTRAST
+        s.mul! @max_output_level if @max_output_level != 1
+      else
+        # since contrast is vertically symmetrical we can apply it
+        # to the negative image
+        contrast! s, IMAGE_CONTRAST if IMAGE_CONTRAST
+        s.mul! -@max_output_level
+        s.add! @max_output_level
+      end
+      s
+    end
+
+    private
+
+    def contrast!(data, factor)
+      # We use this piecewise sigmoid function:
+      #
+      # * f(x)       for x <= 1/2
+      # * 1 - f(1-x) for x > 1/2
+      #
+      # With f(x) = pow(2, factor-1)*pow(x, factor)
+      # The pow() function will be computed as:
+      # pow(x, y) = exp(y*log(x))
+      #
+      # TODO: consider this alternative:
+      # f(x) = (factor*x - x)/(2*factor*x - factor - 1
+      #)
+      factor = factor.round
+      k = 2**(factor-1)
+      lo = data <= 0.5
+      hi = data >  0.5
+      data[lo] = NMath.exp(factor*NMath.log(data[lo]))*k
+      data[hi] = (-NMath.exp(NMath.log((-data[hi]) + 1)*factor))*k+1
+      data
+    end
+
+    def power(data, factor)
+      NMath.exp(factor*NMath.log(data))
+    end
+
+    def adjust(pixels)
+      min = pixels.min
+      max = pixels.max
+      avg = pixels.mean
+      # pixels.sbt! min
+      # pixels.mul! 1.0/(max - min)
+      pixels.sbt! max
+      pixels.div! min - max
+
+      # HUM: target 0.7; frac: target 0.2
+      discriminator = (pixels > 0.83).count_true.to_f / (pixels > 0.5).count_true.to_f
+
+      avg_target = 1.0 - discriminator**0.9
+      x0 = 0.67
+      y0 = 0.72
+      gamma = 3.0
+      k = - x0**gamma/Math.log(1-y0)
+      avg_target = 1.0 - Math.exp(-avg_target**gamma/k)
+
+      if avg_target > 0
+        g = Math.log(avg_target)/Math.log(avg)
+        power(pixels, g)
+      else
+        pixels
+      end
+    end
+  end
+
+end