ruby_spriter 0.6.7 → 0.7.0.1

data/lib/ruby_spriter/dependency_checker.rb

@@ -1,174 +1,224 @@
-# frozen_string_literal: true
-
-require 'open3'
-
-module RubySpriter
-  # Checks for required external dependencies
-  class DependencyChecker
-    REQUIRED_TOOLS = {
-      ffmpeg: {
-        command: 'ffmpeg -version',
-        pattern: /ffmpeg version/i,
-        install: {
-          windows: 'choco install ffmpeg',
-          linux: 'sudo apt install ffmpeg',
-          macos: 'brew install ffmpeg'
-        }
-      },
-      ffprobe: {
-        command: 'ffprobe -version',
-        pattern: /ffprobe version/i,
-        install: {
-          windows: 'Included with ffmpeg',
-          linux: 'Included with ffmpeg',
-          macos: 'Included with ffmpeg'
-        }
-      },
-      imagemagick: {
-        command: Platform.imagemagick_identify_cmd + ' -version',
-        pattern: /ImageMagick/i,
-        install: {
-          windows: 'choco install imagemagick',
-          linux: 'sudo apt install imagemagick',
-          macos: 'brew install imagemagick'
-        }
-      }
-    }.freeze
-
-    def initialize(verbose: false)
-      @verbose = verbose
-      @gimp_path = nil
-    end
-
-    # Check all dependencies
-    # @return [Hash] Results of dependency checks
-    def check_all
-      results = {}
-      
-      REQUIRED_TOOLS.each do |tool, config|
-        results[tool] = check_tool(tool, config)
-      end
-
-      results[:gimp] = check_gimp
-
-      results
-    end
-
-    # Check if all dependencies are satisfied
-    # @return [Boolean] true if all dependencies are available
-    def all_satisfied?
-      results = check_all
-      results.all? { |_tool, status| status[:available] }
-    end
-
-    # Print dependency status report
-    def print_report
-      results = check_all
-      
-      puts "\n" + "=" * 60
-      puts "Dependency Check"
-      puts "=" * 60
-      
-      results.each do |tool, status|
-        icon = status[:available] ? "✅" : "❌"
-        puts "\n#{icon} #{tool.to_s.upcase}"
-        
-        if status[:available]
-          puts "   Found: #{status[:path] || status[:version]}"
-        else
-          puts "   Status: NOT FOUND"
-          puts "   Install: #{status[:install_cmd]}"
-        end
-      end
-      
-      puts "\n" + "=" * 60 + "\n"
-    end
-
-    # Get the found GIMP executable path
-    attr_reader :gimp_path
-
-    private
-
-    def check_tool(tool, config)
-      stdout, stderr, status = Open3.capture3(config[:command])
-      output = stdout + stderr
-
-      if status.success? && output.match?(config[:pattern])
-        version = extract_version(output)
-        {
-          available: true,
-          version: version,
-          install_cmd: nil
-        }
-      else
-        {
-          available: false,
-          version: nil,
-          install_cmd: config[:install][Platform.current]
-        }
-      end
-    rescue StandardError => e
-      puts "DEBUG: Error checking #{tool}: #{e.message}" if @verbose
-      {
-        available: false,
-        version: nil,
-        install_cmd: config[:install][Platform.current]
-      }
-    end
-
-    def check_gimp
-      # Try default path first
-      default_path = Platform.default_gimp_path
-      if gimp_exists?(default_path)
-        @gimp_path = default_path
-        return gimp_status(true, default_path)
-      end
-
-      # Try alternative paths
-      Platform.alternative_gimp_paths.each do |path|
-        if gimp_exists?(path)
-          @gimp_path = path
-          return gimp_status(true, path)
-        end
-      end
-
-      # Not found
-      gimp_status(false, nil)
-    end
-
-    def gimp_exists?(path)
-      return false if path.nil? || path.empty?
-      File.exist?(path)
-    end
-
-    def gimp_status(available, path)
-      {
-        available: available,
-        path: path,
-        install_cmd: gimp_install_command
-      }
-    end
-
-    def gimp_install_command
-      case Platform.current
-      when :windows
-        'Download from https://www.gimp.org/downloads/ or use: choco install gimp'
-      when :linux
-        'sudo apt install gimp'
-      when :macos
-        'brew install gimp'
-      else
-        'Visit https://www.gimp.org/downloads/'
-      end
-    end
-
-    def extract_version(output)
-      # Try to extract version number from output
-      if output =~ /version\s+(\d+\.\d+[\.\d]*)/i
-        $1
-      else
-        output.lines.first&.strip || 'Unknown'
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'open3'
+
+module RubySpriter
+  # Checks for required external dependencies
+  class DependencyChecker
+    REQUIRED_TOOLS = {
+      ffmpeg: {
+        command: 'ffmpeg -version',
+        pattern: /ffmpeg version/i,
+        install: {
+          windows: 'choco install ffmpeg',
+          linux: 'sudo apt install ffmpeg',
+          macos: 'brew install ffmpeg'
+        }
+      },
+      ffprobe: {
+        command: 'ffprobe -version',
+        pattern: /ffprobe version/i,
+        install: {
+          windows: 'Included with ffmpeg',
+          linux: 'Included with ffmpeg',
+          macos: 'Included with ffmpeg'
+        }
+      },
+      imagemagick: {
+        command: Platform.imagemagick_identify_cmd + ' -version',
+        pattern: /ImageMagick/i,
+        install: {
+          windows: 'choco install imagemagick',
+          linux: 'sudo apt install imagemagick',
+          macos: 'brew install imagemagick'
+        }
+      },
+      xvfb: {
+        command: 'xvfb-run --help',
+        pattern: /xvfb-run/i,
+        install: {
+          windows: 'Not required on Windows',
+          linux: 'sudo apt install xvfb',
+          macos: 'Not required on macOS'
+        },
+        optional_for: [:windows, :macos]  # Only required on Linux
+      }
+    }.freeze
+
+    def initialize(verbose: false)
+      @verbose = verbose
+      @gimp_path = nil
+      @gimp_version = nil
+    end
+
+    # Check all dependencies
+    # @return [Hash] Results of dependency checks
+    def check_all
+      results = {}
+      
+      REQUIRED_TOOLS.each do |tool, config|
+        results[tool] = check_tool(tool, config)
+      end
+
+      results[:gimp] = check_gimp
+
+      results
+    end
+
+    # Check if all dependencies are satisfied
+    # @return [Boolean] true if all dependencies are available
+    def all_satisfied?
+      results = check_all
+      results.all? { |tool, status| status[:available] || status[:optional] }
+    end
+
+    # Print dependency status report
+    def print_report
+      results = check_all
+      
+      puts "\n" + "=" * 60
+      puts "Dependency Check"
+      puts "=" * 60
+      
+      results.each do |tool, status|
+        if status[:optional] && !status[:available]
+          icon = "⚪"
+          optional_text = " (Optional for #{Platform.current})"
+        else
+          icon = status[:available] ? "✅" : "❌"
+          optional_text = ""
+        end
+
+        puts "\n#{icon} #{tool.to_s.upcase}#{optional_text}"
+
+        if status[:available]
+          if tool == :gimp && status[:version]
+            version_str = "GIMP #{status[:version][:full]}"
+            puts "   Found: #{status[:path]}"
+            puts "   Version: #{version_str}"
+          else
+            puts "   Found: #{status[:path] || status[:version]}"
+          end
+        else
+          if status[:optional]
+            puts "   Status: NOT FOUND (not required for this platform)"
+          else
+            puts "   Status: NOT FOUND"
+            puts "   Install: #{status[:install_cmd]}"
+          end
+        end
+      end
+      
+      puts "\n" + "=" * 60 + "\n"
+    end
+
+    # Get the found GIMP executable path
+    attr_reader :gimp_path
+
+    # Get the detected GIMP version info
+    attr_reader :gimp_version
+
+    private
+
+    def check_tool(tool, config)
+      # Check if this tool is optional for current platform
+      optional_platforms = config[:optional_for] || []
+      is_optional = optional_platforms.include?(Platform.current)
+
+      stdout, stderr, status = Open3.capture3(config[:command])
+      output = stdout + stderr
+
+      if status.success? && output.match?(config[:pattern])
+        version = extract_version(output)
+        {
+          available: true,
+          version: version,
+          install_cmd: nil,
+          optional: is_optional
+        }
+      else
+        {
+          available: false,
+          version: nil,
+          install_cmd: config[:install][Platform.current],
+          optional: is_optional
+        }
+      end
+    rescue StandardError => e
+      puts "DEBUG: Error checking #{tool}: #{e.message}" if @verbose
+      {
+        available: false,
+        version: nil,
+        install_cmd: config[:install][Platform.current],
+        optional: is_optional
+      }
+    end
+
+    def check_gimp
+      # Try default path first
+      default_path = Platform.default_gimp_path
+      if gimp_exists?(default_path)
+        @gimp_path = default_path
+        @gimp_version = Platform.get_gimp_version(default_path)
+        return gimp_status(true, default_path, @gimp_version)
+      end
+
+      # Try alternative paths
+      Platform.alternative_gimp_paths.each do |path|
+        if gimp_exists?(path)
+          @gimp_path = path
+          @gimp_version = Platform.get_gimp_version(path)
+          return gimp_status(true, path, @gimp_version)
+        end
+      end
+
+      # Not found
+      gimp_status(false, nil, nil)
+    end
+
+    def gimp_exists?(path)
+      return false if path.nil? || path.empty?
+
+      # Handle Flatpak GIMP
+      if path.start_with?('flatpak:')
+        flatpak_app = path.sub('flatpak:', '')
+        stdout, _stderr, status = Open3.capture3("flatpak list --app | grep #{flatpak_app}")
+        return status.success? && !stdout.strip.empty?
+      end
+
+      File.exist?(path)
+    end
+
+    def gimp_status(available, path, version)
+      status = {
+        available: available,
+        path: path,
+        install_cmd: gimp_install_command
+      }
+      status[:version] = version if version
+      status
+    end
+
+    def gimp_install_command
+      case Platform.current
+      when :windows
+        'Download from https://www.gimp.org/downloads/ or use: choco install gimp'
+      when :linux
+        'sudo apt install gimp'
+      when :macos
+        'brew install gimp'
+      else
+        'Visit https://www.gimp.org/downloads/'
+      end
+    end
+
+    def extract_version(output)
+      # Try to extract version number from output
+      if output =~ /version\s+(\d+\.\d+[\.\d]*)/i
+        $1
+      else
+        output.lines.first&.strip || 'Unknown'
+      end
+    end
+  end
+end

data/lib/ruby_spriter/ghost_edge_cleaner.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'fileutils'
+
+module RubySpriter
+  # GhostEdgeCleaner removes semi-transparent "ghost" pixels around sprite edges
+  # using multi-pass alpha channel cleanup while preserving anti-aliasing
+  class GhostEdgeCleaner
+    attr_reader :input_image, :output_image, :config
+    attr_reader :ghost_pixels_detected, :passes_performed, :processing_time
+
+    MAX_PASSES = 3  # Maximum cleanup passes to prevent infinite loops
+
+    def initialize(input_image, output_image, config)
+      @input_image = input_image
+      @output_image = output_image
+      @config = config
+      @ghost_pixels_detected = 0
+      @passes_performed = 0
+      @processing_time = 0
+    end
+
+    # Main processing method
+    def process
+      start_time = Time.now
+
+      # Copy input to output as starting point
+      FileUtils.cp(@input_image, @output_image)
+
+      # Detect ghost pixels before cleanup
+      @ghost_pixels_detected = detect_ghost_pixels
+
+      # Perform multi-pass cleanup if multi_pass enabled
+      if @config.multi_pass
+        @passes_performed = multi_pass_cleanup
+      else
+        # Single pass cleanup
+        clean_edges
+        @passes_performed = 1
+      end
+
+      @processing_time = Time.now - start_time
+
+      true
+    end
+
+    # Detect pixels with alpha below threshold
+    def detect_ghost_pixels
+      threshold = @config.ghost_threshold
+
+      # Use ImageMagick to count pixels with alpha below threshold
+      # Alpha values are 0-255, threshold is 0-255
+      threshold_fraction = threshold / 255.0
+
+      convert_cmd = Platform.imagemagick_convert_cmd
+      cmd = "#{convert_cmd} #{Utils::PathHelper.quote_path(@input_image)} " \
+            "-channel A " \
+            "-separate " \
+            "-threshold #{(threshold_fraction * 100).to_i}% " \
+            "-format '%[fx:w*h*(1-mean)]' " \
+            "info:"
+
+      stdout, stderr, status = Open3.capture3(cmd)
+
+      if status.success?
+        stdout.strip.gsub("'", '').to_f.to_i
+      else
+        0
+      end
+    end
+
+    # Clean edges by removing low-alpha pixels
+    def clean_edges
+      threshold = @config.ghost_threshold
+
+      # Use ImageMagick to selectively remove pixels below alpha threshold
+      # This preserves RGB data and anti-aliasing for pixels above threshold
+      threshold_fraction = threshold / 255.0
+
+      # Use direct -fx operation on alpha channel with explicit RGB preservation
+      # Use png:color-type=6 to force RGBA output (handles grayscale inputs)
+      # Use 'u' to refer to current channel value in -channel context
+      convert_cmd = Platform.imagemagick_convert_cmd
+      cmd = "#{convert_cmd} #{Utils::PathHelper.quote_path(@output_image)} " \
+            "-define png:color-type=6 " \
+            "-alpha set " \
+            "-channel A " \
+            "-fx \"u < #{threshold_fraction} ? 0 : u\" " \
+            "+channel " \
+            "#{Utils::PathHelper.quote_path(@output_image)}"
+
+      stdout, stderr, status = Open3.capture3(cmd)
+
+      unless status.success?
+        warn "Failed to clean edges: #{stderr}"
+        return false
+      end
+
+      true
+    end
+
+    # Perform multiple cleanup passes
+    def multi_pass_cleanup
+      passes = 0
+      previous_ghost_count = @ghost_pixels_detected
+
+      MAX_PASSES.times do
+        passes += 1
+
+        # Perform cleanup pass
+        clean_edges
+
+        # Check if we still have ghost pixels
+        current_ghost_count = detect_ghost_pixels_from_file(@output_image)
+
+        # Stop if no improvement or no ghost pixels remain
+        break if current_ghost_count == 0
+        break if current_ghost_count >= previous_ghost_count
+
+        previous_ghost_count = current_ghost_count
+      end
+
+      # Update instance variable for reporting
+      @passes_performed = passes
+
+      passes
+    end
+
+    # Generate processing report
+    def report
+      {
+        ghost_pixels_detected: @ghost_pixels_detected,
+        threshold_used: @config.ghost_threshold,
+        passes_performed: @passes_performed,
+        processing_time: @processing_time.round(3),
+        max_passes: MAX_PASSES
+      }
+    end
+
+    private
+
+    def detect_ghost_pixels_from_file(file_path)
+      threshold = @config.ghost_threshold
+      threshold_fraction = threshold / 255.0
+
+      convert_cmd = Platform.imagemagick_convert_cmd
+      cmd = "#{convert_cmd} #{Utils::PathHelper.quote_path(file_path)} " \
+            "-channel A " \
+            "-separate " \
+            "-threshold #{(threshold_fraction * 100).to_i}% " \
+            "-format '%[fx:w*h*(1-mean)]' " \
+            "info:"
+
+      stdout, stderr, status = Open3.capture3(cmd)
+
+      if status.success?
+        stdout.strip.gsub("'", '').to_f.to_i
+      else
+        0
+      end
+    end
+  end
+end