ruby_spriter 0.6.7 → 0.6.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1cec402c211c4204134f1a9cf6974093c3e36fd46a45301282260454c91ff33d
-  data.tar.gz: 0de0714668911755bc80ac6f0841d4aa2034f03797dcf027ef6a61e495f46936
+  metadata.gz: 9b62fa9c591b35279199986edc2cf288249c74d80d3479eba177293c53b1dca1
+  data.tar.gz: 71603609b398ec1ac7d0caac7c7194ef0d5e09170a4841e6e3f2f2c0cec65ff7
 SHA512:
-  metadata.gz: 71bbe470ac06aaa1acadf00fba48b911daa6f803010a0e88145a46847078e2db3db25cdeb4462ada7a74e9711b7b36c4b706a36bbd9f04ff53af2087a1882434
-  data.tar.gz: f5f092588802ce4402fe952370f17ba76f59543cdd99b24e83f845e1ca2b2a5cc813481909180ac418d2f34f65dcb4ae5a828794e40abd3164a004ef6695235d
+  metadata.gz: 634d8516173fcb9461af2b457003e7661728e0dfbc7ac72904b0d771831e5bb730ccba867fd03fdae86acbde1e525300ad88a367c29c118b5dbb6002332a2e9f
+  data.tar.gz: 5330230b6690fd1aaed69f62bd31e901bb5119ed8fa0a2c07a8e3a6b164b190c230809688d5b5142a254bc231a0fd9ac556ed2a97230f807f061c5be5ba4175c

data/CHANGELOG.md

@@ -12,6 +12,125 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [0.6.7.1] - 2025-10-24
+
+### 🐧 Linux Support Enhancement Release
+
+#### Added
+- **Linux GIMP 3.x Support**: Full support for GIMP 3.x on Linux via Flatpak
+  - Automatic detection of Flatpak GIMP installation (`flatpak:org.gimp.GIMP`)
+  - Automatic Xvfb integration for completely headless GIMP operation
+  - Virtual display provided by Xvfb eliminates display connection requirement
+  - Flatpak socket isolation (`--nosocket=x11 --nosocket=wayland`) prevents GUI from appearing
+  - Python-fu batch mode works correctly with `python-fu-eval` interpreter
+  - Background removal, scaling, and all GIMP features fully functional
+  - Perfect for desktop use (no GUI distraction) and server environments (CI/CD, Docker, SSH)
+- **GIMP Version Detection**: Detect and report GIMP version (2.x or 3.x)
+  - `Platform.detect_gimp_version(version_output)` - Parse version from `--version` output
+  - `Platform.get_gimp_version(gimp_path)` - Get version from executable or Flatpak
+  - Works with both regular executables and Flatpak installations
+- **Xvfb Dependency Checking**: Added Xvfb to dependency checker (Linux only)
+  - Marked as required on Linux, optional on Windows/macOS
+  - Provides clear installation instructions if missing
+  - Validates availability before GIMP operations
+- **DependencyChecker Version Tracking**: Store and report detected GIMP version
+- **Xvfb Integration**: Transparent Xvfb usage when GIMP Flatpak detected
+  - Command format: `xvfb-run --auto-servernum --server-args='-screen 0 1024x768x24' flatpak run --nosocket=x11 --nosocket=wayland org.gimp.GIMP --no-splash --quit --batch-interpreter=python-fu-eval`
+  - No user configuration required - works automatically
+  - Completely headless - no GUI windows appear on screen
+
+#### Changed
+- **Platform Detection**: Enhanced to detect Flatpak GIMP alongside traditional installations
+- **GimpProcessor**: Updated to support both GIMP 2.x and 3.x APIs (version-aware)
+- **Unix GIMP Execution**: Automatically uses Xvfb with socket isolation for Flatpak installations
+- **Alternative GIMP Paths**: Added `flatpak:org.gimp.GIMP` to Linux search paths
+- **Warning Filters**: Enhanced to filter Xvfb, Wayland, and Flatpak cosmetic warnings
+- **DependencyChecker**: Now supports platform-specific optional dependencies
+
+#### Technical Details
+- **GIMP Flatpak Detection**: Uses `flatpak list --app | grep` to verify installation
+- **Version Parsing**: Regex-based parsing of `GIMP version X.Y.Z` output
+- **Python Interpreter**: Correct name is `python-fu-eval` (not `python-eval`)
+- **Xvfb Flags**:
+  - `--auto-servernum` - Automatically finds free display number
+  - `--server-args='-screen 0 1024x768x24'` - Configures virtual display
+- **Flatpak Socket Isolation**:
+  - `--nosocket=x11` - Prevents access to host X11 display socket
+  - `--nosocket=wayland` - Prevents access to host Wayland display socket
+  - Ensures GIMP runs only in Xvfb virtual display
+- **Platform Module**: New methods for version detection and Flatpak handling
+- **Warning Filtering**: Filters Gdk-WARNING, LibGimp-WARNING, Gimp-Core-WARNING, X11 socket messages
+
+#### Installation Requirements (Linux)
+```bash
+# Ubuntu/Debian
+sudo apt install flatpak xvfb -y
+flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
+flatpak install flathub org.gimp.GIMP -y
+
+# Fedora/RHEL
+sudo dnf install flatpak xorg-x11-server-Xvfb -y
+flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
+flatpak install flathub org.gimp.GIMP -y
+```
+
+#### Example Output
+```bash
+$ ruby_spriter --check-dependencies
+============================================================
+Dependency Check
+============================================================
+
+✅ FFMPEG
+   Found: 6.1.1
+
+✅ FFPROBE
+   Found: 6.1.1
+
+✅ IMAGEMAGICK
+   Found: Version: ImageMagick 6.9.12-98 Q16 x86_64
+
+✅ XVFB
+   Found: Usage: xvfb-run [OPTION ...] COMMAND
+
+✅ GIMP
+   Found: flatpak:org.gimp.GIMP
+   Version: GIMP 3.0.6
+
+============================================================
+
+$ ruby_spriter --image sprite.png --remove-bg
+============================================================
+GIMP Processing
+============================================================
+📝 Using GIMP via Xvfb (virtual display)
+      Removing background (fuzzy select)...
+      === GIMP Messages ===
+      Loading image...
+      Image size: 1280x748
+      Added alpha channel
+      Sampling 4 corners...
+      Using FUZZY SELECT (contiguous regions only)
+        Corner 1 at (0, 0)
+        Corner 2 at (1279, 0)
+        Corner 3 at (0, 747)
+        Corner 4 at (1279, 747)
+      Selection complete
+      Growing selection by 1 pixels...
+      Selection grown
+      Removing background...
+      Background removed
+      Deselecting...
+      Exporting...
+      SUCCESS - Background removed!
+      ====================
+✅ Background Removal complete (142.15 KB)
+```
+
+**Note**: No GIMP GUI window appears on screen - completely headless operation!
+
+---
+
 ## [0.6.7] - 2025-10-24
 
 ### 🚀 Batch Processing, Compression, Directory Consolidation & Frame Extraction Release

data/README.md

@@ -1,4 +1,4 @@
-# Ruby Spriter v0.6.7
+# Ruby Spriter v0.6.7.1
 
 [![Ruby](https://img.shields.io/badge/Ruby-2.7+-red.svg)](https://www.ruby-lang.org/)
 [![License](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
@@ -68,6 +68,7 @@ A powerful cross-platform Ruby tool for creating high-quality spritesheets from
 | **FFprobe** | Latest | Video analysis (included with FFmpeg) |
 | **ImageMagick** | 7.x+ | Metadata and sharpening |
 | **GIMP** | 3.x (or 2.10) | Scaling and background removal |
+| **Xvfb** | Latest (Linux only) | Virtual display for headless GIMP |
 
 ### Ruby Version
 - Ruby 2.7.0 or higher
@@ -90,6 +91,7 @@ Ruby Spriter requires these external tools for video and image processing:
 | **FFmpeg** | Video frame extraction | Any recent version |
 | **ImageMagick** | Image manipulation & metadata | 7.x or 6.9+ |
 | **GIMP** | Advanced image processing | 3.x (or 2.10) |
+| **Xvfb** | Virtual display (Linux only) | Any recent version |
 
 #### Installing Prerequisites
 
@@ -158,9 +160,19 @@ brew install ffmpeg imagemagick gimp
 sudo apt update && sudo apt install ruby-full -y
 
 # Install Ruby Spriter dependencies
-sudo apt install ffmpeg imagemagick gimp -y
+sudo apt install ffmpeg imagemagick -y
+
+# Install GIMP 3.x via Flatpak (recommended)
+sudo apt install flatpak -y
+flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
+flatpak install flathub org.gimp.GIMP -y
+
+# Install Xvfb for headless GIMP operation
+sudo apt install xvfb -y
 ```
 
+**Note for Linux Users**: GIMP 3.x requires a display connection. Ruby Spriter automatically uses Xvfb (X Virtual Framebuffer) with Flatpak socket isolation to provide a completely headless virtual display. No GIMP GUI windows will appear on your screen - perfect for both desktop use (no distractions) and server environments (CI/CD, Docker, SSH sessions).
+
 **Linux (Fedora/RHEL)**
 
 ```bash
@@ -168,7 +180,15 @@ sudo apt install ffmpeg imagemagick gimp -y
 sudo dnf install ruby -y
 
 # Install Ruby Spriter dependencies
-sudo dnf install ffmpeg imagemagick gimp -y
+sudo dnf install ffmpeg imagemagick -y
+
+# Install GIMP 3.x via Flatpak (recommended)
+sudo dnf install flatpak -y
+flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
+flatpak install flathub org.gimp.GIMP -y
+
+# Install Xvfb for headless GIMP operation
+sudo dnf install xorg-x11-server-Xvfb -y
 ```
 
 ---
@@ -685,6 +705,34 @@ ruby_spriter --video input.mp4 --scale 50 --sharpen --debug
 # - Processing timestamps
 ```
 
+### Headless Linux Operation (v0.6.7.1+)
+
+Ruby Spriter provides completely headless GIMP operation on Linux via Xvfb and Flatpak socket isolation:
+
+```bash
+# No GIMP GUI appears during processing
+ruby_spriter --image sprite.png --remove-bg --scale 50
+
+# Perfect for server environments
+ruby_spriter --batch --dir "sprites/" --remove-bg --max-compress
+```
+
+**How it Works:**
+- Automatically detects GIMP 3.x Flatpak installation
+- Uses Xvfb (X Virtual Framebuffer) to provide virtual display
+- Flatpak socket isolation (`--nosocket=x11 --nosocket=wayland`) prevents GUI from appearing
+- No configuration required - works automatically
+
+**Use Cases:**
+- **Desktop**: No GUI distractions during batch processing
+- **Server**: Headless automation on Ubuntu Server, CI/CD pipelines
+- **Docker**: Run in containers without display server
+- **SSH**: Process sprites remotely without X forwarding
+
+**Requirements:**
+- GIMP 3.x via Flatpak (`flatpak install flathub org.gimp.GIMP`)
+- Xvfb (`sudo apt install xvfb` on Ubuntu/Debian)
+
 ---
 
 ## 🏗️ Architecture

data/lib/ruby_spriter/batch_processor.rb

@@ -152,16 +152,18 @@ module RubySpriter
     end
 
     def process_with_gimp(input_file, video_result)
-      # Get GIMP path from dependency checker
+      # 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_processor = GimpProcessor.new(gimp_path, options)
+      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

data/lib/ruby_spriter/cli.rb

@@ -210,7 +210,7 @@ module RubySpriter
         options[:remove_bg] = true
       end
 
-      opts.on("-t", "--threshold VALUE", Float, "Feather radius (default: 0.0 = no feathering)") do |t|
+      opts.on("-t", "--threshold VALUE", Float, "Background color tolerance % (default: 15.0, range: 0-100)") do |t|
         options[:bg_threshold] = t
       end
 

data/lib/ruby_spriter/dependency_checker.rb

@@ -32,12 +32,23 @@ module RubySpriter
           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
@@ -58,7 +69,7 @@ module RubySpriter
     # @return [Boolean] true if all dependencies are available
     def all_satisfied?
       results = check_all
-      results.all? { |_tool, status| status[:available] }
+      results.all? { |tool, status| status[:available] || status[:optional] }
     end
 
     # Print dependency status report
@@ -70,14 +81,31 @@ module RubySpriter
       puts "=" * 60
       
       results.each do |tool, status|
-        icon = status[:available] ? "✅" : "❌"
-        puts "\n#{icon} #{tool.to_s.upcase}"
-        
+        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]
-          puts "   Found: #{status[:path] || status[:version]}"
+          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
-          puts "   Status: NOT FOUND"
-          puts "   Install: #{status[:install_cmd]}"
+          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
       
@@ -87,9 +115,16 @@ module RubySpriter
     # 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
 
@@ -98,13 +133,15 @@ module RubySpriter
         {
           available: true,
           version: version,
-          install_cmd: nil
+          install_cmd: nil,
+          optional: is_optional
         }
       else
         {
           available: false,
           version: nil,
-          install_cmd: config[:install][Platform.current]
+          install_cmd: config[:install][Platform.current],
+          optional: is_optional
         }
       end
     rescue StandardError => e
@@ -112,7 +149,8 @@ module RubySpriter
       {
         available: false,
         version: nil,
-        install_cmd: config[:install][Platform.current]
+        install_cmd: config[:install][Platform.current],
+        optional: is_optional
       }
     end
 
@@ -121,32 +159,44 @@ module RubySpriter
       default_path = Platform.default_gimp_path
       if gimp_exists?(default_path)
         @gimp_path = default_path
-        return gimp_status(true, 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
-          return gimp_status(true, path)
+          @gimp_version = Platform.get_gimp_version(path)
+          return gimp_status(true, path, @gimp_version)
         end
       end
 
       # Not found
-      gimp_status(false, nil)
+      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)
-      {
+    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

data/lib/ruby_spriter/gimp_processor.rb

@@ -6,11 +6,12 @@ require 'tmpdir'
 module RubySpriter
   # Processes images with GIMP
   class GimpProcessor
-    attr_reader :options, :gimp_path
+    attr_reader :options, :gimp_path, :gimp_version
 
     def initialize(gimp_path, options = {})
       @gimp_path = gimp_path
       @options = options
+      @gimp_version = options[:gimp_version] || { major: 3, minor: 0 }  # Default to GIMP 3
     end
 
     # Process image with GIMP operations
@@ -21,6 +22,11 @@ module RubySpriter
 
       Utils::OutputFormatter.header("GIMP Processing")
 
+      # Inform about Xvfb usage on Linux
+      if Platform.linux? && gimp_path.start_with?('flatpak:')
+        Utils::OutputFormatter.note("Using GIMP via Xvfb (virtual display)")
+      end
+
       # Inform user if automatic operation order optimization is applied
       if options[:scale_percent] && options[:remove_bg] &&
          options[:operation_order] == :scale_then_remove_bg
@@ -45,6 +51,18 @@ module RubySpriter
 
     private
 
+    def gimp_major_version
+      @gimp_version[:major]
+    end
+
+    def gimp2?
+      gimp_major_version == 2
+    end
+
+    def gimp3?
+      gimp_major_version == 3
+    end
+
     def determine_operations
       ops = []
 
@@ -101,6 +119,14 @@ module RubySpriter
     end
 
     def generate_scale_script(input_file, output_file, percent)
+      if gimp2?
+        generate_scale_script_gimp2(input_file, output_file, percent)
+      else
+        generate_scale_script_gimp3(input_file, output_file, percent)
+      end
+    end
+
+    def generate_scale_script_gimp3(input_file, output_file, percent)
       input_path = Utils::PathHelper.normalize_for_python(input_file)
       output_path = Utils::PathHelper.normalize_for_python(output_file)
       interpolation = map_interpolation_method(options[:scale_interpolation] || 'nohalo')
@@ -216,7 +242,75 @@ module RubySpriter
       PYTHON
     end
 
+    def generate_scale_script_gimp2(input_file, output_file, percent)
+      input_path = Utils::PathHelper.normalize_for_python(input_file)
+      output_path = Utils::PathHelper.normalize_for_python(output_file)
+      interpolation = map_interpolation_method_gimp2(options[:scale_interpolation] || 'nohalo')
+
+      <<~PYTHON
+        from gimpfu import *
+        import sys
+
+        def scale_image():
+            try:
+                print "Loading image..."
+                img = pdb.gimp_file_load(r'#{input_path}', r'#{input_path}')
+
+                w = img.width
+                h = img.height
+                print "Image size: %dx%d" % (w, h)
+
+                if len(img.layers) == 0:
+                    raise Exception("No layers found")
+                layer = img.layers[0]
+
+                # Calculate new dimensions
+                new_width = int(w * #{percent} / 100.0)
+                new_height = int(h * #{percent} / 100.0)
+                print "Scaling to: %dx%d" % (new_width, new_height)
+                print "Interpolation: #{interpolation}"
+
+                # Scale layer with interpolation
+                pdb.gimp_layer_scale(layer, new_width, new_height, False, #{interpolation})
+                print "Layer scaled with interpolation"
+
+                # Resize canvas to match layer
+                pdb.gimp_image_resize(img, new_width, new_height, 0, 0)
+                print "Canvas resized"
+
+                # Handle multiple layers while preserving alpha
+                if len(img.layers) > 1:
+                    pdb.gimp_image_merge_visible_layers(img, EXPAND_AS_NECESSARY)
+                    print "Multiple layers merged (alpha preserved)"
+                else:
+                    print "Single layer - no merge needed, alpha preserved"
+
+                # Export with alpha channel intact
+                print "Exporting with alpha channel..."
+                pdb.file_png_save(img, img.layers[0], r'#{output_path}', r'#{output_path}',
+                                  0, 9, 0, 0, 0, 0, 0)
+
+                print "SUCCESS - Image scaled!"
+
+            except Exception as e:
+                print "ERROR: %s" % str(e)
+                import traceback
+                traceback.print_exc()
+                sys.exit(1)
+
+        scale_image()
+      PYTHON
+    end
+
     def generate_remove_bg_script(input_file, output_file)
+      if gimp2?
+        generate_remove_bg_script_gimp2(input_file, output_file)
+      else
+        generate_remove_bg_script_gimp3(input_file, output_file)
+      end
+    end
+
+    def generate_remove_bg_script_gimp3(input_file, output_file)
       input_path = Utils::PathHelper.normalize_for_python(input_file)
       output_path = Utils::PathHelper.normalize_for_python(output_file)
 
@@ -328,6 +422,98 @@ module RubySpriter
       PYTHON
     end
 
+    def generate_remove_bg_script_gimp2(input_file, output_file)
+      input_path = Utils::PathHelper.normalize_for_python(input_file)
+      output_path = Utils::PathHelper.normalize_for_python(output_file)
+
+      use_fuzzy = options[:fuzzy_select]
+      grow = options[:grow_selection] || 1
+      feather = options[:bg_threshold] || 0.0
+
+      # Build selection method
+      if use_fuzzy
+        select_method = "CHANNEL_OP_REPLACE" # First corner
+        select_add = "CHANNEL_OP_ADD"        # Additional corners
+        select_call = "pdb.gimp_image_select_contiguous_color(img, select_op, layer, x, y)"
+      else
+        select_method = "CHANNEL_OP_REPLACE"
+        select_add = "CHANNEL_OP_ADD"
+        select_call = "pdb.gimp_image_select_color(img, select_op, layer, color)"
+      end
+
+      <<~PYTHON
+        from gimpfu import *
+        import sys
+
+        def remove_background():
+            try:
+                print "Loading image..."
+                img = pdb.gimp_file_load(r'#{input_path}', r'#{input_path}')
+
+                w = img.width
+                h = img.height
+                print "Image size: %dx%d" % (w, h)
+
+                if len(img.layers) == 0:
+                    raise Exception("No layers found")
+                layer = img.layers[0]
+
+                # Add alpha channel if needed
+                if not pdb.gimp_layer_has_alpha(layer):
+                    pdb.gimp_layer_add_alpha(layer)
+                    print "Added alpha channel"
+
+                # Sample all four corners
+                corners = [
+                    (0, 0),           # Top-left
+                    (w-1, 0),         # Top-right
+                    (0, h-1),         # Bottom-left
+                    (w-1, h-1)        # Bottom-right
+                ]
+
+                print "Sampling %d corners..." % len(corners)
+                #{"print \"Using FUZZY SELECT (contiguous regions only)\"" if use_fuzzy}
+                #{"print \"Using GLOBAL COLOR SELECT (all matching pixels)\"" unless use_fuzzy}
+
+                for i, (x, y) in enumerate(corners):
+                    print "  Corner %d at (%d, %d)" % (i+1, x, y)
+                    select_op = CHANNEL_OP_REPLACE if i == 0 else CHANNEL_OP_ADD
+                    #{use_fuzzy ? "pdb.gimp_image_select_contiguous_color(img, select_op, layer, x, y)" : "color = pdb.gimp_image_get_pixel_color(img, layer, x, y)[1]\n                    pdb.gimp_image_select_color(img, select_op, layer, color)"}
+
+                print "Selection complete"
+
+                # Grow selection if configured
+                #{grow > 0 ? "print \"Growing selection by #{grow} pixels...\"\n                pdb.gimp_selection_grow(img, #{grow})\n                print \"Selection grown\"" : "# No selection growth"}
+
+                # Feather selection if configured
+                #{feather > 0 ? "print \"Feathering selection by #{feather} pixels...\"\n                pdb.gimp_selection_feather(img, #{feather})\n                print \"Selection feathered\"" : "# No feathering"}
+
+                # Delete selection (clear background)
+                print "Removing background..."
+                pdb.gimp_edit_clear(layer)
+                print "Background removed"
+
+                # Deselect
+                print "Deselecting..."
+                pdb.gimp_selection_none(img)
+
+                # Export
+                print "Exporting..."
+                pdb.file_png_save(img, layer, r'#{output_path}', r'#{output_path}',
+                                  0, 9, 0, 0, 0, 0, 0)
+
+                print "SUCCESS - Background removed!"
+
+            except Exception as e:
+                print "ERROR: %s" % str(e)
+                import traceback
+                traceback.print_exc()
+                sys.exit(1)
+
+        remove_background()
+      PYTHON
+    end
+
     def generate_fuzzy_select_code
       <<~PYTHON.chomp
         # Fuzzy select (contiguous regions only)
@@ -468,7 +654,7 @@ module RubySpriter
         @echo off
         REM Suppress GEGL debug output (known GIMP 3.x batch mode issue)
         set GEGL_DEBUG=
-        "#{gimp_path}" --quit --batch-interpreter=python-fu-eval -b "exec(open(r'#{script_file}').read())" > "#{log_file}" 2>&1
+        "#{gimp_path}" --no-splash --quit --batch-interpreter=python-fu-eval -b "exec(open(r'#{script_file}').read())" > "#{log_file}" 2>&1
         exit /b %errorlevel%
       BATCH
 
@@ -502,7 +688,25 @@ module RubySpriter
 
     # Unix execution (Linux/macOS)
     def execute_gimp_unix(script_file, log_file)
-      cmd = "#{Utils::PathHelper.quote_path(gimp_path)} --quit --batch-interpreter=python-fu-eval -b \"exec(open(r'#{script_file}').read())\" > #{Utils::PathHelper.quote_path(log_file)} 2>&1"
+      # Check if we're using Flatpak GIMP (needs xvfb-run)
+      use_xvfb = gimp_path.start_with?('flatpak:')
+
+      if gimp2?
+        # GIMP 2.x: Use gimp-console for batch processing
+        gimp_console_path = gimp_path.sub('/gimp', '/gimp-console')
+        cmd = "#{Utils::PathHelper.quote_path(gimp_console_path)} -i --no-splash --batch-interpreter python-fu-eval -b 'exec(open(\"#{script_file}\").read())' -b '(gimp-quit 0)' > #{Utils::PathHelper.quote_path(log_file)} 2>&1"
+      else
+        # GIMP 3.x command
+        if use_xvfb
+          # Flatpak GIMP needs xvfb-run to provide virtual display
+          # Use --nosocket options to prevent Flatpak from accessing host display
+          flatpak_app = gimp_path.sub('flatpak:', '')
+          cmd = "xvfb-run --auto-servernum --server-args='-screen 0 1024x768x24' flatpak run --nosocket=x11 --nosocket=wayland #{flatpak_app} --no-splash --quit --batch-interpreter=python-fu-eval -b \"exec(open(r'#{script_file}').read())\" > #{Utils::PathHelper.quote_path(log_file)} 2>&1"
+        else
+          # Regular GIMP 3.x installation
+          cmd = "#{Utils::PathHelper.quote_path(gimp_path)} --no-splash --quit --batch-interpreter=python-fu-eval -b \"exec(open(r'#{script_file}').read())\" > #{Utils::PathHelper.quote_path(log_file)} 2>&1"
+        end
+      end
 
       if options[:debug]
         Utils::OutputFormatter.indent("DEBUG: GIMP command: #{cmd}")
@@ -532,6 +736,16 @@ module RubySpriter
         line.match?(/GeglBuffers leaked/) ||
         line.match?(/EEEEeEeek!/) ||
         line.match?(/batch command executed successfully/) ||
+        # Filter Linux/Wayland/Flatpak cosmetic warnings
+        line.match?(/Gdk-WARNING.*Failed to read portal settings/) ||
+        line.match?(/set device.*to mode: disabled/) ||
+        line.match?(/Gdk-WARNING.*Server is missing xdg_foreign support/) ||
+        line.match?(/gimp_widget_set_handle_on_mapped.*gdk_wayland_window_export_handle/) ||
+        line.match?(/It will not be possible to set windows in other processes/) ||
+        line.match?(/LibGimp-WARNING.*gimp_flush.*Broken pipe/) ||
+        line.match?(/Gimp-Core-WARNING.*gimp_finalize.*list of contexts not empty/) ||
+        line.match?(/stale context:/) ||
+        line.match?(/F: X11 socket.*does not exist in filesystem/) ||
         line.strip.empty?
       end
       lines.join
@@ -598,7 +812,7 @@ module RubySpriter
       end
     end
 
-    # Map interpolation method names to GIMP interpolation type enum values
+    # Map interpolation method names to GIMP 3.x interpolation type enum values
     def map_interpolation_method(method)
       # GIMP 3.x GimpInterpolationType enum values
       case method.to_s.downcase
@@ -617,6 +831,183 @@ module RubySpriter
       end
     end
 
+    # Map interpolation method names to GIMP 2.x interpolation type constants
+    def map_interpolation_method_gimp2(method)
+      # GIMP 2.x interpolation constants
+      case method.to_s.downcase
+      when 'none'
+        'INTERPOLATION_NONE'
+      when 'linear'
+        'INTERPOLATION_LINEAR'
+      when 'cubic'
+        'INTERPOLATION_CUBIC'
+      when 'nohalo'
+        'INTERPOLATION_NOHALO'
+      when 'lohalo'
+        'INTERPOLATION_LOHALO'
+      else
+        'INTERPOLATION_NOHALO'  # Default to NoHalo for quality
+      end
+    end
+
+    # Remove background using ImageMagick (fallback for Linux)
+    # Uses edge detection and multiple techniques for better results
+    def remove_background_imagemagick(input_file, output_file)
+      magick_cmd = Platform.imagemagick_convert_cmd
+      identify_cmd = Platform.imagemagick_identify_cmd
+
+      # Get options
+      use_fuzzy = options[:fuzzy_select]
+      fuzz_percent = options[:bg_threshold] || 15.0
+      grow = options[:grow_selection] || 1
+
+      # Get image dimensions
+      stdout, _stderr, status = Open3.capture3("#{identify_cmd} -format '%w %h' #{Utils::PathHelper.quote_path(input_file)}")
+      unless status.success?
+        raise ProcessingError, "Could not get image dimensions"
+      end
+      width, height = stdout.strip.split.map(&:to_i)
+
+      # Sample more points around the border (not just corners)
+      sample_points = [
+        # Corners
+        [0, 0], [width - 1, 0], [0, height - 1], [width - 1, height - 1],
+        # Mid-edges
+        [width / 2, 0], [width / 2, height - 1],
+        [0, height / 2], [width - 1, height / 2]
+      ]
+
+      # Get colors from all sample points
+      sampled_colors = []
+      sample_points.each do |x, y|
+        color_stdout, _stderr, status = Open3.capture3("#{identify_cmd} -format '%[pixel:p{#{x},#{y}}]' #{Utils::PathHelper.quote_path(input_file)}")
+        sampled_colors << color_stdout.strip if status.success? && !color_stdout.strip.empty?
+      end
+
+      # Find the most common color (likely the background)
+      bg_color = sampled_colors.group_by(&:itself).max_by { |_, v| v.size }.first
+
+      if options[:debug]
+        Utils::OutputFormatter.indent("DEBUG: Image size: #{width}x#{height}")
+        Utils::OutputFormatter.indent("DEBUG: Sampled #{sampled_colors.size} border colors")
+        Utils::OutputFormatter.indent("DEBUG: Unique colors: #{sampled_colors.uniq.size}")
+        Utils::OutputFormatter.indent("DEBUG: Using background color: #{bg_color}")
+        Utils::OutputFormatter.indent("DEBUG: Fuzz: #{fuzz_percent}%")
+      end
+
+      # Create a multi-pass approach for better results
+      # Pass 1: Use floodfill from edges with fuzz tolerance
+      temp_file1 = File.join(Dir.tmpdir, "bg_removal_pass1_#{Time.now.to_i}.png")
+
+      draw_commands = sample_points.map { |x, y| "'color #{x},#{y} floodfill'" }.join(' -draw ')
+
+      cmd1 = "#{magick_cmd} #{Utils::PathHelper.quote_path(input_file)} -alpha set -fuzz #{fuzz_percent}% -fill none -draw #{draw_commands} #{temp_file1}"
+
+      if options[:debug]
+        Utils::OutputFormatter.indent("DEBUG: Pass 1 - Floodfill from #{sample_points.size} points")
+      end
+
+      stdout, stderr, status = Open3.capture3(cmd1)
+      unless status.success?
+        File.delete(temp_file1) if File.exist?(temp_file1)
+        raise ProcessingError, "Background removal pass 1 failed: #{stderr}"
+      end
+
+      # Pass 2: Remove the detected background color globally with fuzz
+      temp_file2 = File.join(Dir.tmpdir, "bg_removal_pass2_#{Time.now.to_i}.png")
+
+      cmd2 = "#{magick_cmd} #{temp_file1} -fuzz #{fuzz_percent}% -transparent '#{bg_color}' #{temp_file2}"
+
+      if options[:debug]
+        Utils::OutputFormatter.indent("DEBUG: Pass 2 - Remove color #{bg_color} globally")
+      end
+
+      stdout, stderr, status = Open3.capture3(cmd2)
+      unless status.success?
+        File.delete(temp_file1) if File.exist?(temp_file1)
+        File.delete(temp_file2) if File.exist?(temp_file2)
+        raise ProcessingError, "Background removal pass 2 failed: #{stderr}"
+      end
+
+      # Pass 3: Minimal cleanup - preserve quality
+      cmd3_parts = [
+        magick_cmd,
+        temp_file2
+      ]
+
+      # Only clean up the alpha channel, don't touch the RGB data
+      # This preserves sprite quality while cleaning edges
+      cmd3_parts += [
+        '-channel', 'A',
+        # Very gentle cleanup - only remove nearly-transparent pixels
+        '-threshold', '5%',  # Anything less than 5% alpha becomes fully transparent
+        '+channel'
+      ]
+
+      # Optionally grow the transparent areas
+      if grow > 0
+        cmd3_parts += ['-morphology', 'Dilate', "Disk:#{grow}"]
+      end
+
+      cmd3_parts << Utils::PathHelper.quote_path(output_file)
+      cmd3 = cmd3_parts.join(' ')
+
+      if options[:debug]
+        Utils::OutputFormatter.indent("DEBUG: Pass 3 - Minimal alpha cleanup (quality-preserving)")
+      end
+
+      stdout, stderr, status = Open3.capture3(cmd3)
+
+      # Cleanup temp files
+      File.delete(temp_file1) if File.exist?(temp_file1)
+      File.delete(temp_file2) if File.exist?(temp_file2)
+
+      unless status.success?
+        raise ProcessingError, "Background removal pass 3 failed: #{stderr}"
+      end
+
+      Utils::FileHelper.validate_exists!(output_file)
+      size = Utils::FileHelper.format_size(File.size(output_file))
+      Utils::OutputFormatter.success("Background removal complete (#{size})\n")
+    end
+
+    # Scale image using ImageMagick (fallback for GIMP 2.x)
+    def scale_with_imagemagick(input_file, output_file, percent)
+      magick_cmd = Platform.imagemagick_convert_cmd
+
+      # Map interpolation to ImageMagick filters
+      interpolation = options[:scale_interpolation] || 'nohalo'
+      filter = case interpolation.to_s.downcase
+               when 'none' then 'Point'
+               when 'linear' then 'Triangle'
+               when 'cubic' then 'Catrom'
+               when 'nohalo', 'lohalo' then 'Lanczos'  # Best available quality
+               else 'Lanczos'
+               end
+
+      cmd = [
+        magick_cmd,
+        Utils::PathHelper.quote_path(input_file),
+        '-filter', filter,
+        '-resize', "#{percent}%",
+        Utils::PathHelper.quote_path(output_file)
+      ].join(' ')
+
+      if options[:debug]
+        Utils::OutputFormatter.indent("DEBUG: ImageMagick command: #{cmd}")
+      end
+
+      stdout, stderr, status = Open3.capture3(cmd)
+
+      unless status.success?
+        raise ProcessingError, "ImageMagick scaling failed: #{stderr}"
+      end
+
+      Utils::FileHelper.validate_exists!(output_file)
+      size = Utils::FileHelper.format_size(File.size(output_file))
+      Utils::OutputFormatter.success("Scale complete (#{size})\n")
+    end
+
     # Apply unsharp mask using ImageMagick
     def apply_sharpen_imagemagick(input_file)
       radius = options[:sharpen_radius] || 2.0

data/lib/ruby_spriter/platform.rb

@@ -29,10 +29,13 @@ module RubySpriter
         '/usr/bin/gimp',
         '/usr/local/bin/gimp',
         '/snap/bin/gimp',
-        '/opt/gimp/bin/gimp'
+        '/opt/gimp/bin/gimp',
+        'flatpak:org.gimp.GIMP'  # Flatpak GIMP
       ].freeze,
       macos: [
         '/Applications/GIMP.app/Contents/MacOS/gimp',
+        '/Applications/GIMP-2.99.app/Contents/MacOS/gimp',  # GIMP 3.x dev
+        '/Applications/GIMP-3.0.app/Contents/MacOS/gimp',   # GIMP 3.x release
         '/Applications/GIMP-2.10.app/Contents/MacOS/gimp'
       ].freeze
     }.freeze
@@ -77,6 +80,58 @@ module RubySpriter
       def imagemagick_identify_cmd
         windows? ? 'magick identify' : 'identify'
       end
+
+      # Detect GIMP version from version string output
+      # @param version_output [String] Output from gimp --version command
+      # @return [Hash] Version information with :major, :minor, :patch, :full keys, or nil if parse fails
+      def detect_gimp_version(version_output)
+        return nil if version_output.nil? || version_output.empty?
+
+        # Match version pattern: "version X.Y.Z" or "version X.Y"
+        match = version_output.match(/version\s+(\d+)\.(\d+)(?:\.(\d+))?/i)
+        return nil unless match
+
+        {
+          major: match[1].to_i,
+          minor: match[2].to_i,
+          patch: match[3]&.to_i || 0,
+          full: match[1..3].compact.join('.')
+        }
+      end
+
+      # Get GIMP version from executable path
+      # @param gimp_path [String] Path to GIMP executable or flatpak:app.id
+      # @return [Hash] Version information, or nil if detection fails
+      def get_gimp_version(gimp_path)
+        return nil if gimp_path.nil? || gimp_path.empty?
+
+        require 'open3'
+
+        # Handle Flatpak GIMP
+        if gimp_path.start_with?('flatpak:')
+          flatpak_app = gimp_path.sub('flatpak:', '')
+          stdout, stderr, status = Open3.capture3("flatpak run #{flatpak_app} --version")
+          return nil unless status.success?
+          return detect_gimp_version(stdout + stderr)
+        end
+
+        return nil unless File.exist?(gimp_path)
+
+        stdout, stderr, status = Open3.capture3("#{quote_path_simple(gimp_path)} --version")
+        return nil unless status.success?
+
+        detect_gimp_version(stdout + stderr)
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      # Simple path quoting helper for Platform module
+      def quote_path_simple(path)
+        return path unless path.include?(' ')
+        windows? ? "\"#{path}\"" : "'#{path}'"
+      end
     end
   end
 end

data/lib/ruby_spriter/processor.rb

@@ -25,6 +25,7 @@ module RubySpriter
     def initialize(options = {})
       @options = default_options.merge(options)
       @gimp_path = nil
+      @gimp_version = nil
       validate_numeric_options!
       validate_split_option!
       validate_extract_option!
@@ -340,7 +341,10 @@ module RubySpriter
         raise DependencyError, "Missing required dependencies: #{missing.join(', ')}"
       end
 
-      @gimp_path = checker.gimp_path if results[:gimp][:available]
+      if results[:gimp][:available]
+        @gimp_path = checker.gimp_path
+        @gimp_version = checker.gimp_version
+      end
 
       if options[:debug]
         checker.print_report
@@ -703,7 +707,8 @@ module RubySpriter
     end
 
     def process_with_gimp(input_file)
-      gimp_processor = GimpProcessor.new(@gimp_path, options)
+      gimp_options = options.merge(gimp_version: @gimp_version)
+      gimp_processor = GimpProcessor.new(@gimp_path, gimp_options)
       gimp_processor.process(input_file)
     end
 

data/lib/ruby_spriter/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module RubySpriter
-  VERSION = '0.6.7'
+  VERSION = '0.6.7.1'
   VERSION_DATE = '2025-10-24'
   METADATA_VERSION = '0.6'
 end

data/spec/ruby_spriter/platform_spec.rb

@@ -71,7 +71,7 @@ RSpec.describe RubySpriter::Platform do
   describe '.imagemagick_identify_cmd' do
     it 'returns appropriate command for platform' do
       cmd = described_class.imagemagick_identify_cmd
-      
+
       if described_class.windows?
         expect(cmd).to eq('magick identify')
       else
@@ -79,4 +79,14 @@ RSpec.describe RubySpriter::Platform do
       end
     end
   end
+
+  describe '.detect_gimp_version' do
+    it 'detects GIMP 3.x version from command output' do
+      gimp3_output = "GNU Image Manipulation Program version 3.0.0"
+      version = described_class.detect_gimp_version(gimp3_output)
+      expect(version[:major]).to eq(3)
+      expect(version[:minor]).to eq(0)
+      expect(version[:full]).to eq('3.0.0')
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_spriter
 version: !ruby/object:Gem::Version
-  version: 0.6.7
+  version: 0.6.7.1
 platform: ruby
 authors:
 - scooter-indie
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-10-24 00:00:00.000000000 Z
+date: 2025-10-25 00:00:00.000000000 Z
 dependencies: []
 description: |
   Ruby Spriter is a cross-platform tool for creating spritesheets from video files