dcmtk 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 02e561669b448629495a372ce64dcc1fb60f2b79f2d8d3be5ec0994c8f398378
+  data.tar.gz: d0883775324f3e65da156289a5a839cbd19e511ada8a3c0ac0b7dbd49f1d1757
+SHA512:
+  metadata.gz: 585a11d3adecc9ee835cd4b5b473ad2553d3015d99054c7cc933fb1db1c32eee7fea880abb4d100164d00f2d8c61831b30edb41d2584f2994df6bb25f17e061c
+  data.tar.gz: 73cb9ff4b1750a1fb460ce2e0be672f5891c22e56c8c90c2ecc5a99d3d642185d8c87e921ba59d40af5e1a2ec09b117e66cc00813d4f0e7549e4e429cfff4fe5

data/LICENSE

@@ -0,0 +1,18 @@
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,177 @@
+# DCMTK
+
+A Ruby wrapper for [DCMTK tools](https://dicom.offis.de/dcmtk.php.en) - specifically `dcmj2pnm` or `dcm2img` for converting DICOM medical files to standard image formats.
+
+## Information
+
+Inspired by MiniMagick Ruby gem, this gem provides a DSL for working with DCMTK command-line tools.
+
+## Requirements
+
+DCMTK command-line tools must be installed. You can check if you have it installed by running:
+
+```sh
+$ dcmj2pnm --version
+$dcmtk: dcmj2pnm v3.6.7 2022-04-22
+```
+
+### Installation
+
+On macOS:
+```sh
+brew install dcmtk
+```
+
+On Ubuntu/Debian:
+```sh
+apt-get install dcmtk
+```
+
+## Gem Installation
+
+Add the gem to your Gemfile:
+
+```rb
+gem "dcmtk"
+```
+
+## Usage
+
+Let's first see a basic example - converting a DICOM file to PNG:
+
+```rb
+require "dcmtk"
+
+package = DCMTK::Package.open("scan.dcm")
+package.convert(format: :png)
+package.write("output.png")
+```
+
+`DCMTK::Package.open` makes a copy of the package, and further methods modify that copy (the original stays untouched). The writing part is necessary because the copy is just temporary, it gets garbage collected when we lose reference to the package.
+
+On the other hand, if we want the original package to actually *get* modified, we can use `DCMTK::Package.new`:
+
+```rb
+package = DCMTK::Package.new("scan.dcm")
+package.convert(format: :png)
+# Output file is created at scan.png (same name, different extension)
+```
+
+### Supported Formats
+
+The gem supports converting DICOM files to these formats:
+
+| Format | Symbol | dcmj2pnm Flag |
+|--------|--------|---------------|
+| PNG    | `:png` | `+on`         |
+| BMP    | `:bmp` | `+ob`         |
+| JPEG   | `:jpeg`| `+oj`         |
+
+```rb
+# Convert to different formats
+package.convert(format: :png)   # PNG output
+package.convert(format: :bmp)   # BMP output
+package.convert(format: :jpeg)  # JPEG output
+```
+
+### Configuration
+
+```rb
+DCMTK.configure do |config|
+  config.timeout = 5
+  config.whiny = true  # raise errors on non-zero exit codes
+  config.cli = "dcmj2pnm"  # force specific CLI (see below)
+end
+```
+
+### CLI Tool Selection
+
+By default, the gem auto-detects which CLI tool to use:
+- If `dcm2img` is found in PATH, it will be used
+- Otherwise, falls back to `dcmj2pnm`
+
+You can force a specific CLI tool:
+
+```rb
+# Force dcmj2pnm
+DCMTK.configure do |config|
+  config.cli = "dcmj2pnm"
+end
+
+# Force dcm2img
+DCMTK.configure do |config|
+  config.cli = "dcm2img"
+end
+
+# Check which CLI is being used
+DCMTK.convert_cli #=> "dcm2img" or "dcmj2pnm"
+```
+
+### Logging
+
+You can choose to log DCMTK commands and their execution times:
+
+```rb
+DCMTK.logger.level = Logger::DEBUG
+```
+```
+D, [2024-01-15T12:07:39.240238 #59063] DEBUG -- : [0.11s] dcmj2pnm +on /tmp/dcmtk20240115-59063-8yvk5s.dcm /tmp/output.png
+```
+
+In Rails you'll probably want to set `DCMTK.logger = Rails.logger`.
+
+### Metal
+
+If you want to be close to the metal, you can use DCMTK's command-line tools directly:
+
+```rb
+DCMTK::Tool::Convert.new do |convert|
+  convert.format(:png)
+  convert << "input.dcm"
+  convert << "output.png"
+end #=> `dcmj2pnm +on input.dcm output.png`
+
+# OR
+
+convert = DCMTK::Tool::Convert.new
+convert.format(:jpeg)
+convert << "input.dcm"
+convert << "output.jpg"
+convert.call #=> `dcmj2pnm +oj input.dcm output.jpg`
+```
+
+You can also pass additional flags using method_missing:
+
+```rb
+DCMTK::Tool::Convert.new do |convert|
+  convert.format(:png)
+  convert.verbose  # adds --verbose flag
+  convert << "input.dcm"
+  convert << "output.png"
+end
+```
+
+## Troubleshooting
+
+### Errors being raised when they shouldn't
+
+If you're using the tool directly, you can pass `whiny: false` value to the constructor:
+
+```rb
+DCMTK::Tool::Convert.new(whiny: false) do |convert|
+  convert.help
+end
+```
+
+### Command not found
+
+Make sure DCMTK tools are installed and either `dcm2img` or `dcmj2pnm` is in your PATH:
+
+```sh
+which dcm2img
+which dcmj2pnm
+```
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,4 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+$:.unshift 'lib'

data/lib/dcmtk/configuration.rb

@@ -0,0 +1,64 @@
+require 'dcmtk/utilities'
+require 'logger'
+
+module DCMTK
+  module Configuration
+    ##
+    # If you don't want commands to take too long, you can set a timeout (in
+    # seconds).
+    #
+    # @return [Integer]
+    #
+    attr_accessor :timeout
+    ##
+    # Logger for debug output, default is `Logger.new(STDOUT)`, but
+    # you can override it, for example if you want the logs to be written to
+    # a file.
+    #
+    # @return [Logger]
+    #
+    attr_accessor :logger
+
+    ##
+    # If set to `true`, it will raise errors on non-zero exit codes.
+    # Defaults to `true`.
+    #
+    # @return [Boolean]
+    #
+    attr_accessor :whiny
+
+    ##
+    # Instructs DCMTK how to execute the shell commands. Available
+    # APIs are "open3" (default) and "posix-spawn" (requires the "posix-spawn"
+    # gem).
+    #
+    # @return [String]
+    #
+    attr_accessor :shell_api
+
+    ##
+    # Force a specific CLI command for conversion.
+    # When nil (default), auto-detects: dcm2img if available, otherwise dcmj2pnm.
+    #
+    # @return [String, nil]
+    #
+    attr_accessor :cli
+
+    def self.extended(base)
+      base.whiny = true
+      base.shell_api = "open3"
+      base.logger = Logger.new($stdout).tap { |l| l.level = Logger::INFO }
+    end
+
+    ##
+    # @yield [self]
+    # @example
+    #   DCMTK.configure do |config|
+    #     config.timeout = 5
+    #   end
+    #
+    def configure
+      yield self
+    end
+  end
+end

data/lib/dcmtk/package.rb

@@ -0,0 +1,157 @@
+require 'tempfile'
+require 'stringio'
+require 'pathname'
+require 'fileutils'
+
+require 'dcmtk/utilities'
+
+module DCMTK
+  class Package
+
+    ##
+    # This is the primary loading method used by all of the other class
+    # methods.
+    #
+    # Use this to pass in a stream object. Must respond to #read(size) or be a
+    # binary string object (BLOB)
+    #
+    # @param stream [#read, String] Some kind of stream object that needs
+    #   to be read or is a binary String blob
+    # @param ext [String] A manual extension to use for reading the file. Not
+    #   required, but if you are having issues, give this a try.
+    # @return [DCMTK::Package]
+    #
+    def self.read(stream, ext = nil)
+      if stream.is_a?(String)
+        stream = StringIO.new(stream)
+      end
+
+      create(ext) { |file| IO.copy_stream(stream, file) }
+    end
+
+    ##
+    # Opens a specific file either on the local file system.
+    # Use this if you don't want to overwrite file.
+    #
+    # Extension is either guessed from the path or you can specify it as a
+    # second parameter.
+    #
+    # @param path [String] Either a local file path
+    # @param ext [String] Specify the extension you want to read it as
+    # @param options [Hash] Specify options for the open method
+    # @return [DCMTK::Package] The loaded file
+    #
+    def self.open(path, ext = nil, options = {})
+      options, ext = ext, nil if ext.is_a?(Hash)
+
+      # Don't use Kernel#open, but reuse its logic
+      openable =
+        if path.respond_to?(:open)
+          path
+        else
+          options = { binmode: true }.merge(options)
+          Pathname(path)
+        end
+
+      ext ||= File.extname(openable.to_s)
+      ext.sub!(/:.*/, '') # hack for filenames that include a colon
+
+      openable.open(**options) { |file| read(file, ext) }
+    end
+
+    ##
+    # Used to create a new file object data-copy.
+    #
+    # Takes an extension in a block and can be used to build a new file
+    # object. Used by both {.open} and {.read} to create a new object. Ensures
+    # we have a good tempfile.
+    #
+    # @param ext [String] Specify the extension you want to read it as
+    # @yield [Tempfile] You can #write bits to this object to create the new
+    #   file
+    # @return [DCMTK::Package] The created file
+    #
+    def self.create(ext = nil, &block)
+      tempfile = DCMTK::Utilities.tempfile(ext.to_s.downcase, &block)
+
+      new(tempfile.path, tempfile)
+    end
+
+    attr_reader :path
+    attr_reader :tempfile
+
+    def initialize(input_path, tempfile = nil)
+      @path = input_path.to_s
+      @tempfile = tempfile
+    end
+
+    def to_blob
+      File.binread(path)
+    end
+
+    ##
+    # Converts the DICOM file to the specified image format.
+    #
+    # @param format [Symbol] The output format (:png, :bmp, :jpeg)
+    # @return [self]
+    #
+    def convert(format: :png)
+      ext = ".#{format}"
+
+      if @tempfile
+        new_tempfile = DCMTK::Utilities.tempfile(ext)
+        new_path = new_tempfile.path
+      else
+        new_path = Pathname(path).sub_ext(ext).to_s
+      end
+
+      input_path = path.dup
+
+      DCMTK::Tool::Convert.new do |convert|
+        convert.format(format)
+        convert << input_path
+        convert << new_path
+      end
+
+      if @tempfile
+        destroy!
+        @tempfile = new_tempfile
+      else
+        File.delete(path) unless path == new_path
+      end
+
+      path.replace new_path
+
+      self
+    rescue DCMTK::Error => e
+      new_tempfile.unlink if new_tempfile && @tempfile != new_tempfile
+      raise e
+    end
+
+    ##
+    # Writes the temporary file out to either a file location (by passing in a
+    # String) or by passing in a Stream that you can #write(chunk) to
+    # repeatedly
+    #
+    # @param output_to [String, Pathname, #read] Some kind of stream object
+    #   that needs to be read or a file path as a String
+    #
+    def write(output_to)
+      case output_to
+      when String, Pathname
+        FileUtils.copy_file path, output_to unless path == output_to.to_s
+      else
+        IO.copy_stream File.open(path, "rb"), output_to
+      end
+    end
+
+    ##
+    # Destroys the tempfile (created by {.open}) if it exists.
+    #
+    def destroy!
+      if @tempfile
+        @tempfile.unlink
+      end
+    end
+  end
+end

data/lib/dcmtk/shell.rb

@@ -0,0 +1,78 @@
+require "timeout"
+require "benchmark"
+
+module DCMTK
+  ##
+  # Sends commands to the shell (more precisely, it sends commands directly to
+  # the operating system).
+  #
+  # @private
+  #
+  class Shell
+
+    def run(command, options = {})
+      stdout, stderr, status = execute(command, stdin: options[:stdin])
+
+      if status != 0 && options.fetch(:whiny, DCMTK.whiny)
+        fail DCMTK::Error, "`#{command.join(" ")}` failed with error:\n#{stderr}"
+      end
+
+      $stderr.print(stderr) unless options[:stderr] == false
+
+      [stdout, stderr, status]
+    end
+
+    def execute(command, options = {})
+      stdout, stderr, status =
+        log(command.join(" ")) do
+          send("execute_#{DCMTK.shell_api.gsub("-", "_")}", command, options)
+        end
+
+      [stdout, stderr, status.exitstatus]
+    rescue Errno::ENOENT, IOError
+      ["", "executable not found: \"#{command.first}\"", 127]
+    end
+
+    private
+
+    def execute_open3(command, options = {})
+      require "open3"
+
+      # We would ideally use Open3.capture3, but it wouldn't allow us to
+      # terminate the command after timing out.
+      Open3.popen3(*command) do |in_w, out_r, err_r, thread|
+        [in_w, out_r, err_r].each(&:binmode)
+        stdout_reader = Thread.new { out_r.read }
+        stderr_reader = Thread.new { err_r.read }
+        begin
+          in_w.write options[:stdin].to_s
+        rescue Errno::EPIPE
+        end
+        in_w.close
+
+        unless thread.join(DCMTK.timeout)
+          Process.kill("TERM", thread.pid) rescue nil
+          Process.waitpid(thread.pid)      rescue nil
+          raise Timeout::Error, "DCMTK command timed out: #{command}"
+        end
+
+        [stdout_reader.value, stderr_reader.value, thread.value]
+      end
+    end
+
+    def execute_posix_spawn(command, options = {})
+      require "posix-spawn"
+      child = POSIX::Spawn::Child.new(*command, input: options[:stdin].to_s, timeout: DCMTK.timeout)
+      [child.out, child.err, child.status]
+    rescue POSIX::Spawn::TimeoutExceeded
+      raise Timeout::Error, "DCMTK command timed out: #{command}"
+    end
+
+    def log(command, &block)
+      value = nil
+      duration = Benchmark.realtime { value = block.call }
+      DCMTK.logger.debug "[%.2fs] %s" % [duration, command]
+      value
+    end
+  end
+end

data/lib/dcmtk/tool/convert.rb

@@ -0,0 +1,30 @@
+module DCMTK
+  class Tool
+    class Convert < DCMTK::Tool
+      FORMATS = {
+        png:  '+on', # PNG format
+        bmp:  '+ob', # BMP format
+        jpeg: '+oj' # JPEG format
+      }.freeze
+
+      def initialize(*args)
+        super(DCMTK.convert_cli, *args)
+      end
+
+      ##
+      # Sets the output format for the conversion.
+      #
+      # @param type [Symbol] The format type (:png, :bmp, :jpeg)
+      # @return [self]
+      # @raise [ArgumentError] If the format is not supported
+      #
+      def format(type)
+        flag = FORMATS.fetch(type.to_sym) do
+          raise ArgumentError, "Unsupported format: #{type}. Use: #{FORMATS.keys.join(', ')}"
+        end
+        self << flag
+        self
+      end
+    end
+  end
+end

data/lib/dcmtk/tool.rb

@@ -0,0 +1,144 @@
+require "dcmtk/shell"
+
+module DCMTK
+  ##
+  # Abstract class that wraps command-line tools. It shouldn't be used directly,
+  # but through one of its subclasses. Use
+  # this class if you want to be closer to the metal and execute DCMTK
+  # commands directly, but still with a nice Ruby interface.
+  #
+  class Tool
+    ##
+    # Aside from classic instantiation, it also accepts a block, and then
+    # executes the command in the end.
+    #
+    # @example
+    #   version = DCMTK::Tool::Convert.new { |b| b.version }
+    #   puts version
+    #
+    # @return [DCMTK::Tool, String] If no block is given, returns an
+    #   instance of the tool, if block is given, returns the output of the
+    #   command.
+    #
+    def self.new(*args)
+      instance = super(*args)
+
+      if block_given?
+        yield instance
+        instance.call
+      else
+        instance
+      end
+    end
+
+    # @private
+    attr_reader :name, :args
+
+    # @param name [String]
+    # @param options [Hash]
+    # @option options [Boolean] :whiny Whether to raise errors on non-zero
+    #   exit codes.
+    # @example
+    #   DCMTK::Tool::Convert.new(whiny: false) do |convert|
+    #     convert.help # returns exit status 1, which would otherwise throw an error
+    #   end
+    def initialize(name, options = {})
+      @name  = name
+      @args  = []
+      @whiny = options.is_a?(Hash) ? options.fetch(:whiny, DCMTK.whiny) : options
+    end
+
+    ##
+    # Executes the command that has been built up.
+    #
+    # @example
+    #   convert = DCMTK::Tool::Convert.new
+    #   convert.format(:png)
+    #   convert << "path/to/file.dcm"
+    #   convert << "output.png"
+    #   convert.call # executes `dcmj2pnm +on path/to/file.dcm output.png`
+    #
+    # @example
+    #   convert = DCMTK::Tool::Convert.new
+    #   # build the command
+    #   convert.call do |stdout, stderr, status|
+    #     # ...
+    #   end
+    #
+    # @yield [Array] Optionally yields stdout, stderr, and exit status
+    #
+    # @return [String] Returns the output of the command
+    #
+    def call(*args)
+      options = args[-1].is_a?(Hash) ? args.pop : {}
+      whiny = args.fetch(0, @whiny)
+
+      options[:whiny] = whiny
+      options[:stderr] = false if block_given?
+
+      shell = DCMTK::Shell.new
+      stdout, stderr, status = shell.run(command, options)
+      yield stdout, stderr, status if block_given?
+
+      stdout.chomp("\n")
+    end
+
+    ##
+    # The currently built-up command.
+    #
+    # @return [Array<String>]
+    #
+    # @example
+    #   convert = DCMTK::Tool::Convert.new
+    #   convert.format(:png)
+    #   convert << "input.dcm"
+    #   convert << "output.png"
+    #   convert.command #=> ["dcmj2pnm", "+on", "input.dcm", "output.png"]
+    #
+    def command
+      [*executable, *args]
+    end
+
+    def executable
+      exe = [name]
+      exe
+    end
+
+    ##
+    # Appends raw options, useful for appending file paths.
+    #
+    # @return [self]
+    #
+    def <<(arg)
+      args << arg.to_s
+      self
+    end
+
+    ##
+    # Merges a list of raw options.
+    #
+    # @return [self]
+    #
+    def merge!(new_args)
+      new_args.each { |arg| self << arg }
+      self
+    end
+
+    ##
+    # Any undefined method will be transformed into a CLI option
+    #
+    # @example
+    #   convert = DCMTK::Tool.new("dcmj2pnm")
+    #   convert.verbose
+    #   convert.command.join(" ") # => "dcmj2pnm --verbose"
+    #
+    def method_missing(name, *args)
+      option = "--#{name.to_s.tr('_', '-')}"
+      self << option
+      self.merge!(args)
+      self
+    end
+  end
+end
+
+require "dcmtk/tool/convert"

data/lib/dcmtk/utilities.rb

@@ -0,0 +1,35 @@
+require "tempfile"
+
+module DCMTK
+  # @private
+  module Utilities
+
+    module_function
+
+    ##
+    # Cross-platform way of finding an executable in the $PATH.
+    #
+    # @example
+    #   DCMTK::Utilities.which('ruby') #=> "/usr/bin/ruby"
+    #
+    def which(cmd)
+      exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+      ENV.fetch('PATH').split(File::PATH_SEPARATOR).each do |path|
+        exts.each do |ext|
+          exe = File.join(path, "#{cmd}#{ext}")
+          return exe if File.executable? exe
+        end
+      end
+      nil
+    end
+
+    def tempfile(extension)
+      Tempfile.new(["dcmtk", extension]).tap do |tempfile|
+        tempfile.binmode
+        yield tempfile if block_given?
+        tempfile.close
+      end
+    end
+
+  end
+end

data/lib/dcmtk/version.rb

@@ -0,0 +1,17 @@
+module DCMTK
+  ##
+  # @return [Gem::Version]
+  #
+  def self.version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 1
+    MINOR = 0
+    TINY  = 1
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
+  end
+end

data/lib/dcmtk.rb

@@ -0,0 +1,34 @@
+require 'dcmtk/version'
+require 'dcmtk/configuration'
+
+module DCMTK
+  extend DCMTK::Configuration
+
+  ##
+  # Returns the CLI command to use for conversion.
+  # Uses configured cli if set, otherwise auto-detects (dcm2img preferred, dcmj2pnm fallback).
+  # Result is cached after first call.
+  #
+  # @return [String]
+  def self.convert_cli
+    return cli if cli
+    return @convert_cli if defined?(@convert_cli)
+
+    @convert_cli = DCMTK::Utilities.which('dcm2img') ? 'dcm2img' : 'dcmj2pnm'
+  end
+
+  ##
+  # Returns DCMTK CLI tool version.
+  #
+  # @return [String]
+  def self.cli_version
+    output = DCMTK::Tool::Convert.new { |c| c.version }
+    output[/\d+\.\d+\.\d+/]
+  end
+
+  class Error < RuntimeError; end
+
+end
+
+require 'dcmtk/tool'
+require 'dcmtk/package'

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: dcmtk
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- sanzstez
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-01-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: posix-spawn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby adapter for DCMTK tools for DICOM medical files.
+email:
+- sanzstez@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- lib/dcmtk.rb
+- lib/dcmtk/configuration.rb
+- lib/dcmtk/package.rb
+- lib/dcmtk/shell.rb
+- lib/dcmtk/tool.rb
+- lib/dcmtk/tool/convert.rb
+- lib/dcmtk/utilities.rb
+- lib/dcmtk/version.rb
+homepage: https://github.com/sanzstez/dcmtk
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- You must have DCMTK tools installed (dcmj2pnm)
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Ruby adapter for DCMTK tools for DICOM medical files.
+test_files: []