ruby_spriter 0.6.7.1 → 0.7.0.1

data/spec/unit/smoke_detector_spec.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe RubySpriter::SmokeDetector do
+  let(:config) do
+    double('InnerBgConfig',
+           remove_smoke: false)
+  end
+
+  let(:input_image) { 'spec/fixtures/test_sprite.png' }
+  let(:output_image) { 'spec/tmp/smoke_processed.png' }
+
+  before do
+    FileUtils.mkdir_p('spec/tmp')
+  end
+
+  after do
+    FileUtils.rm_f(output_image) if File.exist?(output_image)
+  end
+
+  describe '#initialize' do
+    it 'accepts input image, output image, and config' do
+      detector = described_class.new(input_image, output_image, config)
+      expect(detector).to be_a(RubySpriter::SmokeDetector)
+    end
+  end
+
+  describe '#detect' do
+    subject { described_class.new(input_image, output_image, config) }
+
+    it 'identifies smoke-like transparency gradients' do
+      smoke_regions = subject.detect
+
+      expect(smoke_regions).to be_an(Array)
+      # May or may not find smoke depending on fixture
+    end
+
+    it 'detects pixels with alpha between 20-80%' do
+      smoke_regions = subject.detect
+
+      # Each region should have alpha characteristics
+      smoke_regions.each do |region|
+        expect(region).to have_key(:alpha_range)
+        expect(region).to have_key(:area)
+      end
+    end
+
+    it 'filters regions by minimum area (50 pixels)' do
+      smoke_regions = subject.detect
+
+      smoke_regions.each do |region|
+        expect(region[:area]).to be >= 50
+      end
+    end
+  end
+
+  describe '#process' do
+    context 'when remove_smoke is false' do
+      subject { described_class.new(input_image, output_image, config) }
+
+      it 'detects but does not remove smoke effects' do
+        subject.process
+        report = subject.report
+
+        expect(report[:smoke_detected]).to be_a(Integer)
+        expect(report[:smoke_removed]).to eq(false)
+      end
+
+      it 'copies input to output unchanged' do
+        subject.process
+
+        expect(File.exist?(output_image)).to be true
+
+        # Files should be identical
+        expect(FileUtils.compare_file(input_image, output_image)).to be true
+      end
+    end
+
+    context 'when remove_smoke is true' do
+      let(:config) do
+        double('InnerBgConfig',
+               remove_smoke: true)
+      end
+
+      subject { described_class.new(input_image, output_image, config) }
+
+      it 'detects and removes smoke effects' do
+        subject.process
+        report = subject.report
+
+        expect(report[:smoke_detected]).to be_a(Integer)
+        expect(report[:smoke_removed]).to eq(true)
+      end
+
+      it 'creates an output image file' do
+        subject.process
+        expect(File.exist?(output_image)).to be true
+      end
+
+      it 'removes semi-transparent gradient regions' do
+        subject.process
+
+        # Output should exist and be valid
+        expect(File.exist?(output_image)).to be true
+
+        # Check file size is reasonable
+        file_size = File.size(output_image)
+        expect(file_size).to be > 100
+      end
+    end
+  end
+
+  describe '#remove_smoke_regions' do
+    let(:config) do
+      double('InnerBgConfig',
+             remove_smoke: true)
+    end
+
+    subject { described_class.new(input_image, output_image, config) }
+
+    it 'removes detected smoke regions' do
+      smoke_regions = [
+        { x: 50, y: 50, area: 100, alpha_range: [0.2, 0.8] }
+      ]
+
+      FileUtils.cp(input_image, output_image)
+      result = subject.remove_smoke_regions(smoke_regions)
+
+      expect(result).to be true
+    end
+  end
+
+  describe '#is_smoke_like?' do
+    subject { described_class.new(input_image, output_image, config) }
+
+    it 'returns true for alpha values between 20-80%' do
+      expect(subject.is_smoke_like?(0.5)).to be true
+      expect(subject.is_smoke_like?(0.3)).to be true
+      expect(subject.is_smoke_like?(0.7)).to be true
+    end
+
+    it 'returns false for fully transparent pixels' do
+      expect(subject.is_smoke_like?(0.0)).to be false
+      expect(subject.is_smoke_like?(0.1)).to be false
+    end
+
+    it 'returns false for fully opaque pixels' do
+      expect(subject.is_smoke_like?(1.0)).to be false
+      expect(subject.is_smoke_like?(0.9)).to be false
+    end
+  end
+
+  describe '#report' do
+    subject { described_class.new(input_image, output_image, config) }
+
+    it 'generates a detection report' do
+      subject.process
+      report = subject.report
+
+      expect(report).to be_a(Hash)
+      expect(report).to have_key(:smoke_detected)
+      expect(report).to have_key(:smoke_removed)
+      expect(report).to have_key(:smoke_regions)
+      expect(report).to have_key(:processing_time)
+    end
+
+    it 'includes region details when smoke is detected' do
+      subject.process
+      report = subject.report
+
+      expect(report[:smoke_regions]).to be_an(Array)
+    end
+  end
+
+  describe 'alpha range detection' do
+    subject { described_class.new(input_image, output_image, config) }
+
+    it 'identifies the alpha range of detected regions' do
+      smoke_regions = subject.detect
+
+      smoke_regions.each do |region|
+        alpha_range = region[:alpha_range]
+        expect(alpha_range).to be_an(Array)
+        expect(alpha_range.length).to eq(2)
+        expect(alpha_range[0]).to be >= 0.2
+        expect(alpha_range[1]).to be <= 0.8
+      end
+    end
+  end
+
+  describe 'minimum area threshold' do
+    subject { described_class.new(input_image, output_image, config) }
+
+    it 'uses 50 pixels as minimum area' do
+      smoke_regions = subject.detect
+
+      # All detected regions should meet minimum
+      smoke_regions.each do |region|
+        expect(region[:area]).to be >= 50
+      end
+    end
+  end
+
+  describe 'performance' do
+    subject { described_class.new(input_image, output_image, config) }
+
+    it 'completes detection in reasonable time' do
+      start_time = Time.now
+      subject.detect
+      elapsed = Time.now - start_time
+
+      # Should complete in under 15 seconds for small test image
+      expect(elapsed).to be < 15
+    end
+  end
+
+  describe 'integration scenarios' do
+    context 'with image containing no smoke effects' do
+      let(:input_image) { 'spec/fixtures/test_sprite.png' }
+
+      subject { described_class.new(input_image, output_image, config) }
+
+      it 'reports zero smoke regions detected' do
+        subject.process
+        report = subject.report
+
+        expect(report[:smoke_detected]).to eq(0)
+      end
+    end
+
+    context 'with grayscale image' do
+      let(:input_image) { 'spec/fixtures/test_sprite.png' }
+
+      subject { described_class.new(input_image, output_image, config) }
+
+      it 'handles grayscale images correctly' do
+        subject.process
+        report = subject.report
+
+        # Should complete without errors
+        expect(report[:smoke_detected]).to be >= 0
+      end
+    end
+  end
+end

data/spec/unit/threshold_stepper_spec.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'ruby_spriter/threshold_stepper'
+require 'ruby_spriter/gimp_processor'
+require 'tempfile'
+
+RSpec.describe RubySpriter::ThresholdStepper do
+  let(:input_file) { Tempfile.new(['input', '.png']) }
+  let(:output_file) { Tempfile.new(['output', '.png']) }
+  let(:background_palette) do
+    [
+      { r: 255, g: 255, b: 255 },
+      { r: 250, g: 250, b: 250 },
+      { r: 245, g: 245, b: 245 }
+    ]
+  end
+  let(:gimp_processor) { instance_double(RubySpriter::GimpProcessor) }
+  let(:options) { { debug: false } }
+  let(:stepper) do
+    described_class.new(
+      input_file.path,
+      output_file.path,
+      background_palette,
+      gimp_processor,
+      options
+    )
+  end
+
+  after do
+    input_file.close
+    input_file.unlink
+    output_file.close
+    output_file.unlink
+  end
+
+  describe '#initialize' do
+    it 'accepts background palette parameter' do
+      expect(stepper.instance_variable_get(:@background_palette)).to eq(background_palette)
+    end
+
+    it 'accepts gimp_processor instance' do
+      expect(stepper.instance_variable_get(:@gimp_processor)).to eq(gimp_processor)
+    end
+
+    it 'uses default threshold values' do
+      thresholds = stepper.instance_variable_get(:@threshold_values)
+      expect(thresholds).to eq([0.0, 0.5, 1.0, 3.0, 5.0, 10.0])
+    end
+
+    it 'accepts custom threshold values' do
+      custom_stepper = described_class.new(
+        input_file.path,
+        output_file.path,
+        background_palette,
+        gimp_processor,
+        { threshold_values: [1.0, 5.0, 10.0] }
+      )
+
+      thresholds = custom_stepper.instance_variable_get(:@threshold_values)
+      expect(thresholds).to eq([1.0, 5.0, 10.0])
+    end
+  end
+
+  describe '#process' do
+    it 'generates GIMP script for each threshold value' do
+      # Mock GIMP processor to track script executions
+      script_calls = []
+      allow(gimp_processor).to receive(:execute_python_script) do |script, temp_output|
+        script_calls << { script: script, output: temp_output }
+        true
+      end
+
+      # Mock ImageMagick compositing
+      allow(Open3).to receive(:capture3).and_return(['', '', double(success?: true)])
+
+      stepper.process
+
+      # Should generate 6 scripts (one per default threshold)
+      expect(script_calls.length).to eq(6)
+    end
+
+    it 'includes background palette colors in GIMP script' do
+      generated_script = nil
+      allow(gimp_processor).to receive(:execute_python_script) do |script, _|
+        generated_script = script
+        true
+      end
+
+      allow(Open3).to receive(:capture3).and_return(['', '', double(success?: true)])
+
+      stepper.process
+
+      # Script should reference the background colors (normalized to 0.0-1.0)
+      # Background palette has: {r: 255, g: 255, b: 255}, {r: 250, g: 250, b: 250}, {r: 245, g: 245, b: 245}
+      # These become: rgb(1.0, 1.0, 1.0), rgb(0.98..., 0.98..., 0.98...), rgb(0.96..., 0.96..., 0.96...)
+      expect(generated_script).to include('Gegl.Color.new')  # Uses Gegl.Color
+      expect(generated_script).to include('rgb(')  # RGB format
+      expect(generated_script).to match(/rgb\(1\.0, 1\.0, 1\.0\)/)  # First color (255,255,255)
+    end
+
+    it 'uses gimp-image-select-color in generated script' do
+      generated_script = nil
+      allow(gimp_processor).to receive(:execute_python_script) do |script, _|
+        generated_script = script
+        true
+      end
+
+      allow(Open3).to receive(:capture3).and_return(['', '', double(success?: true)])
+
+      stepper.process
+
+      # Script should use the correct GIMP procedure
+      expect(generated_script).to include('gimp-image-select-color')
+    end
+
+    it 'applies threshold parameter in GIMP script' do
+      generated_scripts = []
+      allow(gimp_processor).to receive(:execute_python_script) do |script, _|
+        generated_scripts << script
+        true
+      end
+
+      allow(Open3).to receive(:capture3).and_return(['', '', double(success?: true)])
+
+      stepper.process
+
+      # Each script should have a different threshold value
+      expect(generated_scripts[0]).to include('threshold')
+      expect(generated_scripts[1]).to include('threshold')
+    end
+
+    it 'composites threshold results with ImageMagick' do
+      allow(gimp_processor).to receive(:execute_python_script).and_return(true)
+
+      composite_calls = []
+      allow(Open3).to receive(:capture3) do |cmd|
+        composite_calls << cmd if cmd.include?('magick')
+        ['', '', double(success?: true)]
+      end
+
+      stepper.process
+
+      # Should composite the results
+      expect(composite_calls.length).to be > 0
+    end
+  end
+
+  describe 'timeout handling' do
+    it 'skips threshold on per-threshold timeout' do
+      call_count = 0
+      allow(gimp_processor).to receive(:execute_python_script) do
+        call_count += 1
+        if call_count == 2
+          # Simulate timeout on second threshold
+          sleep 0.1
+          raise Timeout::Error, 'Threshold processing timeout'
+        end
+        true
+      end
+
+      allow(Open3).to receive(:capture3).and_return(['', '', double(success?: true)])
+
+      # Should not raise error, just skip the threshold
+      expect { stepper.process }.not_to raise_error
+    end
+
+    it 'reports skipped thresholds' do
+      allow(gimp_processor).to receive(:execute_python_script) do
+        raise Timeout::Error, 'Threshold processing timeout'
+      end
+
+      allow(Open3).to receive(:capture3).and_return(['', '', double(success?: true)])
+
+      stepper.process
+      report = stepper.report
+
+      expect(report[:skipped_thresholds]).to be > 0
+    end
+  end
+
+  describe '#report' do
+    it 'includes processing statistics' do
+      allow(gimp_processor).to receive(:execute_python_script).and_return(true)
+      allow(Open3).to receive(:capture3).and_return(['', '', double(success?: true)])
+
+      stepper.process
+      report = stepper.report
+
+      expect(report).to have_key(:thresholds_processed)
+      expect(report).to have_key(:skipped_thresholds)
+      expect(report).to have_key(:total_time)
+    end
+  end
+end

metadata

@@ -1,19 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: ruby_spriter
 version: !ruby/object:Gem::Version
-  version: 0.6.7.1
+  version: 0.7.0.1
 platform: ruby
 authors:
 - scooter-indie
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-10-25 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: |
-  Ruby Spriter is a cross-platform tool for creating spritesheets from video files
-  and processing them with GIMP. Features include background removal, scaling,
-  consolidation, and metadata management.
+  Ruby Spriter is a cross-platform tool for creating professional spritesheets from video files
+  with advanced GIMP image processing. Features include edge-based and inner background removal,
+  multi-threshold processing, ghost edge prevention, smoke detection, scaling with multiple
+  interpolation methods, sharpening, batch processing, spritesheet consolidation, frame extraction,
+  and comprehensive metadata management. Designed for game development workflows with Godot Engine.
 email:
 - scooter-indie@users.noreply.github.com
 executables:
@@ -28,28 +29,56 @@ files:
 - README.md
 - bin/ruby_spriter
 - lib/ruby_spriter.rb
+- lib/ruby_spriter/background_sampler.rb
 - lib/ruby_spriter/batch_processor.rb
+- lib/ruby_spriter/cell_cleanup_config.rb
+- lib/ruby_spriter/cell_cleanup_gimp_script.rb
+- lib/ruby_spriter/cell_cleanup_processor.rb
 - lib/ruby_spriter/cli.rb
 - lib/ruby_spriter/compression_manager.rb
 - lib/ruby_spriter/consolidator.rb
 - lib/ruby_spriter/dependency_checker.rb
+- lib/ruby_spriter/ghost_edge_cleaner.rb
 - lib/ruby_spriter/gimp_processor.rb
 - lib/ruby_spriter/metadata_manager.rb
 - lib/ruby_spriter/platform.rb
 - lib/ruby_spriter/processor.rb
+- lib/ruby_spriter/smoke_detector.rb
+- lib/ruby_spriter/threshold_stepper.rb
 - lib/ruby_spriter/utils/file_helper.rb
+- lib/ruby_spriter/utils/image_helper.rb
 - lib/ruby_spriter/utils/output_formatter.rb
 - lib/ruby_spriter/utils/path_helper.rb
 - lib/ruby_spriter/utils/spritesheet_splitter.rb
 - lib/ruby_spriter/version.rb
 - lib/ruby_spriter/video_processor.rb
 - ruby_spriter.gemspec
+- spec/fixtures/centered_sprite_with_inner_bg.png
+- spec/fixtures/centered_sprite_with_inner_bg_inner_removed.png
+- spec/fixtures/centered_sprite_with_inner_bg_threshold_stepped.png
+- spec/fixtures/complex_background_sprite.png
+- spec/fixtures/death - bloodborne rekconing.mp4
+- spec/fixtures/death - bloodborne rekconing_spritesheet-nobg-global.png
+- spec/fixtures/death - bloodborne rekconing_spritesheet.png
+- spec/fixtures/death - bloodborne rekconing_spritesheet_20251110_185027_431-nobg-global.png
+- spec/fixtures/death - bloodborne rekconing_spritesheet_20251110_185027_431.png
+- spec/fixtures/death - bloodborne rekconing_spritesheet_20251110_185125_738-nobg-global.png
+- spec/fixtures/death - bloodborne rekconing_spritesheet_20251110_185125_738.png
+- spec/fixtures/has_inner_bg.png
+- spec/fixtures/has_small_inner_bg.png
 - spec/fixtures/image_without_metadata.png
+- spec/fixtures/smoke_effect_sprite.png
 - spec/fixtures/spritesheet_4x2.png
 - spec/fixtures/spritesheet_4x4.png
 - spec/fixtures/spritesheet_6x2.png
 - spec/fixtures/spritesheet_with_metadata.png
+- spec/fixtures/test_sprite.png
+- spec/fixtures/test_sprite_smoke_processed.png
 - spec/fixtures/test_video.mp4
+- spec/fixtures/test_video_spritesheet.png
+- spec/fixtures/transparent_bg_sprite.png
+- spec/fixtures/walk_north_sprite-sheet.png
+- spec/integration/no_fuzzy_mode_spec.rb
 - spec/ruby_spriter/batch_processor_spec.rb
 - spec/ruby_spriter/cli_spec.rb
 - spec/ruby_spriter/compression_manager_spec.rb
@@ -65,6 +94,25 @@ files:
 - spec/ruby_spriter/utils/spritesheet_splitter_spec.rb
 - spec/ruby_spriter/video_processor_spec.rb
 - spec/spec_helper.rb
+- spec/tmp/cli_test_output.png
+- spec/tmp/cli_test_output_20251105_114647_395.png
+- spec/tmp/combined_test.png
+- spec/tmp/compat_test.png
+- spec/tmp/compat_test_20251030_174233_361.png
+- spec/tmp/final_all_features.png
+- spec/tmp/final_test_all_features.png
+- spec/tmp/full_pipeline_test.png
+- spec/tmp/inner_test.png
+- spec/tmp/integration_test.png
+- spec/tmp/validation_test.png
+- spec/unit/background_sampler_spec.rb
+- spec/unit/cell_cleanup_config_spec.rb
+- spec/unit/cell_cleanup_gimp_script_spec.rb
+- spec/unit/cell_cleanup_processor_spec.rb
+- spec/unit/ghost_edge_cleaner_spec.rb
+- spec/unit/gimp_processor_single_point_selection_spec.rb
+- spec/unit/smoke_detector_spec.rb
+- spec/unit/threshold_stepper_spec.rb
 homepage: https://github.com/scooter-indie/ruby-spriter
 licenses:
 - MIT
@@ -72,7 +120,6 @@ metadata:
   homepage_uri: https://github.com/scooter-indie/ruby-spriter
   source_code_uri: https://github.com/scooter-indie/ruby-spriter
   changelog_uri: https://github.com/scooter-indie/ruby-spriter/blob/main/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -87,8 +134,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.7.2
 specification_version: 4
-summary: MP4 to Spritesheet converter with GIMP image processing
+summary: Professional MP4 to Spritesheet converter with advanced GIMP image processing
 test_files: []