shattered_machine 0.0.1

data/lib/shattered_machine/pixel_sorter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative '../rusty_engine/rusty_engine'
+
+module ShatteredMachine
+  # Sort pixels of a given png image.
+  # The logic for the pixel sorter come from the Rusty Engine.
+  class PixelSorter
+    # @param options [Hash] options for pixel sort algorithm
+    def initialize(options = {})
+      @direction = options[:direction] || :vertical
+      @smart_sorting = (options[:smart_sorting] || true).to_s
+      @detection_type = options[:detection_type] || :lightness_range
+      @detection_min = options[:detection_min] || '45'
+      @detection_max = options[:detection_max] || '60'
+      @multiple_ranges = (options[:multiple_ranges] || false).to_s
+      @detection_min_2 = options[:detection_min_2] || '75'
+      @detection_max_2 = options[:detection_max_2] || '90'
+      @sorting_by = options[:sorting_by] || :hue
+    end
+
+    # @param input_image [string] path for image
+    # @param output_image [string] path for output pixel sorted image
+    # @return [boolean] status of pixel sort
+    def call(input_image, output_image)
+      RustyEngine.sort(input_image, output_image, rust_formatted_direction, @smart_sorting,
+                       rust_formatted_detection_type, @detection_min, @detection_max, @multiple_ranges,
+                       @detection_min_2, @detection_max_2, rust_formatted_sorting_by)
+    end
+
+    private
+
+    def rust_formatted_direction
+      ruby_to_rust_directions = { horizontal: '1', vertical: '2',
+                                  horizontal_inverted: '3',
+                                  vertical_inverted: '4' }
+      ruby_to_rust_directions[@direction]
+    end
+
+    def rust_formatted_detection_type
+      ruby_to_rust_detection_type = { lightness_range: '0', colors: '1' }
+      ruby_to_rust_detection_type[@detection_type]
+    end
+
+    def rust_formatted_sorting_by
+      ruby_to_rust_sorting_by = { hue: '0', staturation: '1' }
+      ruby_to_rust_sorting_by[@sorting_by]
+    end
+  end
+end

data/lib/shattered_machine/sampler.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'pnglitch'
+module ShatteredMachine
+  # A simple weay ro run one, many or all glitch algotirhm on one specific image.
+  # This create a quick overview of the effect of each algo for the given image.
+  class Sampler
+    FILTERS = %w[none sub up average paeth].freeze
+    SLIM_DIRECTION = %w[up_to_down down_to_up left_to_right right_to_left].freeze
+    BRUSH_DIRECTION = %w[vertical vertical_inverted horizontal horizontal_inverted].freeze
+    ALL_ALGORITHMS = %w[exchange transpose wrong_filter slim brus change_byte defect]
+
+    # @param io [ShatteredMachine::Io] Io containing paths for images to sample
+    # @param options [Hash] options for specifying which
+    def initialize(io, options = {})
+      @io = io
+      @base_output_filename = options[:base_output_filename] || 'sample'
+      @algorithms_to_sample = options[:algorithms_to_sample] || ALL_ALGORITHMS
+    end
+
+    def call
+      FILTERS.each do |filter|
+        sample_exchange(filter)
+        sample_transpose(filter)
+        sample_wrong_filter(filter)
+      end
+      sample_slim
+      sample_brush
+      sample_change_byte
+      sample_defect
+    end
+
+    private
+
+    def update_io(output_filename_appendix)
+      @io.output_filename = "#{@base_output_filename}_#{output_filename_appendix}"
+    end
+
+    def sample_exchange(filter)
+      return unless @algorithms_to_sample.include? 'exchange'
+
+      exchange_options = { filter: filter }
+      update_io("exchange_#{filter}")
+      Glitcher.new('Exchange', @io, exchange_options).call
+    end
+
+    def sample_transpose(filter)
+      return unless @algorithms_to_sample.include? 'transpose'
+
+      transpose_options = { filter: filter }
+      update_io("transpose_#{filter}")
+      Glitcher.new('Transpose', @io, transpose_options).call
+    end
+
+    def sample_wrong_filter(filter)
+      return unless @algorithms_to_sample.include? 'wrong_filter'
+
+      wrong_filter_options = { algorithm: 'wrong_filter',
+                               filter: filter }
+      update_io("wrong_filter_#{filter}")
+      Glitcher.new('WrongFilter', @io, wrong_filter_options).call
+    end
+
+    def sample_slim
+      return unless @algorithms_to_sample.include? 'slim'
+
+      SLIM_DIRECTION.each do |direction|
+        update_io("slim_#{direction}")
+        slim_options = { direction: direction.to_sym }
+        Glitcher.new('Slim', @io, slim_options).call
+      end
+    end
+
+    def sample_brush
+      return unless @algorithms_to_sample.include? 'brush'
+
+      BRUSH_DIRECTION.each do |direction|
+        update_io("brush_#{direction}")
+        brush_options = { direction: direction.to_sym }
+        Glitcher.new('Brush', @io, brush_options).call
+      end
+    end
+
+    def sample_change_byte
+      return unless @algorithms_to_sample.include? 'change_byte'
+
+      update_io("change_byte")
+      change_byte_options = { algorithm: 'change_byte' }
+      Glitcher.new('ChangeByte', @io, change_byte_options).call
+    end
+
+    def sample_defect
+      return unless @algorithms_to_sample.include? 'defect'
+
+      update_io("defect")
+      defect_options = { random: true, iterations: 10 }
+      Glitcher.new('Defect', @io, defect_options).call
+    end
+  end
+end

data/lib/shattered_machine/slim.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative '../rusty_engine/rusty_engine'
+
+module ShatteredMachine
+  # Repeat pixels of a given png image.
+  # The logic for the pixel sorter come from the Rusty Engine.
+  class Slim
+    ALL_COLORS = %i(white black grey red green blue cyan yellow magenta).freeze
+
+    # @param options [Hash] options for slim algorithm
+    def initialize(options = {})
+      @colors = options[:colors] || ALL_COLORS
+      @direction = options[:direction] || :up_to_down
+      @probability = (options[:probability] || 95).to_s
+      @probability_area = options[:probability_area] || 'global'
+      @colors_with_proba = colors_with_proba(options[:colors_with_proba])
+    end
+
+    # @param input_image [string] path for image
+    # @param output_image [string] path for output slimed image
+    # @return [boolean] status of slim
+    def call(input_image, output_image)
+      RustyEngine.slim(input_image, output_image, @probability, @probability_area,
+                       rust_formatted_direction, rust_formatted_colors,
+                       rust_formatted_color_with_proba)
+    end
+
+    private
+
+    def colors_with_proba(colors_with_proba_options)
+      if colors_with_proba_options.nil? || colors_with_proba_options.empty?
+        ALL_COLORS.map { |c| [c.to_sym, @probability] }.to_h
+      else
+        colors_with_proba_options
+      end
+    end
+
+    def rust_formatted_direction
+      ruby_to_rust_directions = { up_to_down: '1', down_to_up: '2',
+                                  left_to_right: '3', right_to_left: '4' }
+      ruby_to_rust_directions[@direction]
+    end
+
+    def rust_formatted_colors
+      @colors.join(',')
+    end
+
+    def rust_formatted_color_with_proba
+      @colors_with_proba.map do |key, value|
+        "#{key}:#{value}"
+      end.join(',')
+    end
+  end
+end

data/lib/shattered_machine/transpose.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'pnglitch'
+module ShatteredMachine
+  # Use the transpose algorithm from pnglitch on a given png image.
+  class Transpose
+    # @param options [Hash] options for transpose algorithm
+    def initialize(options = {})
+      @filter = define_filter(options[:filter]) || 'average'
+      @transpose_force = options[:transpose_force] || 'half'
+    end
+
+    # @param input_image [string] path for image
+    # @param output_image [string] path for output transposed image
+    # @return [boolean] status of transpose
+    def call(input_image, output_image)
+      PNGlitch.open(input_image) do |png|
+        filtered_glitch(png, @filter).save output_image
+      end
+      output_image
+    end
+
+    private
+
+    def define_filter(filter_from_options)
+      return filter_from_options unless filter_from_options == 'random'
+
+      available_filters = %w(none sub up average paeth)
+      available_filters[rand(5)]
+    end
+
+    def filtered_glitch(png, custom_filter)
+      png.each_scanline do |scanline|
+        scanline.change_filter custom_filter
+      end
+      png.glitch do |data|
+        transpose_data(data)
+      end
+    end
+
+    def transpose_data(data)
+      x = data.size / 4
+      if @transpose_force == 'half'
+        data[0, x] + data[x * 2, x] + data[x * 1, x] + data[x * 3..-1]
+      else
+        data[x * 2, x] + data[0, x] + data[x * 3..-1] + data[x * 1, x]
+      end
+    end
+  end
+end

data/lib/shattered_machine/wrong_filter.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'pnglitch'
+module ShatteredMachine
+  # Use the wrong filter algorithm from pnglitch on a given png image.
+  class WrongFilter
+    # @param options [Hash] options for wrong filter algorithm
+    def initialize(options = {})
+      @filter = options[:filter] || 'average'
+    end
+
+    # @param input_image [string] path for image
+    # @param output_image [string] path for output wrong filtered image
+    # @return [boolean] status of wrong filter
+    def call(input_image, output_image)
+      PNGlitch.open(input_image) do |png|
+        filtered_glitch(png, @filter).save output_image
+      end
+      output_image
+    end
+
+    private
+
+    def define_random_filter
+      available_filters = %w(none sub up average paeth)
+      available_filters[rand(5)]
+    end
+
+    def filtered_glitch(png, custom_filter)
+      png.each_scanline do |scanline|
+        if custom_filter == 'random'
+          scanline.graft define_random_filter
+        else
+          scanline.graft custom_filter
+        end
+      end
+    end
+  end
+end

data/shattered_machine.gemspec

@@ -0,0 +1,16 @@
+Gem::Specification.new do |s|
+  s.name          = 'shattered_machine'
+  s.version       = '0.0.1'
+  s.summary       = 'Shattered Machine core engine'
+  s.description   = 'Shattered Machine is an easy way to glitch PNG images using different algorithms'
+  s.authors       = ['Flo Girardo']
+  s.email         = 'florian@barbrousse.net'
+  s.files         = `git ls-files`.split($/)
+  s.test_files    = ['spec']
+  s.require_paths = ['lib']
+  s.homepage      =
+    'https://glitchedfactory.com/'
+  s.license       = 'MIT'
+  s.add_development_dependency('rspec', '~> 3')
+  s.add_development_dependency('yard', '~> 0.9')
+end

data/spec/brush_spec.rb

@@ -0,0 +1,28 @@
+# brush_spec.rb
+
+# frozen_string_literal: true
+
+# brush_spec.rb
+require 'spec_helper'
+
+RSpec.describe ShatteredMachine::Brush do
+  describe '#call' do
+    let(:output_file) { 'spec/images/brush.png' }
+    let(:input_file) { 'spec/images/foo.png' }
+    let(:io) do
+      ShatteredMachine::Io.new(input_file, 'spec/images', 'brush')
+    end
+    let(:in_img) { io.png_images.first.input }
+    let(:out_img) { io.png_images.first.output }
+    subject { ShatteredMachine::Brush.new.call(in_img, out_img) }
+
+    after do
+      File.delete(output_file) if File.exist?(output_file)
+    end
+
+    it 'brush image' do
+      subject
+      expect(File.exist?(output_file)).to be true
+    end
+  end
+end

data/spec/change_byte_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# change_byte_spec.rb
+require 'spec_helper'
+
+RSpec.describe ShatteredMachine::ChangeByte do
+  describe '#call' do
+    let(:output_file) { 'spec/images/change_byte.png' }
+    let(:input_file) { 'spec/images/foo.png' }
+    let(:io) do
+      ShatteredMachine::Io.new(input_file, 'spec/images', 'change_byte')
+    end
+    let(:in_img) { io.png_images.first.input }
+    let(:out_img) { io.png_images.first.output }
+    subject { ShatteredMachine::ChangeByte.new.call(in_img, out_img) }
+
+    after do
+      File.delete(output_file) if File.exist?(output_file)
+    end
+
+    it 'change byte on image' do
+      subject
+      expect(File.exist?(output_file)).to be true
+    end
+  end
+end

data/spec/converter_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# converter.rb
+require 'spec_helper'
+
+RSpec.describe ShatteredMachine::Converter do
+  describe '#call' do
+    let(:converted_file) { 'spec/images/converted.png' }
+    let(:input_file) { 'spec/images/foo.jpg' }
+    let(:io) do
+      ShatteredMachine::Io.new(input_file, 'spec/images', 'converted')
+    end
+    subject { ShatteredMachine::Converter.new(io).call }
+
+    after do
+      File.delete(converted_file) if File.exist?(converted_file)
+    end
+
+    it 'convert image' do
+      subject
+      expect(File.exist?(converted_file)).to be true
+    end
+  end
+end

data/spec/defect_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# defect_spec.rb
+require 'spec_helper'
+
+RSpec.describe ShatteredMachine::Defect do
+  describe '#call' do
+    let(:output_file) { 'spec/images/defect.png' }
+    let(:input_file) { 'spec/images/foo.png' }
+    let(:io) do
+      ShatteredMachine::Io.new(input_file, 'spec/images', 'defect')
+    end
+    let(:in_img) { io.png_images.first.input }
+    let(:out_img) { io.png_images.first.output }
+    subject { ShatteredMachine::Defect.new.call(in_img, out_img) }
+
+    after do
+      File.delete(output_file) if File.exist?(output_file)
+    end
+
+    it 'defect image' do
+      subject
+      expect(File.exist?(output_file)).to be true
+    end
+  end
+end

data/spec/exchange_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# exchange_spec.rb
+require 'spec_helper'
+
+RSpec.describe ShatteredMachine::Exchange do
+  describe '#call' do
+    let(:output_file) { 'spec/images/exchange.png' }
+    let(:input_file) { 'spec/images/foo.png' }
+    let(:io) do
+      ShatteredMachine::Io.new(input_file, 'spec/images', 'exchange')
+    end
+    let(:in_img) { io.png_images.first.input }
+    let(:out_img) { io.png_images.first.output }
+    subject { ShatteredMachine::Exchange.new.call(in_img, out_img) }
+
+    after do
+      File.delete(output_file) if File.exist?(output_file)
+    end
+
+    it 'exchange image' do
+      subject
+      expect(File.exist?(output_file)).to be true
+    end
+  end
+end