ruby_spriter 0.6.5

data/lib/ruby_spriter/cli.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module RubySpriter
+  # Command-line interface
+  class CLI
+    PRESETS = {
+      thumbnail: { columns: 3, frame_count: 9, max_width: 240 },
+      preview: { columns: 4, frame_count: 16, max_width: 400 },
+      detailed: { columns: 10, frame_count: 50, max_width: 320 },
+      contact: { columns: 8, frame_count: 64, max_width: 160 }
+    }.freeze
+
+    def self.start(args)
+      new.parse_and_run(args)
+    end
+
+    def parse_and_run(args)
+      options = {}
+      parser = build_option_parser(options)
+
+      parser.parse!(args)
+
+      # Handle special commands that don't need full processing
+      if options[:check_dependencies]
+        checker = DependencyChecker.new(verbose: true)
+        checker.print_report
+        exit(checker.all_satisfied? ? 0 : 1)
+      end
+
+      # Run processor
+      processor = Processor.new(options)
+      processor.run
+    rescue OptionParser::InvalidOption, OptionParser::MissingArgument => e
+      puts "Error: #{e.message}"
+      puts "\nUse --help for usage information"
+      exit 1
+    end
+
+    private
+
+    def build_option_parser(options)
+      OptionParser.new do |opts|
+        opts.banner = "Usage: ruby_spriter [options]"
+        
+        add_header(opts)
+        add_input_options(opts, options)
+        add_spritesheet_options(opts, options)
+        add_gimp_options(opts, options)
+        add_bg_removal_options(opts, options)
+        add_consolidation_options(opts, options)
+        add_preset_options(opts, options)
+        add_other_options(opts, options)
+      end
+    end
+
+    def add_header(opts)
+      opts.separator ""
+      opts.separator "Ruby Spriter v#{VERSION} - MP4 to Spritesheet + GIMP Processing"
+      opts.separator "Platform: #{Platform.current.to_s.capitalize}"
+      opts.separator ""
+    end
+
+    def add_input_options(opts, options)
+      opts.separator "Input Options:"
+      
+      opts.on("-v", "--video FILE", "Input video file (MP4)") do |v|
+        options[:video] = v
+      end
+
+      opts.on("-i", "--image FILE", "Input image file (PNG) for direct processing") do |i|
+        options[:image] = i
+      end
+
+      opts.on("--consolidate FILES", Array, "Consolidate multiple spritesheets (comma-separated)") do |c|
+        options[:consolidate] = c
+      end
+
+      opts.on("--verify FILE", "Verify spritesheet metadata") do |v|
+        options[:verify] = v
+      end
+
+      opts.separator ""
+    end
+
+    def add_spritesheet_options(opts, options)
+      opts.separator "Spritesheet Options:"
+
+      opts.on("-o", "--output FILE", "Output file path") do |o|
+        options[:output] = o
+      end
+
+      opts.on("-f", "--frames COUNT", Integer, "Number of frames to extract (default: 16)") do |f|
+        options[:frame_count] = f
+      end
+
+      opts.on("-c", "--columns COUNT", Integer, "Grid columns (default: 4)") do |c|
+        options[:columns] = c
+      end
+
+      opts.on("-w", "--width PIXELS", Integer, "Max frame width (default: 320)") do |w|
+        options[:max_width] = w
+      end
+
+      opts.on("-b", "--background COLOR", "Tile background: black, white (default: black)") do |b|
+        options[:bg_color] = b
+      end
+
+      opts.separator ""
+    end
+
+    def add_gimp_options(opts, options)
+      opts.separator "GIMP Processing Options:"
+
+      opts.on("-s", "--scale PERCENT", Integer, "Scale image by percentage") do |s|
+        options[:scale_percent] = s
+      end
+
+      opts.on("--interpolation METHOD", [:none, :linear, :cubic, :nohalo, :lohalo],
+              "Interpolation method: none, linear, cubic, nohalo, lohalo (default: nohalo)") do |i|
+        options[:scale_interpolation] = i.to_s
+      end
+
+      opts.on("--sharpen", "Apply unsharp mask after scaling (enhances edges)") do
+        options[:sharpen] = true
+      end
+
+      opts.on("--sharpen-radius VALUE", Float, "Sharpen radius in pixels (default: 2.0)") do |r|
+        options[:sharpen_radius] = r
+      end
+
+      opts.on("--sharpen-gain VALUE", Float, "Sharpen gain/strength (default: 0.5, range: 0.0-2.0+)") do |g|
+        options[:sharpen_gain] = g
+      end
+
+      opts.on("--sharpen-threshold VALUE", Float, "Sharpen threshold as fraction (default: 0.03, range: 0.0-1.0)") do |t|
+        options[:sharpen_threshold] = t
+      end
+
+      opts.on("-r", "--remove-bg", "Remove background from spritesheet using GIMP") do
+        options[:remove_bg] = true
+      end
+
+      opts.on("-t", "--threshold VALUE", Float, "Feather radius (default: 0.0 = no feathering)") do |t|
+        options[:bg_threshold] = t
+      end
+
+      opts.on("-g", "--grow PIXELS", Integer, "Pixels to grow selection (default: 1)") do |g|
+        options[:grow_selection] = g
+      end
+
+      opts.separator ""
+    end
+
+    def add_bg_removal_options(opts, options)
+      opts.separator "Background Removal Method:"
+
+      opts.on("--fuzzy", "Use fuzzy select (contiguous regions) - DEFAULT") do
+        options[:fuzzy_select] = true
+      end
+
+      opts.on("--no-fuzzy", "Use global color select (all matching pixels)") do
+        options[:fuzzy_select] = false
+      end
+
+      opts.separator ""
+      opts.separator "Operation Order:"
+
+      opts.on("--order ORDER", [:scale_first, :bg_first],
+              "Operation order: scale_first or bg_first (default: scale_first)") do |order|
+        options[:operation_order] = order == :scale_first ? :scale_then_remove_bg : :remove_bg_then_scale
+      end
+
+      opts.separator ""
+    end
+
+    def add_consolidation_options(opts, options)
+      opts.separator "Consolidation Options:"
+
+      opts.on("--[no-]validate-columns", "Abort if column counts don't match (default: true)") do |v|
+        options[:validate_columns] = v
+      end
+
+      opts.separator ""
+    end
+
+    def add_preset_options(opts, options)
+      opts.separator "Preset Configurations:"
+
+      preset_descriptions = PRESETS.map do |name, config|
+        "    #{name}: #{config[:columns]}×? grid, #{config[:frame_count]} frames, #{config[:max_width]}px wide"
+      end.join("\n")
+
+      opts.on("--preset NAME", String, "Apply preset configuration:",
+              *preset_descriptions.split("\n")) do |preset_name|
+        preset_key = preset_name.to_sym
+        unless PRESETS.key?(preset_key)
+          valid_presets = PRESETS.keys.join(', ')
+          raise OptionParser::InvalidArgument, "Unknown preset: #{preset_name}. Valid options: #{valid_presets}"
+        end
+        options.merge!(PRESETS[preset_key])
+      end
+
+      opts.separator ""
+    end
+
+    def add_other_options(opts, options)
+      opts.separator "Other Options:"
+
+      opts.on("--keep-temp", "Keep temporary files for debugging") do
+        options[:keep_temp] = true
+      end
+
+      opts.on("--debug", "Enable debug mode (verbose output + keep temp files)") do
+        options[:debug] = true
+        options[:keep_temp] = true
+      end
+
+      opts.on("-h", "--help", "Show this help message") do
+        puts opts
+        exit
+      end
+
+      opts.on("--version", "Show version information") do
+        puts "Ruby Spriter v#{VERSION}"
+        puts "Platform: #{Platform.current.to_s.capitalize}"
+        puts "Date: #{VERSION_DATE}"
+        exit
+      end
+
+      opts.on("--check-dependencies", "Check if all required external tools are installed") do
+        options[:check_dependencies] = true
+      end
+
+      opts.separator ""
+      opts.separator "Examples:"
+      opts.separator "  ruby_spriter --check-dependencies"
+      opts.separator "  ruby_spriter --video input.mp4"
+      opts.separator "  ruby_spriter --video input.mp4 --remove-bg --scale 50"
+      opts.separator "  ruby_spriter --video input.mp4 --scale 50 --interpolation nohalo --sharpen"
+      opts.separator "  ruby_spriter --image sprite.png --scale 50 --sharpen --sharpen-gain 1.5"
+      opts.separator "  ruby_spriter --image sprite.png --remove-bg --fuzzy"
+      opts.separator "  ruby_spriter --consolidate file1.png,file2.png,file3.png"
+      opts.separator "  ruby_spriter --verify spritesheet.png"
+      opts.separator ""
+    end
+  end
+end

data/lib/ruby_spriter/consolidator.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module RubySpriter
+  # Consolidates multiple spritesheets vertically
+  class Consolidator
+    attr_reader :options
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    # Consolidate multiple spritesheets into one
+    # @param files [Array<String>] Array of spritesheet file paths
+    # @param output_file [String] Output consolidated file path
+    # @return [Hash] Processing results
+    def consolidate(files, output_file)
+      validate_files!(files)
+
+      Utils::OutputFormatter.header("Consolidating Spritesheets")
+
+      metadata_list = read_all_metadata(files)
+      validate_compatibility!(metadata_list) if options[:validate_columns]
+
+      create_consolidated_image(files, output_file)
+
+      total_frames = metadata_list.sum { |m| m[:frames] }
+      columns = metadata_list.first[:columns]
+      rows = (total_frames.to_f / columns).ceil
+
+      # Embed consolidated metadata
+      temp_file = output_file.sub('.png', '_temp.png')
+      File.rename(output_file, temp_file)
+
+      MetadataManager.embed(
+        temp_file,
+        output_file,
+        columns: columns,
+        rows: rows,
+        frames: total_frames,
+        debug: options[:debug]
+      )
+
+      File.delete(temp_file) if File.exist?(temp_file)
+
+      file_size = File.size(output_file)
+
+      # Display results with Godot instructions
+      display_consolidation_results(output_file, file_size, files, metadata_list, columns, rows, total_frames)
+
+      {
+        output_file: output_file,
+        columns: columns,
+        rows: rows,
+        frames: total_frames,
+        size: file_size
+      }
+    end
+
+    private
+
+    def validate_files!(files)
+      raise ValidationError, "Need at least 2 files to consolidate" if files.length < 2
+
+      files.each { |file| Utils::FileHelper.validate_readable!(file) }
+    end
+
+    def read_all_metadata(files)
+      metadata_list = files.map do |file|
+        metadata = MetadataManager.read(file)
+        
+        unless metadata
+          raise ValidationError, "File missing metadata: #{file}\nAll files must be Ruby Spriter spritesheets."
+        end
+
+        metadata
+      end
+
+      metadata_list
+    end
+
+    def validate_compatibility!(metadata_list)
+      columns = metadata_list.first[:columns]
+      
+      incompatible = metadata_list.find { |m| m[:columns] != columns }
+      
+      if incompatible
+        raise ValidationError, 
+          "Column count mismatch: Expected #{columns}, found #{incompatible[:columns]}\n" \
+          "Use --no-validate-columns to force consolidation."
+      end
+    end
+
+    def create_consolidated_image(files, output_file)
+      Utils::OutputFormatter.indent("Stacking spritesheets vertically...")
+
+      # Use ImageMagick to stack images vertically
+      magick_cmd = Platform.imagemagick_convert_cmd
+      
+      cmd = [
+        magick_cmd,
+        *files.map { |f| Utils::PathHelper.quote_path(f) },
+        '-append',
+        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 consolidation failed: #{stderr}"
+      end
+
+      Utils::FileHelper.validate_exists!(output_file)
+    end
+
+    def display_consolidation_results(output_file, file_size, files, metadata_list, columns, rows, total_frames)
+      Utils::OutputFormatter.success("Consolidated spritesheet created")
+      Utils::OutputFormatter.indent("Output: #{output_file}")
+      Utils::OutputFormatter.indent("Size: #{Utils::FileHelper.format_size(file_size)}")
+      Utils::OutputFormatter.note("Combined #{files.length} spritesheets (#{total_frames} total frames)")
+      
+      puts "\n      Grid Layout:"
+      Utils::OutputFormatter.indent("Columns: #{columns}")
+      Utils::OutputFormatter.indent("Rows: #{rows}")
+      Utils::OutputFormatter.indent("Total Frames: #{total_frames}")
+      
+      puts "\n      📊 Godot AnimatedSprite2D Settings:"
+      Utils::OutputFormatter.indent("HFrames = #{columns}")
+      Utils::OutputFormatter.indent("VFrames = #{rows}")
+      
+      puts "\n      📋 Source Breakdown:"
+      metadata_list.each_with_index do |meta, index|
+        file_basename = File.basename(files[index])
+        Utils::OutputFormatter.indent("#{index + 1}. #{file_basename}")
+        Utils::OutputFormatter.indent("   └─ #{meta[:columns]}×#{meta[:rows]} grid (#{meta[:frames]} frames)")
+      end
+      
+      puts ""
+    end
+  end
+end

data/lib/ruby_spriter/dependency_checker.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module RubySpriter
+  # Checks for required external dependencies
+  class DependencyChecker
+    REQUIRED_TOOLS = {
+      ffmpeg: {
+        command: 'ffmpeg -version',
+        pattern: /ffmpeg version/i,
+        install: {
+          windows: 'choco install ffmpeg',
+          linux: 'sudo apt install ffmpeg',
+          macos: 'brew install ffmpeg'
+        }
+      },
+      ffprobe: {
+        command: 'ffprobe -version',
+        pattern: /ffprobe version/i,
+        install: {
+          windows: 'Included with ffmpeg',
+          linux: 'Included with ffmpeg',
+          macos: 'Included with ffmpeg'
+        }
+      },
+      imagemagick: {
+        command: Platform.imagemagick_identify_cmd + ' -version',
+        pattern: /ImageMagick/i,
+        install: {
+          windows: 'choco install imagemagick',
+          linux: 'sudo apt install imagemagick',
+          macos: 'brew install imagemagick'
+        }
+      }
+    }.freeze
+
+    def initialize(verbose: false)
+      @verbose = verbose
+      @gimp_path = nil
+    end
+
+    # Check all dependencies
+    # @return [Hash] Results of dependency checks
+    def check_all
+      results = {}
+      
+      REQUIRED_TOOLS.each do |tool, config|
+        results[tool] = check_tool(tool, config)
+      end
+
+      results[:gimp] = check_gimp
+
+      results
+    end
+
+    # Check if all dependencies are satisfied
+    # @return [Boolean] true if all dependencies are available
+    def all_satisfied?
+      results = check_all
+      results.all? { |_tool, status| status[:available] }
+    end
+
+    # Print dependency status report
+    def print_report
+      results = check_all
+      
+      puts "\n" + "=" * 60
+      puts "Dependency Check"
+      puts "=" * 60
+      
+      results.each do |tool, status|
+        icon = status[:available] ? "✅" : "❌"
+        puts "\n#{icon} #{tool.to_s.upcase}"
+        
+        if status[:available]
+          puts "   Found: #{status[:path] || status[:version]}"
+        else
+          puts "   Status: NOT FOUND"
+          puts "   Install: #{status[:install_cmd]}"
+        end
+      end
+      
+      puts "\n" + "=" * 60 + "\n"
+    end
+
+    # Get the found GIMP executable path
+    attr_reader :gimp_path
+
+    private
+
+    def check_tool(tool, config)
+      stdout, stderr, status = Open3.capture3(config[:command])
+      output = stdout + stderr
+
+      if status.success? && output.match?(config[:pattern])
+        version = extract_version(output)
+        {
+          available: true,
+          version: version,
+          install_cmd: nil
+        }
+      else
+        {
+          available: false,
+          version: nil,
+          install_cmd: config[:install][Platform.current]
+        }
+      end
+    rescue StandardError => e
+      puts "DEBUG: Error checking #{tool}: #{e.message}" if @verbose
+      {
+        available: false,
+        version: nil,
+        install_cmd: config[:install][Platform.current]
+      }
+    end
+
+    def check_gimp
+      # Try default path first
+      default_path = Platform.default_gimp_path
+      if gimp_exists?(default_path)
+        @gimp_path = default_path
+        return gimp_status(true, default_path)
+      end
+
+      # Try alternative paths
+      Platform.alternative_gimp_paths.each do |path|
+        if gimp_exists?(path)
+          @gimp_path = path
+          return gimp_status(true, path)
+        end
+      end
+
+      # Not found
+      gimp_status(false, nil)
+    end
+
+    def gimp_exists?(path)
+      return false if path.nil? || path.empty?
+      File.exist?(path)
+    end
+
+    def gimp_status(available, path)
+      {
+        available: available,
+        path: path,
+        install_cmd: gimp_install_command
+      }
+    end
+
+    def gimp_install_command
+      case Platform.current
+      when :windows
+        'Download from https://www.gimp.org/downloads/ or use: choco install gimp'
+      when :linux
+        'sudo apt install gimp'
+      when :macos
+        'brew install gimp'
+      else
+        'Visit https://www.gimp.org/downloads/'
+      end
+    end
+
+    def extract_version(output)
+      # Try to extract version number from output
+      if output =~ /version\s+(\d+\.\d+[\.\d]*)/i
+        $1
+      else
+        output.lines.first&.strip || 'Unknown'
+      end
+    end
+  end
+end