libis-format 1.0.4 → 2.0.2

data/lib/libis/format/converter/chain.rb

@@ -5,7 +5,7 @@ require 'deep_dive'
 
 require 'libis/tools/logger'
 require 'libis/tools/extend/hash'
-require 'libis/format/type_database'
+require 'libis/format/library'
 
 module Libis
   module Format
@@ -83,8 +83,8 @@ module Libis
             target = target_file
 
             if i < size - 1
-              target += ".temp.#{TypeDatabase.type_extentions(target_type).first}"
-              target += ".#{TypeDatabase.type_extentions(target_type).first}" while File.exist? target
+              target += ".temp.#{Libis::Format::Library.get_field(target_type, :extensions).first}"
+              target += ".#{Libis::Format::Library.get_field(target_type, :extensions).first}" while File.exist? target
               temp_files << target
             end
 

data/lib/libis/format/converter/image_assembler.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+require_relative 'base'
+require 'libis/format/identifier'
+
+require 'mini_magick'
+
+MiniMagick.logger.level = ::Logger::UNKNOWN
+
+MiniMagick.configure do |config|
+  # config.cli = :graphicsmagick
+  config.validate_on_create = false
+  config.validate_on_write = false
+  config.whiny = false
+end
+
+module Libis
+  module Format
+    module Converter
+
+      # noinspection RubyTooManyInstanceVariablesInspection,DuplicatedCode
+      class ImageAssembler < Libis::Format::Converter::Base
+
+        def self.input_types
+          [:TIFF, :JPG, :PNG, :BMP, :GIF, :PDF, :JP2]
+        end
+
+        def self.output_types(format = nil)
+          return [] unless input_types.include?(format) if format
+          [:PDF, :TIFF, :GIF, :PBM, :PGM, :PPM]
+        end
+
+        def self.category
+          :assembler
+        end
+
+        def image_assemble(_)
+          #force usage of this converter
+        end
+
+        def quiet(v)
+          @quiet = !!v
+        end
+
+        def convert(source, target, format, opts = {})
+          super
+
+          FileUtils.mkpath(File.dirname(target))
+
+          if source.is_a? Array
+            assemble(source, target, format)
+          elsif File.directory?(source)
+            source_list = Dir[File.join(source, '**', '*')].reject {|p| File.directory? p}
+            assemble(source_list, target, format)
+          else
+            image = MiniMagick::Image.open(source) {|b| b.quiet}
+            if image.pages.size > 1
+              assemble(image.pages.map {|page| page.path}, target, format)
+            else
+              assemble([source], target, format)
+            end
+          end
+
+          target
+
+        end
+
+        private
+
+        def assemble(sources, target, format)
+          MiniMagick::Tool::Convert.new do |b|
+            sources.each {|source| b << source}
+            convert.format(format)
+            b << target
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/format/converter/image_converter.rb

@@ -4,7 +4,6 @@ require_relative 'base'
 require 'libis/format/identifier'
 
 require 'mini_magick'
-require 'fileutils'
 
 MiniMagick.logger.level = ::Logger::UNKNOWN
 
@@ -23,11 +22,11 @@ module Libis
       class ImageConverter < Libis::Format::Converter::Base
 
         def self.input_types
-          [:TIFF, :JPG, :PNG, :BMP, :GIF, :PDF, :JP2]
+          [:TIFF, :JPG, :PNG, :BMP, :GIF, :PDF, :JP2, :PBM, :PGM, :PPM]
         end
 
         def self.output_types(format = nil)
-          return [] unless input_types.include?(format)
+          return [] unless input_types.include?(format) if format
           [:TIFF, :JPG, :PNG, :BMP, :GIF, :PDF, :JP2]
         end
 
@@ -46,109 +45,57 @@ module Libis
 
         def quiet(v)
           @quiet = !!v
+          self
         end
 
         def page(nr)
           @page = nr
+          self
         end
 
         def scale(percent)
           @options[:scale] = percent
+          self
         end
 
         def resize(geometry)
           @options[:resize] = geometry
+          self
         end
 
         def quality(value)
           @options[:quality] = value
+          self
         end
 
         def dpi(value)
           @options[:density] = value
+          self
         end
 
         def resample(value)
           @options[:resample] = value
+          self
         end
 
         def flatten(value = true)
-          @options[:flatten] = !!value
+          @options[:flatten] = value
+          self
         end
 
         def colorspace(value)
           @options[:colorspace] = value
+          self
         end
 
         def delete_date(value = true)
-          @delete_date = !!value
+          @delete_date = value
+          self
         end
 
         def profile(icc)
           @profile = icc
-        end
-
-        # Create or use a watermark image.
-        #
-        # The watermark options are:
-        #     - file: watermark image to use
-        #     - text: text to create a watermark from
-        #     - rotation: rotation of the watermark text (counter clockwise in degrees; integer number) - default 30
-        #     - tiles: number of tiles of the watermark - default 4
-        #       - 0: no tiling, so only 1 watermark will be placed with the original size
-        #       - 1: 1 tile, so the watermark will be scaled up to fill the image
-        #       - n > 1: minimum n tiles in both directions
-        #       - n < 0: tile without scaling the watermark
-        #     - size: same as tiles - for backwards compatibility
-        #     - resize: fraction 0.0 - 1.0
-        #     - gap: size of the gap between watermark instances. Fractions as percentage of widht/height. - default 0.2
-        #     - opacity: opacity of the watermark (fraction 0.0 - 1.0) - default 0.1
-        #     - gravity: center point of the overlay - default 'center'
-        # If both options are given, the file will be used as-is if it exists and is a valid image file. Otherwise the
-        # file will be created or overwritten with a newly created watermark image.
-        #
-        # The created watermark file will be a PNG image with transparent background containing the supplied text
-        # slanted by 30 degrees counter-clockwise.
-        #
-        # @param [Hash] options Hash of options for watermark creation.
-        def watermark(options = {})
-          text = options[:text] || '© LIBIS'
-          @wm_tiles = (options[:tiles] || '4').to_i
-          @wm_tiles ||= (options[:size] || '4').to_i
-          @wm_resize = ((options[:resize]).to_f * 100).to_i if options[:resize]
-          @wm_opacity = ((options[:opacity] || 0.1).to_f * 100).to_i
-          @wm_composition = options[:composition] || 'modulate'
-          @wm_gravity = options[:gravity] || 'center'
-          @wm_gap = ((options[:gap] || 0.2).to_f * 100).to_i
-          rotation = 360 - (options[:rotation] || 30).to_i
-          @wm_image = MiniMagick::Image.new(options[:file]) if options[:file]
-          unless @wm_image && @wm_image.valid?
-            image = options[:file] || (Dir::Tmpname.create(%w(wm_image .png)) {|_|})
-            # noinspection RubyResolve
-            MiniMagick::Tool::Convert.new do |convert|
-              # noinspection RubyLiteralArrayInspection
-              convert.quiet
-              convert.background 'transparent'
-              convert.size('2000x2000')
-              convert.gravity 'Center'
-              convert.font('Helvetica').fill('black').pointsize(72) #.stroke('black').strokewidth(1)
-              convert << "label:#{text}"
-              convert.rotate rotation
-              convert.trim.repage.+
-              convert << image
-            end
-            if options[:file]
-              @wm_image = MiniMagick::Image.new(image)
-            else
-              @wm_image = MiniMagick::Image.open(image)
-              File.delete(image)
-            end
-            # noinspection RubyResolve
-            unless @wm_image.valid?
-              error "Problem creating watermark image '#{image}'."
-              @wm_image = nil
-            end
-          end
+          self
         end
 
         def convert(source, target, format, opts = {})
@@ -156,90 +103,25 @@ module Libis
 
           FileUtils.mkpath(File.dirname(target))
 
-          if source.is_a? Array
-
-            assemble_and_convert(source, target, format)
-
-          elsif File.directory?(source)
-            source_list = Dir[File.join(source, '**', '*')].reject {|p| File.directory? p}
-
-            assemble_and_convert(source_list, target, format)
-
-          else
-
-            image = MiniMagick::Image.new(source) { |b| b.quiet }
-
-            if image.pages.size > 1
-              if @page
-                convert_image(image.pages[@page].path, target, format)
-              else
-                # noinspection RubyBlockToMethodReference
-                assemble_and_convert(image.pages.map {|page| page.path}, target, format)
-              end
-            else
-              convert_image(source, target, format)
-            end
-          end
+          convert_image(source, target, format)
 
           target
 
         end
 
-        def assemble_and_convert(sources, target, format)
-
-          warn 'Received multiple images as input and single page format as target.' unless self.class.multipage?(format)
-          converted_pages = sources.inject([]) do |list, path|
-            # noinspection RubyArgCount
-            converted = Tempfile.new(['page-', ".#{Libis::Format::TypeDatabase.type_extentions(format).first}"])
-            convert_image(path, converted.path, format)
-            list << converted
-          end
-          MiniMagick::Tool::Convert.new do |b|
-            b.append unless self.class.multipage?(format)
-            converted_pages.each {|page| b << page.path}
-            b << target
-          end
-          converted_pages.each do |temp_file|
-            temp_file.close
-            temp_file.unlink
-          end
-        end
-
         protected
 
         def convert_image(source, target, format)
 
-          image_info = nil
-          image_info = MiniMagick::Image::Info.new(source) {|b| b.quiet} if @wm_image
+          if @page
+            image = MiniMagick::Image.open(source) { |b| b.quiet }
+            source = image.pages[@page].path if image.pages.size > 1
+          end
 
           MiniMagick::Tool::Convert.new do |convert|
-            convert.quiet if @quiet
-            if @wm_image
-              convert << @wm_image.path
-              convert.bordercolor('transparent').border("#{@wm_gap}%") if @wm_gap > 0
-              convert.filter('Lagrange')
-              convert.resize("#{image_info['width'] / @wm_tiles}x#{image_info['height'] / @wm_tiles}") if @wm_tiles > 0
-              convert.resize("#{@wm_resize}%") if @wm_resize
-              convert.write('mpr:watermark').delete.+
-            end
-
             convert.quiet if @quiet
             convert << source
             convert.flatten if @options[:flatten].nil? && format == :JPG
-            if @wm_image
-              if @wm_tiles >= 0 and @wm_tiles <= 1
-                convert << 'mpr:watermark'
-              else
-                convert.stack do |stack|
-                  stack.size("#{image_info['width']}x#{image_info['height']}")
-                  stack << 'xc:transparent'
-                  stack.tile('mpr:watermark')
-                  stack.draw "rectangle 0,0,#{image_info['width']},#{image_info['height']}"
-                end
-              end
-              convert.compose(@wm_composition).gravity(@wm_gravity).define("compose:args=#{@wm_opacity}%").composite
-            end
-
             @flags.each {|f, v| v.is_a?(TrueClass) ? convert.send(f).+ : convert.send(f)}
             if @delete_date
               convert << '+set' << 'modify-date' << '+set' << 'create-date'

data/lib/libis/format/converter/image_splitter.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+
+require_relative 'base'
+require 'libis/format/identifier'
+
+require 'mini_magick'
+
+MiniMagick.logger.level = ::Logger::UNKNOWN
+
+MiniMagick.configure do |config|
+  # config.cli = :graphicsmagick
+  config.validate_on_create = false
+  config.validate_on_write = false
+  config.whiny = false
+end
+
+module Libis
+  module Format
+    module Converter
+
+      class ImageSplitter < Libis::Format::Converter::Base
+
+        def self.input_types
+          [:PDF, :TIFF, :GIF, :PBM, :PGM, :PPM]
+        end
+
+        def self.output_types(format = nil)
+          return [] unless input_types.include?(format) if format
+          [:TIFF, :JPG, :PNG, :BMP, :GIF, :PDF, :JP2]
+        end
+
+        def self.multipage?(format)
+          [:PDF, :TIFF, :GIF, :PBM, :PGM, :PPM].include?(format)
+        end
+
+        def self.category
+          :splitter
+        end
+
+        def image_split(_)
+          #force usage of this converter
+        end
+
+        def quiet(v)
+          @quiet = !!v
+        end
+
+        def convert(source, target, format, opts = {})
+          super
+
+          FileUtils.mkpath(File.dirname(target))
+
+          if self.class.multipage?(format)
+            target = File.join(File.dirname(target), "#{File.basename(target, '.*')}-%d#{File.extname(target)}")
+          end
+
+          result = split_image(source, target, format)
+          return nil unless result
+          target
+
+        end
+
+        private
+
+        def split_image(source, target, format)
+
+          MiniMagick::Tool::Convert.new do |convert|
+            convert.quiet if @quiet
+            convert << source
+            convert.format(format)
+            convert << target
+
+            debug "ImageMagick command: '#{convert.command.join(' ')}'"
+          end
+
+          target
+
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/format/converter/image_watermarker.rb

@@ -0,0 +1,261 @@
+# encoding: utf-8
+
+require_relative 'base'
+require 'libis/format/identifier'
+
+require 'mini_magick'
+# noinspection RubyResolve
+require 'fileutils'
+
+MiniMagick.logger.level = ::Logger::UNKNOWN
+
+MiniMagick.configure do |config|
+  # config.cli = :graphicsmagick
+  config.validate_on_create = false
+  config.validate_on_write = false
+  config.whiny = false
+end
+
+module Libis
+  module Format
+    module Converter
+
+      # noinspection RubyTooManyInstanceVariablesInspection
+      class ImageWatermarker < Libis::Format::Converter::Base
+
+        def self.input_types
+          [:TIFF, :JPG, :PNG, :BMP, :GIF, :PDF, :JP2]
+        end
+
+        def self.output_types(format = nil)
+          return [] unless input_types.include?(format) if format
+          [format]
+        end
+
+        def self.multipage?(format)
+          [:PDF, :TIFF, :GIF, :PBM, :PGM, :PPM].include?(format)
+        end
+
+        def initialize
+          super
+          @quiet = true
+          @wm_image = nil
+          @wm_file = nil
+          @wm_text = '© LIBIS'
+          @wm_tiles = 4
+          @wm_resize = nil
+          @wm_gap = 20
+          @wm_gravity = 'Center'
+          @wm_rotation = 30
+          @wm_composition ='modulate'
+          @wm_composition_args = '10'
+        end
+
+        def image_watermark(_)
+          #force usage of this converter
+          self
+        end
+
+        def quiet(v)
+          @quiet = !!v
+          self
+        end
+
+        def page(v)
+          @page = v.to_i
+          self
+        end
+
+        # watermark image to use
+        def file(v)
+          @wm_file = v.blank? ? nil : v
+          self
+        end
+
+        # text to create a watermark from
+        def text(v)
+          @wm_text = v.blank? ? nil : v
+          self
+        end
+
+        # rotation of the watermark text (counter clockwise in degrees; integer number)
+        # default 30
+        def rotation(v)
+          @wm_rotation = v.to_i
+          self
+        end
+
+        # number of tiles of the watermark
+        # default 4
+        # 0: no tiling, so only 1 watermark will be placed with the original size
+        # 1: 1 tile, so the watermark will be scaled up to fill the image
+        # n > 1: minimum n tiles in both directions
+        # n < 0: tile without scaling the watermark
+        def tiles(v)
+          @wm_tiles = v.to_i
+          self
+        end
+
+        # fraction 0.0 - 1.0
+        def resize(v)
+          @wm_resize = (v.to_f * 100).to_i
+          self
+        end
+
+        # size of the gap between watermark instances. Fractions as percentage of widht/height
+        # default 0.2
+        def gap(v)
+          @wm_gap = (v.to_f * 100).to_i
+          self
+        end
+
+        # center point for the watermark overlay
+        # default 'center'
+        def gravity(v)
+          @wm_gravity = v.blank? ? nil : v
+          self
+        end
+
+        # the image composition method for merging the watermark image
+        # default 'modulate'
+        # See https://imagemagick.org/script/compose.php for more information
+        def composition(v)
+          @wm_composition = v.blank? ? nil : v
+          self
+        end
+
+        # arguments for the composition method
+        # default '10'
+        # See https://imagemagick.org/script/compose.php for more information
+        def composition_args(v)
+          @wm_composition_args = v.blank? ? nil : v
+          self
+        end
+
+
+        def convert(source, target, format, opts = {})
+          super
+
+          FileUtils.mkpath(File.dirname(target))
+
+          if source.is_a?(Array) || File.directory?(source)
+            error 'Only a single image file is allowed for input'
+          else
+            image = MiniMagick::Image.open(source) { |b| b.quiet }
+
+            if image.pages.size > 1
+              if @page
+                convert_image(image.pages[@page].path, target, format)
+              else
+                error 'multipage input file detecte; you need to supply a page number'
+              end
+            else
+              convert_image(source, target, format)
+            end
+          end
+
+          target
+
+        end
+
+        protected
+
+        # noinspection DuplicatedCode
+        def convert_image(source, target, format)
+
+          wm_image = watermark_image
+          return nil unless wm_image
+          image_info = MiniMagick::Image::Info.new(source) {|b| b.quiet}
+
+          MiniMagick::Tool::Convert.new do |convert|
+            convert.quiet if @quiet
+
+            # adapt watermark image to tile size and apply gap and resize if necessary
+            convert << @wm_image.path
+            # noinspection RubyResolve
+            convert.bordercolor('transparent').border("#{@wm_gap}%") if @wm_gap > 0
+            convert.filter('Lagrange')
+            convert.resize("#{image_info['width'] / @wm_tiles}x#{image_info['height'] / @wm_tiles}") if @wm_tiles > 0
+            convert.resize("#{@wm_resize}%") if @wm_resize
+            convert.write('mpr:watermark').delete.+
+
+            # convert the source image
+            convert << source
+            if @wm_tiles >= 0 and @wm_tiles <= 1
+              # only 1 watermark required (tiles = 0/1 => scaled no/yes)
+              convert << 'mpr:watermark'
+            else
+              # fill the image size with a pattern of the watermark image
+              convert.stack do |stack|
+                stack.size("#{image_info['width']}x#{image_info['height']}")
+                stack << 'xc:transparent'
+                # noinspection RubyResolve
+                stack.tile('mpr:watermark')
+                # noinspection RubyResolve
+                stack.draw "rectangle 0,0,#{image_info['width']},#{image_info['height']}"
+              end
+            end
+            # perform the blending operation
+            convert.compose(@wm_composition).gravity(@wm_gravity).define("compose:args=#{@wm_composition_args}").composite
+
+            convert.format(format)
+            convert << target
+
+            debug "ImageMagick command: '#{convert.command.join(' ')}'"
+          end
+
+          target
+
+        end
+
+        private
+
+        # Create or use a watermark image.
+        #
+        # If both text and image are set, the file will be used as-is if it exists and is a valid image file. Otherwise the
+        # file will be created or overwritten with a newly created watermark image.
+        #
+        # The created watermark file will be a 2000x2000 pixels PNG image with transparent background
+        #
+        # The text will be slanted by given rotation degrees counter-clockwise
+        def watermark_image
+          rotation = 360 - @wm_rotation
+          @wm_image = MiniMagick::Image.new(@wm_file) if @wm_file
+          # only create image if file is not an image
+          unless @wm_image&.valid?
+            # noinspection RubyResolve
+            # Create image file (as given or temp file)
+            image = @wm_file || (Dir::Tmpname.create(%w(wm_image .png)) {|_|})
+            # noinspection RubyResolve
+            MiniMagick::Tool::Convert.new do |convert|
+              convert.quiet # allways quiet
+              convert.background 'transparent'
+              convert.size('2000x2000')
+              convert.gravity 'Center'
+              convert.font('Helvetica').fill('black').pointsize(72) #.stroke('black').strokewidth(1)
+              convert << "label:#{@wm_text}"
+              convert.rotate rotation
+              convert.trim.repage.+
+              convert << image
+            end
+            if @wm_file
+              @wm_image = MiniMagick::Image.new(image)
+            else # delete temp file
+              @wm_image = MiniMagick::Image.open(image)
+              File.delete(image)
+            end
+            # noinspection RubyResolve
+            unless @wm_image.valid?
+              error "Problem creating watermark image '#{image}'."
+              @wm_image = nil
+            end
+            @wm_image
+          end
+        end
+
+
+      end
+
+    end
+  end
+end