ruby_spriter 0.6.7 → 0.7.0.1

data/lib/ruby_spriter/smoke_detector.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'fileutils'
+
+module RubySpriter
+  # SmokeDetector identifies and optionally removes smoke-like transparency gradients
+  # Detects alpha values between 20-80% in contiguous regions
+  class SmokeDetector
+    attr_reader :input_image, :output_image, :config
+    attr_reader :smoke_regions, :processing_time
+
+    # Smoke detection thresholds
+    MIN_ALPHA = 0.2   # 20% - minimum alpha for smoke
+    MAX_ALPHA = 0.8   # 80% - maximum alpha for smoke
+    MIN_AREA = 50     # Minimum contiguous area in pixels
+
+    def initialize(input_image, output_image, config)
+      @input_image = input_image
+      @output_image = output_image
+      @config = config
+      @smoke_regions = []
+      @processing_time = 0
+    end
+
+    # Main processing method
+    def process
+      start_time = Time.now
+
+      # Validate input file exists
+      unless File.exist?(@input_image)
+        warn "SmokeDetector: Input image does not exist: #{@input_image}"
+        @processing_time = Time.now - start_time
+        return false
+      end
+
+      # Always detect smoke (for reporting)
+      @smoke_regions = detect
+
+      # Remove smoke if configured
+      if @config.remove_smoke
+        FileUtils.cp(@input_image, @output_image)
+        remove_smoke_regions(@smoke_regions)
+      else
+        # Just copy input to output
+        FileUtils.cp(@input_image, @output_image)
+      end
+
+      @processing_time = Time.now - start_time
+
+      true
+    end
+
+    # Detect smoke-like transparency gradients
+    def detect
+      regions = []
+
+      # Use ImageMagick to analyze alpha channel
+      # Find regions with alpha in the smoke range (20-80%)
+      regions = find_smoke_regions
+
+      # Filter by minimum area
+      regions.select { |r| r[:area] >= MIN_AREA }
+    end
+
+    # Remove detected smoke regions
+    def remove_smoke_regions(regions)
+      return true if regions.empty?
+
+      # Apply smoke removal to the entire image
+      # Remove all pixels with alpha in the smoke range
+      remove_smoke_pixels
+
+      true
+    end
+
+    # Check if alpha value is smoke-like
+    def is_smoke_like?(alpha)
+      alpha >= MIN_ALPHA && alpha <= MAX_ALPHA
+    end
+
+    # Generate detection report
+    def report
+      {
+        smoke_detected: @smoke_regions.length,
+        smoke_removed: @config.remove_smoke,
+        smoke_regions: @smoke_regions.map do |r|
+          {
+            x: r[:x],
+            y: r[:y],
+            area: r[:area],
+            alpha_range: r[:alpha_range]
+          }
+        end,
+        processing_time: @processing_time.round(3),
+        min_alpha_threshold: MIN_ALPHA,
+        max_alpha_threshold: MAX_ALPHA,
+        min_area_threshold: MIN_AREA
+      }
+    end
+
+    private
+
+    def find_smoke_regions
+      regions = []
+
+      # Get image dimensions
+      cmd = "magick identify -format \"%w %h\" #{Utils::PathHelper.quote_path(@input_image)}"
+      stdout, stderr, status = Open3.capture3(cmd)
+
+      return regions unless status.success?
+
+      width, height = stdout.strip.split.map(&:to_i)
+      return regions if width == 0 || height == 0
+
+      # Sample grid to find smoke-like regions
+      step = 20
+      visited = {}
+
+      (step...height).step(step) do |y|
+        (step...width).step(step) do |x|
+          next if visited["#{x},#{y}"]
+
+          alpha = get_alpha_at_point(x, y)
+
+          if alpha && is_smoke_like?(alpha)
+            # Found a smoke-like pixel, estimate region
+            area = estimate_smoke_area(x, y, visited)
+
+            if area >= MIN_AREA
+              regions << {
+                x: x,
+                y: y,
+                area: area,
+                alpha_range: [MIN_ALPHA, MAX_ALPHA]
+              }
+            end
+          end
+        end
+      end
+
+      regions
+    end
+
+    def get_alpha_at_point(x, y)
+      cmd = "magick #{Utils::PathHelper.quote_path(@input_image)} " \
+            "-format \"%[pixel:p{#{x},#{y}}]\" info:"
+      stdout, stderr, status = Open3.capture3(cmd)
+
+      return nil unless status.success?
+
+      # Parse alpha from output like "srgba(255,255,255,0.5)" or "gray(128,0.5)"
+      if stdout =~ /[a-z]+\([^)]+,([0-9.]+)\)/
+        $1.to_f
+      elsif stdout =~ /[a-z]+\([^)]+\)/ && stdout !~ /,/
+        # No alpha in output, fully opaque
+        1.0
+      else
+        # Try to extract from different format
+        1.0
+      end
+    end
+
+    def estimate_smoke_area(x, y, visited)
+      # Simple flood fill estimation for smoke region
+      queue = [[x, y]]
+      area = 0
+      max_checks = 100  # Limit to prevent long processing
+
+      while !queue.empty? && area < max_checks
+        cx, cy = queue.shift
+        key = "#{cx},#{cy}"
+
+        next if visited[key]
+
+        alpha = get_alpha_at_point(cx, cy)
+
+        if alpha && is_smoke_like?(alpha)
+          visited[key] = true
+          area += 1
+
+          # Add neighbors (simplified 4-directional)
+          [[cx + 20, cy], [cx - 20, cy], [cx, cy + 20], [cx, cy - 20]].each do |nx, ny|
+            queue << [nx, ny] unless visited["#{nx},#{ny}"]
+          end
+        else
+          visited[key] = true
+        end
+      end
+
+      # Approximate actual area (we sampled every 20 pixels)
+      area * 400  # 20x20 = 400 pixels per sample
+    end
+
+    def remove_smoke_pixels
+      # Use ImageMagick to remove pixels with alpha in smoke range
+      # Convert pixels with alpha 20-80% to fully transparent
+
+      min_threshold = (MIN_ALPHA * 100).to_i
+      max_threshold = (MAX_ALPHA * 100).to_i
+
+      # Use -fx to conditionally set alpha:
+      # if alpha is between MIN_ALPHA and MAX_ALPHA, set to 0 (transparent)
+      # otherwise keep original alpha
+      cmd = "magick #{Utils::PathHelper.quote_path(@output_image)} " \
+            "-define png:color-type=6 " \
+            "-alpha set " \
+            "-channel A " \
+            "-fx \"(u >= #{MIN_ALPHA} && u <= #{MAX_ALPHA}) ? 0 : u\" " \
+            "+channel " \
+            "#{Utils::PathHelper.quote_path(@output_image)}"
+
+      stdout, stderr, status = Open3.capture3(cmd)
+
+      unless status.success?
+        warn "Failed to remove smoke pixels: #{stderr}"
+        return false
+      end
+
+      true
+    end
+  end
+end

data/lib/ruby_spriter/threshold_stepper.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'timeout'
+require 'tmpdir'
+
+module RubySpriter
+  # ThresholdStepper applies multiple threshold-based background removal passes
+  # using GIMP Python-fu with edge-sampled background colors
+  class ThresholdStepper
+    attr_reader :input_file, :output_file, :background_palette, :gimp_processor, :options
+
+    def initialize(input_file, output_file, background_palette, gimp_processor, options = {})
+      @input_file = input_file
+      @output_file = output_file
+      @background_palette = background_palette
+      @gimp_processor = gimp_processor
+      @options = options
+      @threshold_values = parse_threshold_values(options[:threshold_values])
+      @threshold_timeout = options[:threshold_timeout] || 60
+      @total_timeout = options[:total_threshold_timeout] || 300
+      @thresholds_processed = 0
+      @skipped_thresholds = 0
+      @start_time = nil
+      @end_time = nil
+    end
+
+    def process
+      @start_time = Time.now
+      temp_results = []
+
+      begin
+        Timeout.timeout(@total_timeout) do
+          @threshold_values.each_with_index do |threshold, index|
+            temp_output = File.join(Dir.tmpdir, "threshold_#{threshold}_#{Time.now.to_i}_#{index}.png")
+
+            begin
+              Timeout.timeout(@threshold_timeout) do
+                script = generate_gimp_script(threshold, temp_output)
+
+                if @gimp_processor.execute_python_script(script, temp_output)
+                  temp_results << temp_output
+                  @thresholds_processed += 1
+                else
+                  @skipped_thresholds += 1
+                  log_debug "Threshold #{threshold} failed to process"
+                end
+              end
+            rescue Timeout::Error
+              @skipped_thresholds += 1
+              log_debug "Threshold #{threshold} timed out after #{@threshold_timeout}s"
+            rescue StandardError => e
+              @skipped_thresholds += 1
+              log_debug "Threshold #{threshold} error: #{e.message}"
+            end
+          end
+        end
+      rescue Timeout::Error
+        log_debug "Total threshold stepping timed out after #{@total_timeout}s"
+      end
+
+      @end_time = Time.now
+
+      # Composite all threshold results
+      if temp_results.any?
+        composite_results(temp_results)
+      else
+        # Fallback: copy input to output if no thresholds succeeded
+        FileUtils.cp(@input_file, @output_file)
+      end
+
+      # Cleanup temp files
+      temp_results.each { |f| File.delete(f) if File.exist?(f) }
+    end
+
+    def report
+      {
+        thresholds_processed: @thresholds_processed,
+        skipped_thresholds: @skipped_thresholds,
+        total_time: @end_time && @start_time ? (@end_time - @start_time).round(2) : 0
+      }
+    end
+
+    private
+
+    def parse_threshold_values(custom_values)
+      if custom_values.is_a?(String)
+        custom_values.split(',').map(&:strip).map(&:to_f)
+      elsif custom_values.is_a?(Array)
+        custom_values.map(&:to_f)
+      else
+        # Default threshold values
+        [0.0, 0.5, 1.0, 3.0, 5.0, 10.0]
+      end
+    end
+
+    def generate_gimp_script(threshold, output_path)
+      # Build color list for GIMP script
+      color_definitions = @background_palette.map.with_index do |color, idx|
+        "    color#{idx} = Gegl.Color.new('rgb(#{color[:r] / 255.0}, #{color[:g] / 255.0}, #{color[:b] / 255.0})')"
+      end.join("\n")
+
+      color_selections = @background_palette.map.with_index do |color, idx|
+        operation = idx == 0 ? 'Gimp.ChannelOps.REPLACE' : 'Gimp.ChannelOps.ADD'
+        <<~PYTHON.chomp
+            # Select color #{idx + 1}
+            config = select_proc.create_config()
+            config.set_property('image', img)
+            config.set_property('operation', #{operation})
+            config.set_property('drawable', layer)
+            config.set_property('color', color#{idx})
+            config.set_property('threshold', #{threshold})
+            select_proc.run(config)
+        PYTHON
+      end.join("\n\n")
+
+      <<~PYTHON
+        #!/usr/bin/env python3
+        import gi
+        gi.require_version('Gimp', '3.0')
+        gi.require_version('Gegl', '0.4')
+        from gi.repository import Gimp, GLib, Gio, Gegl
+        import sys
+
+        def threshold_step():
+            try:
+                Gegl.init(None)
+
+                # Load image
+                img = Gimp.file_load(Gimp.RunMode.NONINTERACTIVE,
+                                    Gio.File.new_for_path(r'#{@input_file}'))
+
+                if not img:
+                    raise Exception("Failed to load image")
+
+                layers = img.get_layers()
+                if not layers:
+                    raise Exception("No layers found in image")
+
+                layer = layers[0]
+
+                # Add alpha channel if needed
+                if not layer.has_alpha():
+                    layer.add_alpha()
+
+                pdb = Gimp.get_pdb()
+
+                # Get select-color procedure
+                select_proc = pdb.lookup_procedure('gimp-image-select-color')
+                if not select_proc:
+                    raise Exception("Could not find gimp-image-select-color procedure")
+
+                # Define background colors
+        #{color_definitions}
+
+                # Select all background colors with threshold
+        #{color_selections}
+
+                # Delete selection (make transparent)
+                edit_clear = pdb.lookup_procedure('gimp-drawable-edit-clear')
+                config = edit_clear.create_config()
+                config.set_property('drawable', layer)
+                edit_clear.run(config)
+
+                # Deselect
+                select_none = pdb.lookup_procedure('gimp-selection-none')
+                config = select_none.create_config()
+                config.set_property('image', img)
+                select_none.run(config)
+
+                # Export
+                export_proc = pdb.lookup_procedure('file-png-export')
+                config = export_proc.create_config()
+                config.set_property('image', img)
+                config.set_property('file', Gio.File.new_for_path(r'#{output_path}'))
+                export_proc.run(config)
+
+                print("SUCCESS - Threshold #{threshold} complete!")
+                return 0
+            except Exception as e:
+                print(f"ERROR: {e}")
+                import traceback
+                traceback.print_exc()
+                return 1
+
+        sys.exit(threshold_step())
+      PYTHON
+    end
+
+    def composite_results(temp_files)
+      # Use ImageMagick to composite all threshold results
+      # Layer them with DstOver mode (later layers go behind earlier ones)
+
+      if temp_files.length == 1
+        # Only one result, just copy it
+        FileUtils.cp(temp_files.first, @output_file)
+        return
+      end
+
+      # Build composite command
+      # Start with the first result as base
+      cmd_parts = ['magick', Utils::PathHelper.quote_path(temp_files.first)]
+
+      # Add each subsequent result as a layer
+      temp_files[1..-1].each do |temp_file|
+        cmd_parts << Utils::PathHelper.quote_path(temp_file)
+        cmd_parts << '-compose' << 'DstOver' << '-composite'
+      end
+
+      # Output final result
+      cmd_parts << Utils::PathHelper.quote_path(@output_file)
+
+      cmd = cmd_parts.join(' ')
+      stdout, stderr, status = Open3.capture3(cmd)
+
+      unless status.success?
+        raise ProcessingError, "Failed to composite threshold results: #{stderr}"
+      end
+    end
+
+    def log_debug(message)
+      return unless @options[:debug]
+
+      Utils::OutputFormatter.indent("DEBUG: #{message}")
+    end
+  end
+end

data/lib/ruby_spriter/utils/file_helper.rb

@@ -1,82 +1,82 @@
-# frozen_string_literal: true
-
-module RubySpriter
-  module Utils
-    # File naming and size utilities
-    class FileHelper
-      class << self
-        # Generate spritesheet filename from video file
-        # @param video_file [String] Path to video file
-        # @return [String] Generated spritesheet filename
-        def spritesheet_filename(video_file)
-          dir = File.dirname(video_file)
-          basename = File.basename(video_file, '.*')
-          File.join(dir, "#{basename}_spritesheet.png")
-        end
-
-        # Generate output filename with suffix
-        # @param input_file [String] Original input file
-        # @param suffix [String] Suffix to add to filename
-        # @return [String] Generated output filename
-        def output_filename(input_file, suffix)
-          dir = File.dirname(input_file)
-          basename = File.basename(input_file, '.*')
-          File.join(dir, "#{basename}-#{suffix}.png")
-        end
-
-        # Format file size in human-readable format
-        # @param bytes [Integer] File size in bytes
-        # @return [String] Formatted file size
-        def format_size(bytes)
-          if bytes >= 1024 * 1024
-            "#{(bytes / (1024.0 * 1024.0)).round(2)} MB"
-          elsif bytes >= 1024
-            "#{(bytes / 1024.0).round(2)} KB"
-          else
-            "#{bytes} bytes"
-          end
-        end
-
-        # Validate file exists
-        # @param path [String] File path to validate
-        # @raise [ValidationError] if file doesn't exist
-        def validate_exists!(path)
-          raise ValidationError, "File not found: #{path}" unless File.exist?(path)
-        end
-
-        # Validate file is readable
-        # @param path [String] File path to validate
-        # @raise [ValidationError] if file isn't readable
-        def validate_readable!(path)
-          validate_exists!(path)
-          raise ValidationError, "File not readable: #{path}" unless File.readable?(path)
-        end
-
-        # Generate unique filename by adding timestamp if file exists
-        # @param path [String] Original file path
-        # @return [String] Unique file path (adds timestamp if original exists)
-        def unique_filename(path)
-          return path unless File.exist?(path)
-
-          dir = File.dirname(path)
-          ext = File.extname(path)
-          basename = File.basename(path, ext)
-          timestamp = Time.now.strftime('%Y%m%d_%H%M%S_%3N') # Include milliseconds
-
-          File.join(dir, "#{basename}_#{timestamp}#{ext}")
-        end
-
-        # Ensure output filename is unique based on overwrite option
-        # @param path [String] Desired output path
-        # @param overwrite [Boolean] If true, return original path; if false, make unique
-        # @return [String] Output path (unique if overwrite is false and file exists)
-        def ensure_unique_output(path, overwrite: false)
-          return path if overwrite
-          return path unless File.exist?(path)
-
-          unique_filename(path)
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubySpriter
+  module Utils
+    # File naming and size utilities
+    class FileHelper
+      class << self
+        # Generate spritesheet filename from video file
+        # @param video_file [String] Path to video file
+        # @return [String] Generated spritesheet filename
+        def spritesheet_filename(video_file)
+          dir = File.dirname(video_file)
+          basename = File.basename(video_file, '.*')
+          File.join(dir, "#{basename}_spritesheet.png")
+        end
+
+        # Generate output filename with suffix
+        # @param input_file [String] Original input file
+        # @param suffix [String] Suffix to add to filename
+        # @return [String] Generated output filename
+        def output_filename(input_file, suffix)
+          dir = File.dirname(input_file)
+          basename = File.basename(input_file, '.*')
+          File.join(dir, "#{basename}-#{suffix}.png")
+        end
+
+        # Format file size in human-readable format
+        # @param bytes [Integer] File size in bytes
+        # @return [String] Formatted file size
+        def format_size(bytes)
+          if bytes >= 1024 * 1024
+            "#{(bytes / (1024.0 * 1024.0)).round(2)} MB"
+          elsif bytes >= 1024
+            "#{(bytes / 1024.0).round(2)} KB"
+          else
+            "#{bytes} bytes"
+          end
+        end
+
+        # Validate file exists
+        # @param path [String] File path to validate
+        # @raise [ValidationError] if file doesn't exist
+        def validate_exists!(path)
+          raise ValidationError, "File not found: #{path}" unless File.exist?(path)
+        end
+
+        # Validate file is readable
+        # @param path [String] File path to validate
+        # @raise [ValidationError] if file isn't readable
+        def validate_readable!(path)
+          validate_exists!(path)
+          raise ValidationError, "File not readable: #{path}" unless File.readable?(path)
+        end
+
+        # Generate unique filename by adding timestamp if file exists
+        # @param path [String] Original file path
+        # @return [String] Unique file path (adds timestamp if original exists)
+        def unique_filename(path)
+          return path unless File.exist?(path)
+
+          dir = File.dirname(path)
+          ext = File.extname(path)
+          basename = File.basename(path, ext)
+          timestamp = Time.now.strftime('%Y%m%d_%H%M%S_%3N') # Include milliseconds
+
+          File.join(dir, "#{basename}_#{timestamp}#{ext}")
+        end
+
+        # Ensure output filename is unique based on overwrite option
+        # @param path [String] Desired output path
+        # @param overwrite [Boolean] If true, return original path; if false, make unique
+        # @return [String] Output path (unique if overwrite is false and file exists)
+        def ensure_unique_output(path, overwrite: false)
+          return path if overwrite
+          return path unless File.exist?(path)
+
+          unique_filename(path)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_spriter/utils/image_helper.rb

@@ -0,0 +1,16 @@
+module RubySpriter
+  module Utils
+    module ImageHelper
+      def self.get_dimensions(image_path)
+        # Execute ImageMagick to get image dimensions
+        cmd = "magick identify -format \"%wx%h\" #{PathHelper.quote_path(image_path)}"
+        stdout, _stderr, status = Open3.capture3(cmd)
+
+        raise ProcessingError, "Failed to get image dimensions: #{image_path}" unless status.success?
+
+        dimensions = stdout.strip.split('x')
+        { width: dimensions[0].to_i, height: dimensions[1].to_i }
+      end
+    end
+  end
+end