dicoms 1.0.0

data/README.md

@@ -0,0 +1,48 @@
+# DicomS: DICOM Series toolkit
+
+DicomS is a Ruby toolkit for working with DICOM (CT/MRI) Series
+(image sequences that compose a volume of density information).
+
+It can be used through a command line interface
+by using the `dicoms` executable script, or
+from a Ruby program through the 'DicomS' class interface (API).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dicoms'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dicoms
+
+### Requirements
+
+* [FFmpeg](https://www.ffmpeg.org/) (the command line tools).
+* [ImageMagick](http://www.imagemagick.org/) (the library whichs is used by RMagick)
+
+## Usage
+
+The `dicoms` executable provides the following commands:
+
+* Extract images: `dicoms extract DICOM-DIR ...`
+* Generate projected images (on axial, sagittal and coronal planes):
+  `dicoms project DICOM-DIR ...`
+* Pack a DICOM series in compact form: `dicoms pack DICOM-DIR ...`
+* Unpack a packed DICOM series: `dicoms unpack PACKED-FILE ...`
+
+Use the command to get further help.
+
+## License
+
+Copyright (c) 2015 Javier Goizueta
+
+This software is licensed under the
+[GNU General Public License](./LICENSE.md) version 3.

data/Rakefile

@@ -0,0 +1,22 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = DicomS::VERSION
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "DicomS #{version}"
+  rdoc.main = "README.md"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.markup = 'markdown' if rdoc.respond_to?(:markup)
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "dicompack"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/dicoms.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dicoms/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "dicoms"
+  spec.version       = DicomS::VERSION
+  spec.authors       = ["Javier Goizueta"]
+  spec.email         = ["jgoizueta@gmail.com"]
+
+  spec.summary       = %q{DICOM Series toolkit}
+  spec.description   = %q{Toolkit for working with DICOM image sequences}
+  spec.homepage      = "https://gitlab.com/jgoizueta/dicompacker"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'dicom'
+  # spec.add_dependency 'dicom', 'mini_magick'
+  spec.add_dependency 'rmagick', '~> 2.14'
+  spec.add_dependency 'sys_cmd', '>= 0.2.1'
+  spec.add_dependency 'modalsettings', '~> 1.0.1'
+  spec.add_dependency 'narray', '~> 0.6'
+  spec.add_dependency 'thor', '~> 0.19'
+
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+end

data/exe/dicoms

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+
+require 'dicoms'
+require 'dicoms/cli'
+
+DicomS::CLI.start ARGV

data/lib/dicoms.rb

@@ -0,0 +1,67 @@
+require 'fileutils'
+require 'dicom'
+require 'modalsettings'
+require 'sys_cmd'
+require 'narray'
+
+require "dicoms/version"
+require "dicoms/meta_codec"
+require "dicoms/support"
+require "dicoms/shared_files"
+require "dicoms/shared_settings"
+require "dicoms/progress"
+require "dicoms/command_options"
+require "dicoms/sequence"
+require "dicoms/transfer"
+require "dicoms/extract"
+require "dicoms/pack"
+require "dicoms/unpack"
+require "dicoms/stats"
+require "dicoms/projection"
+require "dicoms/remap"
+
+class DicomS
+
+  def initialize(options = {})
+    @settings = Settings[options]
+
+    if @settings.image_processor
+      DICOM.image_processor = @settings.image_processor.to_sym
+    end
+
+    @ffmpeg_options = { 'ffmpeg' => @settings.ffmpeg }
+    # TODO: use quality level settings
+    # TODO: temporary strategy option (:current_dir, :system_tmp, ...)
+  end
+
+  attr_reader :settings
+
+  extend Support
+  include Support
+
+  private
+
+  def meta_codec
+    MetaCodec.new
+  end
+
+  # def optimize_dynamic_range(data, output_min, output_max, options = {})
+  #   minimum, maximum = options[:range]
+  #   r = (maximum - minimum).to_f
+  #   data -= minimum
+  #   data *= (output_max - output_min)/r
+  #   data += output_min
+  #   data[data < output_min] = output_min
+  #   data[data > output_max] = output_max
+  #   data
+  # end
+
+  def check_command(command)
+    unless command.success?
+      puts "Error executing:"
+      puts "  #{command}"
+      puts command.error_output
+      exit 1
+    end
+  end
+end

data/lib/dicoms/cli.rb

@@ -0,0 +1,241 @@
+require 'thor'
+
+class DicomS
+  class CLI < Thor
+    check_unknown_options!
+
+    def self.exit_on_failure?
+      true
+    end
+
+    desc 'version', "Display DicomS version"
+    map %w(-v --version) => :version
+    def version
+      say "dicoms #{VERSION}"
+    end
+
+    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'
+
+    desc "pack DICOM-DIR", "pack a DICOM directory"
+    option :output,   desc: 'output file', aliases: '-o'
+    option :tmp,      desc: 'temporary directory'
+    option :transfer,   desc: 'transfer method', aliases: '-t', default: 'sample'
+    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 :reorder, desc: 'reorder slices based on instance number'
+    def pack(dicom_dir)
+      DICOM.logger.level = Logger::FATAL
+      strategy_parameters = {
+        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
+      ]
+      packer = DicomS.new(settings)
+      packer.pack dicom_dir, cmd_options
+      # rescue => raise Error?
+      0
+    end
+
+    desc "unpack dspack", "unpack a dspack file"
+    option :output,   desc: 'output directory', aliases: '-o'
+    option :dicom,    desc: 'dicom format output directory', aliases: '-d'
+    # 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,
+        settings: options.settings,
+        settings_io: options.settings_io,
+        output: options.output,
+        dicom_output: options.dicom
+      )
+      # rescue => raise Error?
+      0
+    end
+
+    desc "extract DICOM-DIR", "extract images from a set of DICOM files"
+    option :output,   desc: 'output directory', aliases: '-o'
+    option :transfer,   desc: 'transfer method', aliases: '-t', default: 'window'
+    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 :raw,   desc: 'generate raw output', aliases: '-r'
+    option :big, desc: 'big-endian raw output'
+    option :little, desc: 'little-endian raw output'
+    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
+        raw = true
+        big_endian = true
+      elsif options.little
+        raw = true
+        little_endian = true
+      end
+
+      packer = DicomS.new(settings)
+      packer.extract(
+        dicom_dir,
+        transfer: DicomS.transfer_options(options),
+        output: options.output,
+        raw: raw, big_endian: big_endian, little_endian: little_endian
+      )
+      # rescue => raise Error?
+      0
+    end
+
+    desc "Level stats", "Level limits of one or more DICOM files"
+    def stats(dicom_dir)
+      DICOM.logger.level = Logger::FATAL
+      settings = {} # TODO: ...
+      dicoms = DicomS.new(settings)
+      stats = dicoms.stats dicom_dir
+      puts "Aggregate values for #{stats[:n]} DICOM files:"
+      puts "  Minimum level: #{stats[:min]}"
+      puts "  Next minimum level: #{stats[:next_min]}"
+      puts "  Maximum level: #{stats[:max]}"
+      0
+    end
+
+    desc "projection DICOM-DIR", "extract projected images from a DICOM sequence"
+    option :output,   desc: 'output directory', aliases: '-o'
+    option :axial,    desc: 'N for single slice, * all, C center, mip or aap for volumetric aggregation'
+    option :sagittal, desc: 'N for single slice, * all, C center, mip or aap for volumetric aggregation'
+    option :coronal,  desc: 'N for single slice, * all, C center, mip or aap for volumetric aggregation'
+    option :transfer,   desc: 'transfer method', aliases: '-t', default: 'window'
+    # 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 :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,
+          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,
+          reorder: options.reorder,
+        ]
+      else
+        cmd_options = CommandOptions[
+          transfer: DicomS.transfer_options(options),
+          output: options.output,
+          axial: options.axial == 'axial' ? 'mip' : options.axial,
+          sagittal: options.sagittal == 'sagittal' ? 'mip' : options.sagittal,
+          coronal: options.coronal == 'coronal' ? 'mip' : options.coronal,
+          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,
+          reorder: options.reorder,
+        ]
+      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)
+      # rescue => raise Error?
+      0
+    end
+
+    desc "Remap DICOM-DIR", "convert DICOM pixel values"
+    option :output,     desc: 'output directory', aliases: '-o'
+    option :transfer,   desc: 'transfer method', aliases: '-t', default: 'identity'
+    option :unsigned,   desc: 'transfer as unsigned', aliases: '-u'
+    # 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)'
+    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,
+        transfer: DicomS.transfer_options(options),
+        output: options.output
+      )
+      # rescue => raise Error?
+      0
+    end
+  end
+
+  class <<self
+    def transfer_options(options)
+      strategy = options.transfer.to_sym
+      params = {}
+      params[:output] = :unsigned if options.unsigned
+      params[:output] = :byte     if options.byte
+      params[:center] = options.center.to_f if options.center
+      params[:width] = options.width.to_f if options.width
+      if options.ignore_min
+        params[:ignore_min] = true
+      elsif [:global, :first, :sample].include?(strategy)
+        params[:ignore_min] = false
+      end
+      params[:max_files] = options.samples if options.samples
+      params[:min] = options[:min].to_f if options[:min]
+      params[:max] = options[:max].to_f if options[:max]
+
+      if params.empty?
+        strategy
+      else
+        [strategy, params]
+      end
+    end
+  end
+end