ruby_spriter 0.6.7.1 → 0.7.0.1

data/bin/ruby_spriter

@@ -1,20 +1,20 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# Add lib directory to load path
-lib = File.expand_path('../lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-
-require 'ruby_spriter'
-
-# Run the CLI
-begin
-  RubySpriter::CLI.start(ARGV)
-rescue Interrupt
-  puts "\n\n⚠️  Process interrupted by user"
-  exit 130
-rescue StandardError => e
-  puts "\n❌ ERROR: #{e.message}"
-  puts e.backtrace.join("\n") if ENV['DEBUG']
-  exit 1
-end
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Add lib directory to load path
+lib = File.expand_path('../lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'ruby_spriter'
+
+# Run the CLI
+begin
+  RubySpriter::CLI.start(ARGV)
+rescue Interrupt
+  puts "\n\n⚠️  Process interrupted by user"
+  exit 130
+rescue StandardError => e
+  puts "\n❌ ERROR: #{e.message}"
+  puts e.backtrace.join("\n") if ENV['DEBUG']
+  exit 1
+end

data/lib/ruby_spriter/background_sampler.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module RubySpriter
+  # BackgroundSampler collects unique background colors from interior image regions
+  #
+  # Sampling Strategy:
+  # - Starts at (sample_offset, sample_offset) to avoid edge compression artifacts
+  # - Samples horizontally across the image with calculated intervals
+  # - Moves to next row if not enough unique colors found
+  # - Uses pixel cache for fast lookups (loads all pixels once)
+  class BackgroundSampler
+    attr_reader :image_path, :sample_offset, :sample_count, :max_rows
+
+    def initialize(image_path, sample_offset = 5, sample_count = 10, max_rows = 20)
+      @image_path = image_path
+      @sample_offset = sample_offset
+      @sample_count = sample_count
+      @max_rows = max_rows
+      @image_width = nil
+      @image_height = nil
+      @pixel_cache = nil
+    end
+
+    # Collect unique background colors by sampling interior regions
+    def collect_unique_colors
+      load_image_dimensions
+      load_pixel_cache
+
+      # Input validation
+      if @sample_count < 2
+        raise ValidationError, "sample_count must be at least 2"
+      end
+
+      usable_width = @image_width - (2 * @sample_offset)
+      if usable_width <= 0
+        raise ValidationError, "sample_offset (#{@sample_offset}) too large for image width (#{@image_width})"
+      end
+
+      unique_colors = []
+      y = @sample_offset
+      rows_sampled = 0
+
+      while unique_colors.length < @sample_count && rows_sampled < @max_rows
+        # Calculate interval across usable width (excluding offset margins on both sides)
+        interval = (@image_width - 2 * @sample_offset).to_f / (@sample_count - 1)
+
+        # Sample across the width at current y position
+        @sample_count.times do |i|
+          x = @sample_offset + (i * interval).round
+
+          # Ensure x is within bounds
+          x = x.clamp(@sample_offset, @image_width - @sample_offset - 1)
+
+          color = sample_pixel(x, y)
+
+          if color && !color_exists?(unique_colors, color)
+            unique_colors << color
+            break if unique_colors.length >= @sample_count
+          end
+        end
+
+        # Move to next row
+        y += 1
+        rows_sampled += 1
+      end
+
+      unique_colors
+    end
+
+    private
+
+    def load_image_dimensions
+      identify_cmd = Platform.imagemagick_identify_cmd
+      cmd = "#{identify_cmd} -format \"%w %h\" #{Utils::PathHelper.quote_path(@image_path)}"
+      stdout, stderr, status = Open3.capture3(cmd)
+
+      unless status.success?
+        raise ProcessingError, "Failed to get image dimensions: #{stderr}"
+      end
+
+      @image_width, @image_height = stdout.strip.split.map(&:to_i)
+    end
+
+    def load_pixel_cache
+      return if @pixel_cache
+
+      convert_cmd = Platform.imagemagick_convert_cmd
+      cmd = "#{convert_cmd} #{Utils::PathHelper.quote_path(@image_path)} txt:-"
+      stdout, stderr, status = Open3.capture3(cmd)
+
+      unless status.success?
+        raise ProcessingError, "Failed to load pixel cache: #{stderr}"
+      end
+
+      @pixel_cache = {}
+
+      stdout.each_line do |line|
+        next if line.start_with?('#')
+
+        if line =~ /^(\d+),(\d+):\s+\((\d+),(\d+),(\d+)/
+          x = $1.to_i
+          y = $2.to_i
+          r = $3.to_i
+          g = $4.to_i
+          b = $5.to_i
+
+          @pixel_cache[[x, y]] = { r: r, g: g, b: b }
+        end
+      end
+    end
+
+    def sample_pixel(x, y)
+      # Fallback to direct ImageMagick call if cache not loaded (for testing)
+      return @pixel_cache[[x, y]] if @pixel_cache
+
+      convert_cmd = Platform.imagemagick_convert_cmd
+      cmd = "#{convert_cmd} #{Utils::PathHelper.quote_path(@image_path)} -format \"%[pixel:p{#{x},#{y}}]\" info:"
+      stdout, stderr, status = Open3.capture3(cmd)
+
+      return nil unless status.success?
+
+      # Parse output like "srgb(255,255,255)", "srgba(255,255,255,1.0)", or "gray(255)"
+      if stdout =~ /srgba?\((\d+),(\d+),(\d+)/
+        { r: $1.to_i, g: $2.to_i, b: $3.to_i }
+      elsif stdout =~ /gray\((\d+)\)/
+        # Convert grayscale to RGB
+        gray_value = $1.to_i
+        { r: gray_value, g: gray_value, b: gray_value }
+      else
+        nil
+      end
+    end
+
+    def color_exists?(colors, new_color)
+      colors.any? { |c| c[:r] == new_color[:r] && c[:g] == new_color[:g] && c[:b] == new_color[:b] }
+    end
+  end
+end

data/lib/ruby_spriter/batch_processor.rb

@@ -1,214 +1,268 @@
-# frozen_string_literal: true
-
-require 'fileutils'
-
-module RubySpriter
-  # Processes multiple videos in batch mode
-  class BatchProcessor
-    attr_reader :options
-
-    def initialize(options = {})
-      @options = options
-      validate_directory!
-    end
-
-    # Find all MP4 files in the directory
-    # @return [Array<String>] List of MP4 file paths
-    def find_videos
-      pattern = File.join(options[:dir], '*.mp4')
-      videos = Dir.glob(pattern)
-
-      if videos.empty?
-        raise ValidationError, "No MP4 files found in directory: #{options[:dir]}"
-      end
-
-      if options[:debug]
-        Utils::OutputFormatter.note("Found #{videos.length} video(s) to process")
-        videos.each { |v| Utils::OutputFormatter.indent(File.basename(v)) }
-      end
-
-      videos
-    end
-
-    # Process all videos in the directory
-    # @return [Hash] Processing results with outputs and errors
-    def process
-      videos = find_videos
-      output_dir = determine_output_directory
-      ensure_output_directory_exists(output_dir)
-
-      results = {
-        processed_count: 0,
-        outputs: [],
-        errors: []
-      }
-
-      Utils::OutputFormatter.header("Batch Processing: #{videos.length} video(s)")
-
-      videos.each_with_index do |video, index|
-        begin
-          puts "\nProcessing [#{index + 1}/#{videos.length}]: #{File.basename(video)}"
-
-          output_file = determine_output_file(video, output_dir)
-          output_file = Utils::FileHelper.ensure_unique_output(output_file, overwrite: options[:overwrite])
-
-          # Process video
-          video_result = process_video(video, output_file)
-
-          # Apply max compression if requested
-          if options[:max_compress] && video_result[:output_file]
-            video_result[:output_file] = apply_compression(video_result[:output_file])
-          end
-
-          results[:outputs] << video_result[:output_file]
-          results[:processed_count] += 1
-
-          Utils::OutputFormatter.success("Output: #{File.basename(video_result[:output_file])}")
-        rescue StandardError => e
-          error_msg = "#{File.basename(video)}: #{e.message}"
-          results[:errors] << error_msg
-          Utils::OutputFormatter.error(error_msg)
-        end
-      end
-
-      # Consolidate if requested
-      if options[:batch_consolidate] && results[:outputs].any?
-        consolidated = consolidate_results(results[:outputs])
-        results[:consolidated] = consolidated if consolidated
-      end
-
-      display_summary(results)
-
-      results
-    end
-
-    # Consolidate all resulting spritesheets
-    # @param outputs [Array<String>] List of spritesheet file paths
-    # @return [Hash, nil] Consolidation result or nil if not requested
-    def consolidate_results(outputs)
-      return nil unless options[:batch_consolidate]
-      return nil if outputs.empty?
-
-      Utils::OutputFormatter.header("Consolidating #{outputs.length} spritesheets")
-
-      output_dir = options[:outputdir] || options[:dir]
-      consolidated_file = File.join(output_dir, 'batch_consolidated_spritesheet.png')
-      consolidated_file = Utils::FileHelper.ensure_unique_output(consolidated_file, overwrite: options[:overwrite])
-
-      consolidator = Consolidator.new(options)
-      result = consolidator.consolidate(outputs, consolidated_file)
-
-      Utils::OutputFormatter.success("Consolidated output: #{File.basename(consolidated_file)}")
-
-      result
-    end
-
-    private
-
-    def validate_directory!
-      dir = options[:dir]
-
-      raise ValidationError, "Must specify --dir for batch processing" unless dir
-      raise ValidationError, "Directory not found: #{dir}" unless File.directory?(dir)
-    end
-
-    def determine_output_directory
-      options[:outputdir] || options[:dir]
-    end
-
-    def ensure_output_directory_exists(dir)
-      return if File.directory?(dir)
-
-      if options[:debug]
-        Utils::OutputFormatter.note("Creating output directory: #{dir}")
-      end
-
-      FileUtils.mkdir_p(dir)
-    end
-
-    def determine_output_file(video_file, output_dir)
-      basename = File.basename(video_file, '.*')
-      File.join(output_dir, "#{basename}_spritesheet.png")
-    end
-
-    def process_video(video_file, output_file)
-      video_processor = VideoProcessor.new(options)
-      result = video_processor.create_spritesheet(video_file, output_file)
-
-      working_file = result[:output_file]
-
-      # Apply GIMP processing if requested
-      if needs_gimp_processing?
-        working_file = process_with_gimp(working_file, result)
-      end
-
-      # Update result with final file
-      result[:output_file] = working_file
-      result
-    end
-
-    def needs_gimp_processing?
-      options[:scale_percent] || options[:remove_bg] || options[:sharpen]
-    end
-
-    def process_with_gimp(input_file, video_result)
-      # Get GIMP path and version from dependency checker
-      checker = DependencyChecker.new(verbose: false)
-      results = checker.check_all
-      gimp_path = checker.gimp_path
-      gimp_version = checker.gimp_version
-
-      unless gimp_path
-        raise DependencyError, "GIMP not found but required for processing"
-      end
-
-      gimp_options = options.merge(gimp_version: gimp_version)
-      gimp_processor = GimpProcessor.new(gimp_path, gimp_options)
-      output_file = gimp_processor.process(input_file)
-
-      # Clean up intermediate file if different
-      if output_file != input_file && File.exist?(input_file)
-        File.delete(input_file) unless options[:keep_temp]
-      end
-
-      output_file
-    end
-
-    def apply_compression(file)
-      Utils::OutputFormatter.indent("Applying maximum compression...")
-
-      temp_file = file.gsub('.png', '_temp.png')
-      CompressionManager.compress_with_metadata(file, temp_file)
-
-      # Show compression stats
-      if options[:debug]
-        stats = CompressionManager.compression_stats(file, temp_file)
-        Utils::OutputFormatter.indent("Saved #{Utils::FileHelper.format_size(stats[:saved_bytes])} (#{stats[:reduction_percent].round(1)}% reduction)")
-      end
-
-      # Replace original with compressed
-      FileUtils.mv(temp_file, file)
-
-      file
-    end
-
-    def display_summary(results)
-      Utils::OutputFormatter.header("Batch Processing Summary")
-
-      puts "Total videos: #{results[:processed_count] + results[:errors].length}"
-      Utils::OutputFormatter.success("Successfully processed: #{results[:processed_count]}")
-
-      if results[:errors].any?
-        Utils::OutputFormatter.error("Failed: #{results[:errors].length}")
-        results[:errors].each do |error|
-          Utils::OutputFormatter.indent("- #{error}")
-        end
-      end
-
-      if results[:consolidated]
-        puts "\nConsolidated spritesheet:"
-        Utils::OutputFormatter.indent(results[:consolidated][:output_file])
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module RubySpriter
+  # Processes multiple videos in batch mode
+  class BatchProcessor
+    attr_reader :options
+
+    def initialize(options = {})
+      @options = options
+      @gimp_path = nil
+      @gimp_version = nil
+      validate_directory!
+      setup_dependencies if needs_dependency_setup?
+    end
+
+    # Find all MP4 files in the directory
+    # @return [Array<String>] List of MP4 file paths
+    def find_videos
+      pattern = File.join(options[:dir], '*.mp4')
+      videos = Dir.glob(pattern)
+
+      if videos.empty?
+        raise ValidationError, "No MP4 files found in directory: #{options[:dir]}"
+      end
+
+      if options[:debug]
+        Utils::OutputFormatter.note("Found #{videos.length} video(s) to process")
+        videos.each { |v| Utils::OutputFormatter.indent(File.basename(v)) }
+      end
+
+      videos
+    end
+
+    # Process all videos in the directory
+    # @return [Hash] Processing results with outputs and errors
+    def process
+      videos = find_videos
+      output_dir = determine_output_directory
+      ensure_output_directory_exists(output_dir)
+
+      results = {
+        processed_count: 0,
+        outputs: [],
+        errors: []
+      }
+
+      Utils::OutputFormatter.header("Batch Processing: #{videos.length} video(s)")
+
+      videos.each_with_index do |video, index|
+        begin
+          puts "\nProcessing [#{index + 1}/#{videos.length}]: #{File.basename(video)}"
+
+          output_file = determine_output_file(video, output_dir)
+          output_file = Utils::FileHelper.ensure_unique_output(output_file, overwrite: options[:overwrite])
+
+          # Process video
+          video_result = process_video(video, output_file)
+
+          # Apply max compression if requested
+          if options[:max_compress] && video_result[:output_file]
+            video_result[:output_file] = apply_compression(video_result[:output_file])
+          end
+
+          results[:outputs] << video_result[:output_file]
+          results[:processed_count] += 1
+
+          Utils::OutputFormatter.success("Output: #{File.basename(video_result[:output_file])}")
+        rescue StandardError => e
+          error_msg = "#{File.basename(video)}: #{e.message}"
+          results[:errors] << error_msg
+          Utils::OutputFormatter.error(error_msg)
+        end
+      end
+
+      # Consolidate if requested
+      if options[:batch_consolidate] && results[:outputs].any?
+        consolidated = consolidate_results(results[:outputs])
+        results[:consolidated] = consolidated if consolidated
+      end
+
+      display_summary(results)
+
+      results
+    end
+
+    # Consolidate all resulting spritesheets
+    # @param outputs [Array<String>] List of spritesheet file paths
+    # @return [Hash, nil] Consolidation result or nil if not requested
+    def consolidate_results(outputs)
+      return nil unless options[:batch_consolidate]
+      return nil if outputs.empty?
+
+      Utils::OutputFormatter.header("Consolidating #{outputs.length} spritesheets")
+
+      output_dir = options[:outputdir] || options[:dir]
+      consolidated_file = File.join(output_dir, 'batch_consolidated_spritesheet.png')
+      consolidated_file = Utils::FileHelper.ensure_unique_output(consolidated_file, overwrite: options[:overwrite])
+
+      consolidator = Consolidator.new(options)
+      result = consolidator.consolidate(outputs, consolidated_file)
+
+      Utils::OutputFormatter.success("Consolidated output: #{File.basename(consolidated_file)}")
+
+      result
+    end
+
+    private
+
+    def validate_directory!
+      dir = options[:dir]
+
+      raise ValidationError, "Must specify --dir for batch processing" unless dir
+      raise ValidationError, "Directory not found: #{dir}" unless File.directory?(dir)
+    end
+
+    # Check if using frame-by-frame background removal mode
+    # @return [Boolean] true if both --by-frame and --remove-bg flags are set
+    def using_frame_by_frame_background_removal?
+      options[:by_frame] && options[:remove_bg]
+    end
+
+    # Normalize video processing result to standard format
+    # @param result [Hash] Result from process_with_background_removal
+    # @return [Hash] Normalized result with :output_file, :columns, :rows, :frames
+    def normalize_video_result_format(result)
+      {
+        output_file: result[:output_file],
+        columns: result[:columns],
+        rows: (result[:frames].to_f / result[:columns]).ceil,
+        frames: result[:frames]
+      }
+    end
+
+    # Check if we need to setup dependencies (GIMP required)
+    # @return [Boolean] true if any operation requires GIMP
+    def needs_dependency_setup?
+      options[:by_frame] || options[:scale_percent] || options[:remove_bg] || options[:sharpen]
+    end
+
+    # Setup dependencies by checking for required tools
+    # Caches GIMP path and version as instance variables
+    def setup_dependencies
+      checker = DependencyChecker.new(verbose: false)
+      results = checker.check_all
+      @gimp_path = checker.gimp_path
+      @gimp_version = checker.gimp_version
+    end
+
+    def determine_output_directory
+      options[:outputdir] || options[:dir]
+    end
+
+    def ensure_output_directory_exists(dir)
+      return if File.directory?(dir)
+
+      if options[:debug]
+        Utils::OutputFormatter.note("Creating output directory: #{dir}")
+      end
+
+      FileUtils.mkdir_p(dir)
+    end
+
+    def determine_output_file(video_file, output_dir)
+      basename = File.basename(video_file, '.*')
+      File.join(output_dir, "#{basename}_spritesheet.png")
+    end
+
+    def process_video(video_file, output_file)
+      # Check if we need frame-by-frame background removal
+      if using_frame_by_frame_background_removal?
+        # Frame-by-frame processing with background removal
+        unless @gimp_path
+          raise DependencyError, "GIMP not found but required for --by-frame processing"
+        end
+
+        # Pass gimp_path through options
+        video_options = options.merge(gimp_path: @gimp_path)
+        video_processor = VideoProcessor.new(video_options)
+
+        result = video_processor.process_with_background_removal(
+          video_file,
+          output_file,
+          video_options
+        )
+
+        # Normalize result format to match create_spritesheet
+        result = normalize_video_result_format(result)
+
+        working_file = result[:output_file]
+      else
+        # Standard video processing
+        video_processor = VideoProcessor.new(options)
+        result = video_processor.create_spritesheet(video_file, output_file)
+        working_file = result[:output_file]
+
+        # Apply GIMP processing if requested (only for non-by-frame mode)
+        if needs_gimp_processing?
+          working_file = process_with_gimp(working_file, result)
+        end
+      end
+
+      # Update result with final file
+      result[:output_file] = working_file
+      result
+    end
+
+    def needs_gimp_processing?
+      options[:scale_percent] || options[:remove_bg] || options[:sharpen]
+    end
+
+    def process_with_gimp(input_file, video_result)
+      # Use cached GIMP path and version from initialization
+      unless @gimp_path
+        raise DependencyError, "GIMP not found but required for processing"
+      end
+
+      gimp_options = options.merge(gimp_version: @gimp_version)
+      gimp_processor = GimpProcessor.new(@gimp_path, gimp_options)
+      output_file = gimp_processor.process(input_file)
+
+      # Clean up intermediate file if different
+      if output_file != input_file && File.exist?(input_file)
+        File.delete(input_file) unless options[:keep_temp]
+      end
+
+      output_file
+    end
+
+    def apply_compression(file)
+      Utils::OutputFormatter.indent("Applying maximum compression...")
+
+      temp_file = file.gsub('.png', '_temp.png')
+      CompressionManager.compress_with_metadata(file, temp_file)
+
+      # Show compression stats
+      if options[:debug]
+        stats = CompressionManager.compression_stats(file, temp_file)
+        Utils::OutputFormatter.indent("Saved #{Utils::FileHelper.format_size(stats[:saved_bytes])} (#{stats[:reduction_percent].round(1)}% reduction)")
+      end
+
+      # Replace original with compressed
+      FileUtils.mv(temp_file, file)
+
+      file
+    end
+
+    def display_summary(results)
+      Utils::OutputFormatter.header("Batch Processing Summary")
+
+      puts "Total videos: #{results[:processed_count] + results[:errors].length}"
+      Utils::OutputFormatter.success("Successfully processed: #{results[:processed_count]}")
+
+      if results[:errors].any?
+        Utils::OutputFormatter.error("Failed: #{results[:errors].length}")
+        results[:errors].each do |error|
+          Utils::OutputFormatter.indent("- #{error}")
+        end
+      end
+
+      if results[:consolidated]
+        puts "\nConsolidated spritesheet:"
+        Utils::OutputFormatter.indent(results[:consolidated][:output_file])
+      end
+    end
+  end
+end