images-convert 0.4.1

data/lib/rubygems_plugin.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# RubyGems plugin hooks for automatic cleanup on gem uninstall
+# This file is loaded by RubyGems when any gem command runs.
+
+require 'fileutils'
+
+Gem.post_uninstall do |uninstaller|
+  begin
+    spec = uninstaller.respond_to?(:spec) ? uninstaller.spec : nil
+    next unless spec && spec.name == 'images-convert'
+
+    config_dir = File.expand_path('~/.images-convert')
+    next unless Dir.exist?(config_dir)
+
+    # Ask for confirmation interactively in TTY environments
+    confirm = 'y'
+    if $stdout.isatty && $stdin.isatty
+      puts "images-convert: 設定ディレクトリ (#{config_dir}) を削除しますか？ [Y/n]"
+      print '> '
+      ans = ($stdin.gets || '').strip
+      confirm = ans.empty? ? 'y' : ans
+    end
+
+    if confirm.to_s.downcase.start_with?('y')
+      FileUtils.rm_rf(config_dir)
+      puts "images-convert: 設定ディレクトリを削除しました: #{config_dir}"
+    else
+      puts "images-convert: 設定ディレクトリの削除をスキップしました"
+    end
+  rescue => e
+    warn "images-convert: アンインストール後のクリーンアップに失敗しました: #{e.class}: #{e.message}"
+  end
+end

data/lib/waifu2x/downloader.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'tmpdir'
+require 'open3'
+
+module Waifu2x
+  module Downloader
+    module_function
+
+    def download_and_install(download_url)
+      raise 'download_url が空です' if download_url.to_s.strip.empty?
+
+      cache_root = File.expand_path('~/.cache/waifu2x-pdf')
+      FileUtils.mkdir_p(cache_root)
+
+      Dir.mktmpdir('waifu2x-dl') do |tmp|
+        archive_path = File.join(tmp, File.basename(download_url))
+
+        run!(%W[curl -L -o #{archive_path} #{download_url}])
+
+        extract_dir = File.join(tmp, 'extract')
+        FileUtils.mkdir_p(extract_dir)
+
+        if archive_path =~ /\.zip\z/i
+          run!(%W[unzip -q #{archive_path} -d #{extract_dir}])
+        else
+          run!(%W[tar -xf #{archive_path} -C #{extract_dir}])
+        end
+
+        bin_path = nil
+        models_path = nil
+
+        Dir.glob(File.join(extract_dir, '**', 'waifu2x-ncnn-vulkan')).each do |p|
+          next unless File.file?(p)
+          bin_path = p
+          break
+        end
+
+        if bin_path
+          candidate = File.join(File.dirname(bin_path), 'models')
+          models_path = candidate if File.directory?(candidate)
+        end
+
+        if models_path.nil?
+          Dir.glob(File.join(extract_dir, '**', 'models')).each do |p|
+            next unless File.directory?(p)
+            models_path = p
+            break
+          end
+        end
+
+        raise 'ダウンロードしたアーカイブから waifu2x-ncnn-vulkan が見つかりません' unless bin_path
+
+        FileUtils.chmod('+x', bin_path)
+
+        install_dir = File.join(cache_root, 'waifu2x-ncnn-vulkan')
+        FileUtils.mkdir_p(install_dir)
+
+        unique = File.basename(archive_path).gsub(/[^a-zA-Z0-9_.-]/, '_')
+        target_dir = File.join(install_dir, unique)
+        FileUtils.mkdir_p(target_dir)
+
+        src_root = File.dirname(bin_path)
+        FileUtils.cp_r(Dir.glob(File.join(src_root, '*')), target_dir)
+
+        resolved_bin = File.join(target_dir, 'waifu2x-ncnn-vulkan')
+        resolved_models = File.directory?(File.join(target_dir, 'models')) ? File.join(target_dir, 'models') : models_path
+
+        current_link = File.join(install_dir, 'current')
+        begin
+          FileUtils.rm_f(current_link)
+          FileUtils.ln_s(target_dir, current_link)
+        rescue StandardError
+        end
+
+        { bin: resolved_bin, models: resolved_models }
+      end
+    end
+
+    def run!(argv)
+      stdout_str, stderr_str, status = Open3.capture3(*argv)
+      unless status.success?
+        raise "Command failed (#{argv.join(' ')}): #{stderr_str}\n#{stdout_str}"
+      end
+      stdout_str
+    end
+  end
+end

data/lib/waifu2x/pdf_builder.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'combine_pdf'
+require 'fileutils'
+require 'tmpdir'
+require 'shellwords'
+
+module Waifu2x
+  class PDFBuilder
+    class << self
+      def create_pdf(image_paths, output_path, options = {})
+        return if image_paths.nil? || image_paths.empty?
+
+        Dir.mktmpdir('waifu2x-pdf-pages') do |pages_dir|
+          pdf_paths = images_to_single_pdfs(image_paths, pages_dir, options)
+          merge_pdfs(pdf_paths, output_path)
+        end
+      end
+
+      def images_to_single_pdfs(image_paths, output_dir, options = {})
+        FileUtils.mkdir_p(output_dir)
+        pdfs = []
+
+        compression = (options[:pdf_compression] || '').to_s.downcase
+        quality = options[:pdf_quality]
+        density = options[:pdf_density]
+        a4_print = options.key?(:a4_print) ? options[:a4_print] : true
+
+        tool = find_imagemagick_tool
+        raise 'ImageMagick CLI (magick or convert) が見つかりません' unless tool
+
+        image_paths.each_with_index do |path, idx|
+          base = format('%04d', idx + 1)
+          pdf_path = File.join(output_dir, "page_#{base}.pdf")
+          d = (density && density.to_i > 0) ? density.to_i : 300
+          compress_args = imagemagick_compress_args(compression: compression, quality: quality)
+
+          if a4_print
+            a4_width_in = 8.26771653543307
+            a4_height_in = 11.6929133858268
+            canvas_w = (a4_width_in * d).round
+            canvas_h = (a4_height_in * d).round
+            base_cmd = (tool == 'magick') ? ['magick', path] : ['convert', path]
+            cmd = base_cmd + [
+              '-define', 'png:ignore-crc=true',
+              '-auto-orient', '-strip', '-units', 'PixelsPerInch', '-density', d.to_s,
+              '-resize', "#{canvas_w}x#{canvas_h}>",
+              '-background', 'white', '-gravity', 'center', '-extent', "#{canvas_w}x#{canvas_h}"
+            ]
+            cmd += compress_args
+            cmd += [pdf_path]
+            run_cmd!(cmd)
+          else
+            base_cmd = (tool == 'magick') ? ['magick', path] : ['convert', path]
+            cmd = base_cmd + ['-define', 'png:ignore-crc=true', '-auto-orient', '-strip', '-units', 'PixelsPerInch', '-density', d.to_s]
+            cmd += compress_args
+            cmd += [pdf_path]
+            run_cmd!(cmd)
+          end
+
+          pdfs << pdf_path
+        end
+        pdfs
+      end
+
+      def merge_pdfs(pdf_paths, output_path)
+        combined = CombinePDF.new
+        pdf_paths.each do |pdf|
+          combined << CombinePDF.load(pdf)
+        end
+        FileUtils.mkdir_p(File.dirname(output_path)) unless Dir.exist?(File.dirname(output_path))
+        combined.save(output_path)
+      end
+
+      def imagemagick_compress_args(compression:, quality: nil)
+        args = []
+        case compression
+        when 'jpeg'
+          args += ['-compress', 'JPEG']
+        when 'jpeg2000'
+          args += ['-compress', 'JPEG2000']
+        when 'zip'
+          args += ['-compress', 'Zip']
+        end
+        if quality && quality.to_i > 0
+          args += ['-quality', quality.to_i.to_s]
+        end
+        args
+      end
+
+      def run_cmd!(cmd)
+        success = system(*cmd, out: File::NULL, err: File::NULL)
+        return true if success
+        code = $?.respond_to?(:exitstatus) ? $?.exitstatus : nil
+        raise "ImageMagick command failed (exit #{code}): #{cmd.join(' ')}"
+      end
+
+      def find_imagemagick_tool
+        return 'magick' if system('which magick > /dev/null 2>&1')
+        return 'convert' if system('which convert > /dev/null 2>&1')
+        nil
+      end
+    end
+  end
+end

data/lib/waifu2x/processor.rb

@@ -0,0 +1,301 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'tmpdir'
+require 'parallel'
+require 'shellwords'
+
+module Waifu2x
+  class Processor
+    class Waifu2xNotFoundError < StandardError; end
+
+    class << self
+      def process_images(input_dir, output_dir, scale: 2, noise: 1, model: 'anime_style_art_rgb', processor: :waifu2x_ncnn_vulkan, waifu2x_bin: nil, models_path: nil, recursive: false, auto_scale_a4: false, pdf_density: nil, verbose: false, image_format: 'png', on_error: 'stop')
+        FileUtils.mkdir_p(output_dir) unless Dir.exist?(output_dir)
+
+        image_paths = find_images(input_dir, recursive: recursive)
+        return if image_paths.empty?
+
+        Parallel.each(image_paths, in_threads: [Parallel.processor_count, 1].max) do |image_path|
+          local_scale = if auto_scale_a4
+                          choose_scale_for_a4(image_path, target_dpi: (pdf_density || 300))
+                        else
+                          scale
+                        end
+          begin
+            process_single_image(image_path, output_dir, local_scale, noise, model, processor, waifu2x_bin, models_path, verbose, image_format)
+          rescue StandardError => e
+            safe_path = begin
+              image_path.to_s.encode('UTF-8', invalid: :replace, undef: :replace)
+            rescue StandardError
+              image_path.to_s
+            end
+            safe_err = begin
+              e.message.to_s.encode('UTF-8', invalid: :replace, undef: :replace)
+            rescue StandardError
+              e.message.to_s
+            end
+            warn "[waifu2x] failed: #{safe_path} (#{e.class}: #{safe_err})"
+            raise e if on_error != 'skip'
+          end
+        end
+      end
+
+      private
+
+      def choose_scale_for_a4(image_path, target_dpi: 300)
+        a4_width_in = 8.26771653543307
+        a4_height_in = 11.6929133858268
+        target_w = (a4_width_in * target_dpi).round
+        target_h = (a4_height_in * target_dpi).round
+
+        w, h = safe_image_dimensions(image_path)
+
+        return 2 if w.to_i <= 0 || h.to_i <= 0
+        scale_w = target_w.to_f / w
+        scale_h = target_h.to_f / h
+        needed = [scale_w, scale_h].max
+
+        return 1 if needed <= 1.0
+        return 2 if needed <= 2.0
+        4
+      rescue StandardError
+        2
+      end
+
+      def safe_image_dimensions(path)
+        cmd = identify_command
+        if cmd
+          out = `#{cmd} -format "%w %h" #{Shellwords.escape(path)} 2>/dev/null`
+          if $?.success?
+            parts = out.strip.split
+            if parts.size == 2
+              w = Integer(parts[0]) rescue nil
+              h = Integer(parts[1]) rescue nil
+              return [w, h] if w && h
+            end
+          end
+        end
+        if system('which sips > /dev/null 2>&1')
+          out = `sips -g pixelWidth -g pixelHeight #{Shellwords.escape(path)} 2>/dev/null`
+          if $?.success?
+            w = out[/pixelWidth:\s*(\d+)/, 1]
+            h = out[/pixelHeight:\s*(\d+)/, 1]
+            return [w.to_i, h.to_i] if w && h
+          end
+        end
+        [0, 0]
+      end
+
+      def identify_command
+        if system('which magick > /dev/null 2>&1')
+          'magick identify'
+        elsif system('which identify > /dev/null 2>&1')
+          'identify'
+        else
+          nil
+        end
+      end
+
+      def find_images(directory, recursive: false)
+        exts = %w[jpg JPG jpeg JPEG png PNG gif GIF webp WEBP]
+        brace = "{#{exts.join(',')}}"
+        pattern = recursive ? File.join(directory, '**', "*.#{brace}") : File.join(directory, "*.#{brace}")
+        paths = Dir.glob(pattern)
+        paths.select! { |p| File.file?(p) }
+        paths.reject! do |p|
+          base = File.basename(p)
+          base.start_with?('._') || base.casecmp('thumbs.db').zero?
+        end
+        paths.sort
+      end
+
+      def process_single_image(input_path, output_dir, scale, noise, model, processor, waifu2x_bin, models_path, verbose, image_format)
+        base_name = File.basename(input_path, '.*')
+        requested_ext = image_format.to_s.downcase
+        requested_ext = 'png' unless %w[png jpg jpeg webp].include?(requested_ext)
+        requested_ext = 'jpg' if requested_ext == 'jpeg'
+        output_path = File.join(output_dir, base_name + ".#{requested_ext}")
+        png_path = File.join(output_dir, base_name + '.png')
+
+        direct_format = (requested_ext == 'png' ? nil : requested_ext)
+        direct_quality = (requested_ext == 'webp' || requested_ext == 'jpg') ? 95 : nil
+        waifu_out_path = direct_format ? output_path : png_path
+
+        case processor
+        when :waifu2x_ncnn_vulkan
+          ok, status = process_with_waifu2x_ncnn_vulkan(
+            input_path,
+            waifu_out_path,
+            scale,
+            noise,
+            model,
+            waifu2x_bin,
+            models_path,
+            verbose,
+            format: direct_format,
+            quality: direct_quality
+          )
+          unless ok
+            cleaned = clean_input_image(input_path, verbose: verbose)
+            if cleaned && File.exist?(cleaned)
+              ok2, status2 = process_with_waifu2x_ncnn_vulkan(
+                cleaned,
+                waifu_out_path,
+                scale,
+                noise,
+                model,
+                waifu2x_bin,
+                models_path,
+                verbose,
+                format: direct_format,
+                quality: direct_quality
+              )
+              ok = ok2
+              status = status2
+            end
+            unless ok
+              raise RuntimeError, "waifu2x exited with status #{status || 'unknown'}"
+            end
+          end
+        else
+          raise "Unsupported processor: #{processor}"
+        end
+
+        if File.exist?(png_path) && (File.extname(output_path).downcase != '.png') && direct_format.nil?
+          begin
+            convert_with_imagemagick_cli!(png_path, output_path, verbose: verbose)
+            File.delete(png_path) if File.exist?(output_path) && File.exist?(png_path)
+          rescue StandardError => e
+            safe_path = begin
+              output_path.to_s.encode('UTF-8', invalid: :replace, undef: :replace)
+            rescue StandardError
+              output_path.to_s
+            end
+            safe_err = begin
+              e.message.to_s.encode('UTF-8', invalid: :replace, undef: :replace)
+            rescue StandardError
+              e.message.to_s
+            end
+            warn "[imagemagick] convert skipped, keep PNG: #{safe_path} (#{e.class}: #{safe_err})"
+          end
+        end
+
+        unless File.exist?(output_path) || File.exist?(png_path)
+          raise "出力画像の作成に失敗しました: #{output_path}"
+        end
+      end
+
+      def process_with_waifu2x_ncnn_vulkan(input_path, output_path, scale, noise, model, waifu2x_bin, models_path, verbose, format: nil, quality: nil)
+        bin = waifu2x_bin || 'waifu2x-ncnn-vulkan'
+        cmd = [bin, '-i', input_path, '-o', output_path, '-s', scale.to_s, '-n', noise.to_s]
+        cmd += ['-f', format] if format
+        cmd += ['-q', quality.to_i.to_s] if quality
+        cmd += ['-m', models_path] if models_path && !models_path.empty?
+        cmd += ['-g', '0', '-j', '1:2:2']
+
+        success = if verbose
+                    system(*cmd)
+                  else
+                    system(*cmd, out: File::NULL, err: File::NULL)
+                  end
+        status = $?.respond_to?(:exitstatus) ? $?.exitstatus : (success ? 0 : nil)
+        [success, status]
+      end
+
+      def convert_with_imagemagick_cli!(src_path, dst_path, verbose: false)
+        tool = find_imagemagick_tool
+        raise 'ImageMagick CLI (magick or convert) が見つかりません' unless tool
+
+        dst_ext = File.extname(dst_path).downcase
+        quality = 90
+        args = []
+        args += ['-define', 'png:ignore-crc=true', '-auto-orient', '-strip']
+
+        case dst_ext
+        when '.jpg', '.jpeg'
+          args += ['-quality', quality.to_s]
+        when '.webp'
+          args += ['-quality', quality.to_s]
+        end
+        cmd = if tool == 'magick'
+                ['magick', src_path] + args + [dst_path]
+              else
+                ['convert', src_path] + args + [dst_path]
+              end
+        success = run_im_cmd(cmd, verbose: verbose)
+        return true if success
+
+        Dir.mktmpdir('w2x-fix') do |tmp|
+          cleaned = File.join(tmp, 'clean.png')
+          fix_cmd = if tool == 'magick'
+                      ['magick', src_path, '-define', 'png:ignore-crc=true', '-auto-orient', '-strip', '-colorspace', 'sRGB', 'PNG32:' + cleaned]
+                    else
+                      ['convert', src_path, '-define', 'png:ignore-crc=true', '-auto-orient', '-strip', '-colorspace', 'sRGB', 'PNG32:' + cleaned]
+                    end
+          run_im_cmd(fix_cmd, verbose: verbose)
+          retry_cmd = if tool == 'magick'
+                        ['magick', cleaned] + args + [dst_path]
+                      else
+                        ['convert', cleaned] + args + [dst_path]
+                      end
+          success2 = run_im_cmd(retry_cmd, verbose: verbose)
+          return true if success2
+
+          if system('which sips > /dev/null 2>&1')
+            sips_png = File.join(tmp, 'sips.png')
+            sips_ok = system('sips', '-s', 'format', 'png', src_path, '--out', sips_png, out: File::NULL, err: File::NULL)
+            if sips_ok && File.exist?(sips_png)
+              retry_cmd2 = if tool == 'magick'
+                             ['magick', sips_png] + args + [dst_path]
+                           else
+                             ['convert', sips_png] + args + [dst_path]
+                           end
+              success3 = run_im_cmd(retry_cmd2, verbose: verbose)
+              return true if success3
+            end
+          end
+        end
+
+        code = $?.respond_to?(:exitstatus) ? $?.exitstatus : nil
+        raise "ImageMagick convert failed (exit #{code})"
+      end
+
+      def find_imagemagick_tool
+        return 'magick' if system('which magick > /dev/null 2>&1')
+        return 'convert' if system('which convert > /dev/null 2>&1')
+        nil
+      end
+
+      def run_im_cmd(cmd, verbose: false)
+        if verbose
+          system(*cmd)
+        else
+          system(*cmd, out: File::NULL, err: File::NULL)
+        end
+      end
+
+      def clean_input_image(src_path, verbose: false)
+        tool = find_imagemagick_tool
+        Dir.mktmpdir('w2x-clean') do |tmp|
+          cleaned = File.join(tmp, 'clean.png')
+          if tool
+            cmd = if tool == 'magick'
+                    ['magick', src_path, '-define', 'png:ignore-crc=true', '-auto-orient', '-strip', '-colorspace', 'sRGB', 'PNG32:' + cleaned]
+                  else
+                    ['convert', src_path, '-define', 'png:ignore-crc=true', '-auto-orient', '-strip', '-colorspace', 'sRGB', 'PNG32:' + cleaned]
+                  end
+            return cleaned if run_im_cmd(cmd, verbose: verbose) && File.exist?(cleaned)
+          end
+          if system('which sips > /dev/null 2>&1')
+            sips_ok = system('sips', '-s', 'format', 'png', src_path, '--out', cleaned, out: File::NULL, err: File::NULL)
+            return cleaned if sips_ok && File.exist?(cleaned)
+          end
+          nil
+        end
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/waifu2x/setup.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'fileutils'
+require_relative 'downloader'
+
+module Waifu2x
+  module Setup
+    DEFAULT_MACOS_URL = 'https://github.com/nihui/waifu2x-ncnn-vulkan/releases/download/20250915/waifu2x-ncnn-vulkan-20250915-macos.zip'
+
+    module_function
+
+    def resolve_paths(options = {})
+      bin = options[:waifu2x_bin] || ENV['WAIFU2X_BIN'] || which('waifu2x-ncnn-vulkan')
+      models = options[:models_path] || ENV['WAIFU2X_MODELS']
+      source = nil
+
+      if options[:waifu2x_bin]
+        source = :option
+      elsif ENV['WAIFU2X_BIN']
+        source = :env
+      elsif bin && !bin.empty?
+        source = :path
+      end
+
+      if bin.nil? || bin.empty?
+        cached = find_cached_install
+        if cached
+          bin = cached[:bin]
+          models ||= cached[:models]
+          source = :cached
+        end
+      end
+
+      if bin.nil? || bin.empty?
+        if options[:auto_download]
+          download_url = options[:download_url]
+          download_url = DEFAULT_MACOS_URL if download_url.to_s.strip.empty?
+
+          installed = Downloader.download_and_install(download_url)
+          bin = installed[:bin]
+          models ||= installed[:models]
+          source = :download
+        else
+          raise 'waifu2x-ncnn-vulkan が見つかりませんでした。--waifu2x-bin でパスを指定するか、--auto-download と --download-url を指定してください。'
+        end
+      end
+
+      models ||= begin
+        candidate = File.join(File.dirname(bin), 'models')
+        File.directory?(candidate) ? candidate : nil
+      end
+
+      if models && options[:model]
+        selected = select_model_dir(models, options[:model].to_s)
+        models = selected if selected
+      end
+
+      case source
+      when :option
+        puts "Using waifu2x binary (option): #{bin}"
+      when :env
+        puts "Using waifu2x binary (env WAIFU2X_BIN): #{bin}"
+      when :path
+        puts "Using waifu2x binary (PATH): #{bin}"
+      when :cached
+        puts "Using waifu2x binary (cached): #{bin}"
+      when :download
+        puts "Downloaded waifu2x binary: #{bin}"
+      end
+
+      { bin: bin, models: models }
+    end
+
+    def select_model_dir(models_root, alias_name)
+      return nil unless File.directory?(models_root)
+
+      key = alias_name.to_s.downcase
+      patterns = case key
+                 when 'photo'
+                   [/upconv_7_photo\z/, /photo\z/]
+                 when 'anime_rgb'
+                   [/upconv_7_anime_style_art_rgb\z/]
+                 when 'anime'
+                   [/upconv_7_anime_style_art\z/, /anime_style_art\z/]
+                 when 'cunet'
+                   [/cunet\z/]
+                 when 'upresnet10'
+                   [/upresnet10\z/]
+                 else
+                   []
+                 end
+
+      return nil if patterns.empty?
+
+      entries = Dir.children(models_root)
+      dirnames = entries.select { |e| File.directory?(File.join(models_root, e)) }
+
+      patterns.each do |pat|
+        match = dirnames.find { |name| name.match?(pat) || name.match?(/models-.*#{pat.source}/) }
+        return File.join(models_root, match) if match
+      end
+
+      nil
+    end
+
+    def which(cmd)
+      stdout, _stderr, status = Open3.capture3('bash', '-lc', "command -v #{cmd}")
+      status.success? ? stdout.strip : nil
+    end
+
+    def find_cached_install
+      cache_root = File.expand_path('~/.cache/waifu2x-pdf/waifu2x-ncnn-vulkan')
+      return nil unless Dir.exist?(cache_root)
+
+      candidates = Dir.children(cache_root).map { |d| File.join(cache_root, d) }.select { |p| File.directory?(p) }
+      candidates.sort_by! { |p| File.mtime(p) }.reverse!
+      candidates.each do |dir|
+        bin = File.join(dir, 'waifu2x-ncnn-vulkan')
+        next unless File.exist?(bin)
+        models = File.join(dir, 'models')
+        return { bin: bin, models: File.directory?(models) ? models : nil }
+      end
+      nil
+    end
+  end
+end

data/lib/waifu2x/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Waifu2x
+  VERSION = '0.1.0'
+end