ruby_spriter 0.6.7 → 0.7.0.1

data/lib/ruby_spriter/cell_cleanup_config.rb

@@ -0,0 +1,21 @@
+module RubySpriter
+  class CellCleanupConfig
+    attr_accessor :threshold, :parallel, :skip_empty
+
+    def initialize(options = {})
+      @threshold = options[:cell_cleanup_threshold] || 15.0
+      @parallel = options.fetch(:cell_cleanup_parallel, true)
+      @skip_empty = options.fetch(:cell_cleanup_skip_empty, true)
+
+      validate!
+    end
+
+    private
+
+    def validate!
+      unless @threshold.between?(1.0, 50.0)
+        raise ValidationError, "cell_cleanup_threshold must be between 1.0 and 50.0 (got: #{@threshold})"
+      end
+    end
+  end
+end

data/lib/ruby_spriter/cell_cleanup_gimp_script.rb

@@ -0,0 +1,123 @@
+module RubySpriter
+  module CellCleanupGimpScript
+    def self.generate_cleanup_script(input_path, output_path, dominant_colors)
+      # Normalize paths for Python
+      input_normalized = Utils::PathHelper.normalize_for_python(input_path)
+      output_normalized = Utils::PathHelper.normalize_for_python(output_path)
+
+      # Convert RGB strings to Python color strings
+      colors_py = dominant_colors.map do |color_str|
+        # Parse "rgb(255,0,0)" format
+        match = color_str.match(/rgb\((\d+),(\d+),(\d+)\)/)
+        r = match[1].to_i
+        g = match[2].to_i
+        b = match[3].to_i
+        "{'r': #{r}, 'g': #{g}, 'b': #{b}}"
+      end.join(', ')
+
+      <<~PYTHON
+        import sys
+        import gc
+        from gi.repository import Gimp, Gio, Gegl
+
+        img = None
+        layer = None
+
+        try:
+            print("Loading image...")
+            img = Gimp.file_load(Gimp.RunMode.NONINTERACTIVE,
+                                Gio.File.new_for_path(r'#{input_normalized}'))
+
+            w = img.get_width()
+            h = img.get_height()
+            print(f"Image size: {w}x{h}")
+
+            layers = img.get_layers()
+            if not layers or len(layers) == 0:
+                raise Exception("No layers found")
+            layer = layers[0]
+
+            # Add alpha channel if needed
+            if not layer.has_alpha():
+                layer.add_alpha()
+                print("Added alpha channel")
+
+            pdb = Gimp.get_pdb()
+
+            # Select dominant colors for removal
+            print("Selecting dominant colors...")
+            select_proc = pdb.lookup_procedure('gimp-image-select-color')
+            if not select_proc:
+                raise Exception("Could not find gimp-image-select-color procedure")
+
+            for i, color_dict in enumerate([#{colors_py}]):
+                r, g, b = color_dict['r'], color_dict['g'], color_dict['b']
+                print(f"  Selecting color {i+1}: RGB({r}, {g}, {b})")
+
+                # Create Gegl.Color from normalized RGB values
+                color = Gegl.Color.new(f"rgb({r/255.0}, {g/255.0}, {b/255.0})")
+
+                config = select_proc.create_config()
+                config.set_property('image', img)
+                # Use REPLACE for first color, ADD for subsequent colors
+                if i == 0:
+                    config.set_property('operation', Gimp.ChannelOps.REPLACE)
+                else:
+                    config.set_property('operation', Gimp.ChannelOps.ADD)
+                config.set_property('drawable', layer)
+                config.set_property('color', color)
+                select_proc.run(config)
+
+            print("Colors selected")
+
+            # Delete selection (make transparent)
+            print("Removing selected colors...")
+            edit_clear = pdb.lookup_procedure('gimp-drawable-edit-clear')
+            if edit_clear:
+                config = edit_clear.create_config()
+                config.set_property('drawable', layer)
+                edit_clear.run(config)
+                print("Selection cleared")
+
+            # Deselect
+            print("Deselecting...")
+            select_none = pdb.lookup_procedure('gimp-selection-none')
+            if select_none:
+                config = select_none.create_config()
+                config.set_property('image', img)
+                select_none.run(config)
+
+            # Export
+            print("Exporting...")
+            export_proc = pdb.lookup_procedure('file-png-export')
+            if export_proc:
+                config = export_proc.create_config()
+                config.set_property('image', img)
+                config.set_property('file', Gio.File.new_for_path(r'#{output_normalized}'))
+                export_proc.run(config)
+                print("SUCCESS - Cell cleanup complete!")
+            else:
+                raise Exception("Could not find file-png-export procedure")
+
+        except Exception as e:
+            print(f"ERROR: {e}")
+            import traceback
+            traceback.print_exc()
+            sys.exit(1)
+        finally:
+            # Explicit cleanup to minimize GEGL warnings
+            try:
+                if layer is not None:
+                    layer = None
+                if img is not None:
+                    gc.collect()  # Force garbage collection
+                    img.delete()
+                    img = None
+                    gc.collect()  # Force again after deletion
+            except Exception as cleanup_error:
+                print(f"Cleanup warning: {cleanup_error}")
+                pass
+      PYTHON
+    end
+  end
+end

data/lib/ruby_spriter/cell_cleanup_processor.rb

@@ -0,0 +1,230 @@
+require 'open3'
+require 'fileutils'
+require 'tmpdir'
+require_relative 'cell_cleanup_config'
+require_relative 'cell_cleanup_gimp_script'
+require_relative 'gimp_processor'
+require_relative 'utils/image_helper'
+
+module RubySpriter
+  class CellCleanupProcessor
+
+    def initialize(options = {})
+      @config = CellCleanupConfig.new(options)
+      @gimp_processor = GimpProcessor.new(options[:gimp_path], options)
+      @options = options
+    end
+
+    # Main method to cleanup background colors in spritesheet cells
+    # @param spritesheet_path [String] Path to the spritesheet PNG
+    # @param options [Hash] Processing options
+    # @return [Hash] Statistics about cleanup process
+    def cleanup_cells(spritesheet_path, options)
+      cell_dims = calculate_cell_dimensions(spritesheet_path, options)
+      rows = calculate_rows(options)
+      columns = options[:columns]
+
+      temp_dir = create_temp_dir
+      cleaned_cells = []
+      stats = { processed: 0, cleaned: 0, skipped: 0, colors_removed: 0 }
+
+      puts "  Analyzing spritesheet: #{columns}×#{rows} grid (#{rows * columns} cells)"
+      puts "  Dominance threshold: #{@config.threshold}%\n\n"
+
+      (0...rows).each do |row|
+        (0...columns).each do |col|
+          stats[:processed] += 1
+
+          # Extract cell region
+          cell_path = extract_cell(spritesheet_path, row, col, cell_dims[:width], cell_dims[:height], temp_dir)
+
+          # Analyze for dominant colors
+          dominant_colors = analyze_cell_colors(cell_path)
+
+          if dominant_colors && !dominant_colors.empty?
+            # Remove dominant colors via GIMP
+            cleaned_cell = remove_dominant_colors(cell_path, dominant_colors, options, temp_dir)
+            cleaned_cells << cleaned_cell
+            stats[:cleaned] += 1
+            stats[:colors_removed] += dominant_colors.length
+
+            puts "  Cell [#{row},#{col}]: Removed #{dominant_colors.length} dominant color(s)"
+          else
+            # No cleanup needed
+            cleaned_cells << cell_path
+            stats[:skipped] += 1
+            puts "  Cell [#{row},#{col}]: No dominant colors detected (skipped)"
+          end
+        end
+      end
+
+      # Reassemble cleaned cells
+      reassemble_spritesheet(cleaned_cells, columns, rows, spritesheet_path)
+
+      puts "\n  ✓ Cleanup complete"
+      puts "  - Processed: #{stats[:processed]} cells"
+      puts "  - Cleaned: #{stats[:cleaned]} cells"
+      puts "  - Skipped: #{stats[:skipped]} cells"
+      puts "  - Dominant colors removed: #{stats[:colors_removed]} total\n"
+
+      stats
+    ensure
+      cleanup_temp_dir(temp_dir) if temp_dir
+    end
+
+    private
+
+    def calculate_cell_dimensions(spritesheet_path, options)
+      image_info = Utils::ImageHelper.get_dimensions(spritesheet_path)
+
+      columns = options[:columns]
+      raise ProcessingError, "columns is nil or zero" if columns.nil? || columns == 0
+
+      rows = calculate_rows(options)
+      raise ProcessingError, "rows is nil or zero" if rows.nil? || rows == 0
+
+      {
+        width: image_info[:width] / columns,
+        height: image_info[:height] / rows
+      }
+    end
+
+    def calculate_rows(options)
+      frames = options[:frames]
+      columns = options[:columns]
+
+      raise ProcessingError, "frames is nil or zero: #{frames.inspect}" if frames.nil? || frames == 0
+      raise ProcessingError, "columns is nil or zero: #{columns.inspect}" if columns.nil? || columns == 0
+
+      (frames.to_f / columns).ceil
+    end
+
+    def parse_histogram(histogram_output)
+      colors = {}
+
+      histogram_output.each_line do |line|
+        # Parse ImageMagick histogram format:
+        # "1234: (255,0,0) #FF0000 srgb(255,0,0)"
+        next unless line.match(/^\s*(\d+):\s*\((\d+),(\d+),(\d+)/)
+
+        count = $1.to_i
+        r = $2.to_i
+        g = $3.to_i
+        b = $4.to_i
+
+        # Skip fully transparent pixels (indicated by rgba format with alpha=0)
+        next if line.include?('srgba') && line.include?(',0)')
+
+        colors["rgb(#{r},#{g},#{b})"] = count
+      end
+
+      colors
+    end
+
+    def analyze_cell_colors(cell_image_path)
+      # Extract histogram using ImageMagick
+      convert_cmd = Platform.imagemagick_convert_cmd
+      cmd = "#{convert_cmd} #{Utils::PathHelper.quote_path(cell_image_path)} -define histogram:unique-colors=true -format %c histogram:info:-"
+      histogram_output = execute_command(cmd)
+
+      # Parse histogram into color => pixel_count hash
+      colors = parse_histogram(histogram_output)
+
+      # Calculate total non-transparent pixels
+      total_pixels = colors.values.sum
+      return nil if total_pixels == 0  # Empty cell
+
+      # Find colors exceeding dominance threshold
+      dominant_colors = colors.select do |color, count|
+        percentage = (count.to_f / total_pixels) * 100
+        percentage >= @config.threshold
+      end
+
+      # Return dominant colors or nil if none found
+      dominant_colors.empty? ? nil : dominant_colors.keys
+    end
+
+    def execute_command(cmd)
+      stdout, stderr, status = Open3.capture3(cmd)
+      raise ProcessingError, "Command failed: #{stderr}" unless status.success?
+      stdout
+    end
+
+    def create_temp_dir
+      Dir.mktmpdir('cell_cleanup')
+    end
+
+    def cleanup_temp_dir(temp_dir)
+      FileUtils.rm_rf(temp_dir) if temp_dir && Dir.exist?(temp_dir)
+    end
+
+    def extract_cell(spritesheet_path, row, col, cell_width, cell_height, temp_dir)
+      x_offset = col * cell_width
+      y_offset = row * cell_height
+      cell_path = File.join(temp_dir, "cell_#{row}_#{col}.png")
+
+      # Use ImageMagick crop: convert spritesheet.png -crop WxH+X+Y +repage cell.png
+      convert_cmd = Platform.imagemagick_convert_cmd
+      cmd = [
+        convert_cmd,
+        Utils::PathHelper.quote_path(spritesheet_path),
+        '-crop', "#{cell_width}x#{cell_height}+#{x_offset}+#{y_offset}",
+        '+repage',
+        Utils::PathHelper.quote_path(cell_path)
+      ].join(' ')
+
+      stdout, stderr, status = Open3.capture3(cmd)
+
+      unless status.success?
+        raise ProcessingError, "Failed to extract cell: #{stderr}"
+      end
+
+      cell_path
+    end
+
+    def remove_dominant_colors(cell_path, dominant_colors, options, temp_dir)
+      cleaned_path = cell_path.sub('.png', '_cleaned.png')
+
+      # Generate GIMP Python-fu script
+      script_content = CellCleanupGimpScript.generate_cleanup_script(
+        cell_path,
+        cleaned_path,
+        dominant_colors
+      )
+
+      # Execute GIMP script - pass script content and expected output file
+      success = @gimp_processor.execute_python_script(script_content, cleaned_path)
+
+      unless success
+        raise ProcessingError, "GIMP script failed to create output file: #{cleaned_path}"
+      end
+
+      # Validate output was created
+      Utils::FileHelper.validate_exists!(cleaned_path)
+
+      cleaned_path
+    end
+
+    def reassemble_spritesheet(cell_paths, columns, rows, output_path)
+      # Use ImageMagick montage to reassemble cells
+      quoted_paths = cell_paths.map { |p| Utils::PathHelper.quote_path(p) }.join(' ')
+
+      cmd = [
+        'magick', 'montage',
+        quoted_paths,
+        '-tile', "#{columns}x#{rows}",
+        '-geometry', '+0+0',  # No gaps/borders
+        '-background', 'none',
+        Utils::PathHelper.quote_path(output_path)
+      ].join(' ')
+
+      stdout, stderr, status = Open3.capture3(cmd)
+
+      unless status.success?
+        raise ProcessingError, "Failed to reassemble spritesheet: #{stderr}"
+      end
+
+      Utils::FileHelper.validate_exists!(output_path)
+    end
+  end
+end