image_filter_dsl 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dad7597cc47d2d15fbba4c15de8222bd7fd60599709c34801d909ba1b8c4e9e3
+  data.tar.gz: 53dc7843ef41747dc96baac57a440da580821c6b1ff18e3ecad479846343c51d
+SHA512:
+  metadata.gz: 18274358415905e80d5969243832d30847496bc219510d3a11d5fd88be347c7a5de70eeb8415095413c684999beb24a269f5137b3a88c58bb223b6e78fb05a20
+  data.tar.gz: 61fcf052a2afb9f8445fcda605c6e94a84007680d55c5bda9bff4b995f5ff0854f3ba674b072a99da10f6ba037b5991b8308d563f270e73545d0ee95610908d1

data/bin/image_filter_dsl

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'image_filter_dsl'
+
+printf "Image Filter DSL > Process Image\n"
+if ARGV.length == 0
+    printf "Usage: image_filter_dsl <kernel_file> <image_in> <image_out>\n"
+else
+    ImageFilterDsl.cli_process_image(ARGV)
+end

data/lib/image_filter_dsl.rb

@@ -0,0 +1,47 @@
+require_relative './image_filter_dsl/dsl/filter.rb'
+require_relative './image_filter_dsl/dsl/filter_instructions.rb'
+require_relative './image_filter_dsl/dsl/kernel.rb'
+require_relative './image_filter_dsl/binary/struct.rb'
+require_relative './image_filter_dsl/binary/serialize.rb'
+require_relative './image_filter_dsl/engine/io.rb'
+require_relative './image_filter_dsl/engine/image_processor.rb'
+
+##
+# Image Filter DSL Library
+# (c) 2018 VDTDEV/Wade H. ~ MIT License
+# @author Wade H. <vdtdev@gmail.com>
+module ImageFilterDsl
+
+    ##
+    # Reference to Filter module
+    Filter = Dsl::Filter
+
+    ##
+    # Shortcut to ImageProcessor constructor
+    # @param [Dsl::Kernel::FilterKernel|String] kernel FilterKernel object or path to binary kernel file
+    # @param [Integer] threads How many threads for processor to use
+    # @return [Engine::ImageProcessor] new instance of image processor
+    def self.image_processor(kernel, threads=6)
+        Engine::ImageProcessor.new(kernel, threads)
+    end
+
+    ##
+    # Execute process image using kernel from CLI
+    # @param [Array] args Array of arguments (kernel file, img in, img out)
+    def self.cli_process_image(args)
+        kernel_file = args[0]
+        img_in = args[1]
+        img_out = args[2]
+        ip = image_processor(kernel_file)
+        ip.process_image(img_in, img_out)
+    end
+
+    ##
+    # Shorthand for Engine::IO.write
+    # @param [Dsl::Kernel::FilterKernel] filter Filter to write
+    # @param [String] filename Filename to write to
+    def self.save_binary_kernel(filter, filename)
+        Engine::IO.write(filename, filter)
+    end
+
+end

data/lib/image_filter_dsl/binary/serialize.rb

@@ -0,0 +1,175 @@
+##
+# Image Filter DSL Library
+# (c) 2018 VDTDEV/Wade H. ~ MIT License
+# @author Wade H. <vdtdev@gmail.com>
+module ImageFilterDsl
+    module Binary
+        ##
+        # Module providing serialization functionality for converting between
+        # FilterKernel instance and binary IfdKernel record
+        module Serialize
+
+            # @!group Object -> Binary
+
+            ##
+            # Alias for Serialize::from_kernel
+            def self.to_record(filter)
+                from_kernel(filter)
+            end
+
+            ##
+            # Build binary IfdKernel record from Kernel object
+            # @param [Dsl::Kernel::FilterKernel] filter Source filter kernel
+            # @return [Binary::Struct::IfdKernel] Binary kernel record
+            def self.from_kernel(filter)
+                variables = {
+                    inputs: nil,
+                    outputs: nil,
+                    pool: nil,
+                    symbols: nil
+                }
+
+                parts = {}
+
+                # Collect variables
+                pool = (filter.inputs + filter.outputs).uniq
+                filter.instructions.each do |i|
+                    pool += i.inputs
+                    pool += [i.out]
+                    pool.uniq!
+                end
+                variables[:pool] = pool
+
+                # Generate variable symbols
+                variables[:symbols] = {}
+                count = 1
+                variables[:pool].each do |v|
+                    variables[:symbols][v] = count
+                    count += 1
+                end
+
+                # Build variables record
+
+                vars_rec = Binary::Struct::IfdVariables.new(
+                    field_count: variables[:pool].length,
+                    input_count: filter.inputs.length,
+                    output_count: filter.outputs.length,
+                    input_fields: filter.inputs.map { |i| variables[:symbols][i] },
+                    output_fields: filter.outputs.map { |i| variables[:symbols][i] }
+                )
+
+                fkinds = Binary::Struct::FIELD_KINDS
+
+                defs = variables[:symbols].keys.map do |k|
+                    f_field = Binary::Struct::IfdField.new(
+                        symbol: variables[:symbols][k]
+                    )
+
+                    if k.is_a?(Symbol)
+                        f_field.kind = fkinds[:var]
+                        f_field.name_length = k.to_s.length
+                        f_field.variable.assign(k.to_s)
+                    elsif k.is_a?(Integer)
+                        f_field.kind = fkinds[:literal_int]
+                        f_field.int_value = k
+                    else
+                        f_field.kind = fkinds[:literal_float]
+                        f_field.float_value = k
+                    end
+
+                    f_field
+                end
+
+                vars_rec.definition = defs
+                parts[:variables] = vars_rec
+
+                # Build instructions records
+                parts[:instructions] = filter.instructions.map do |i|
+                    inp_fields = i.inputs.map { |f| variables[:symbols][f] }
+                    f_ins = Binary::Struct::IfdInstruction.new(
+                        operation: Binary::Struct.instruction_symbol(i.op),
+                        input_count: i.inputs.length,
+                        input_fields: inp_fields,
+                        output_field: variables[:symbols][i.out]
+                    )
+                    f_ins
+                end
+
+                # Build Kernel Record
+                kernel = Binary::Struct::IfdKernel.new(
+                    header: Binary::Struct::IfdHeader.new,
+                    variables: parts[:variables],
+                    instruction_count: filter.instructions.length,
+                    instructions: parts[:instructions]
+                )
+
+                return kernel
+            end
+
+            # @!endgroup
+
+            # @!group Binary -> Object
+
+            ##
+            # Alias for Serialize::from_record
+            def self.to_kernel(record)
+                from_record(record)
+            end
+
+            ##
+            # Convert IfdKernel record to FilterKernel object
+            # @param [Binary::Struct::IfdKernel] record Record to convert
+            # @return [Dsl::Kernel::FilterKernel] FilterKernel from record
+            def self.from_record(record)
+                ins = []
+                outs = []
+
+                vars = record.variables
+                vardefs = vars.definition
+
+                vars_val = Proc.new do |vs,force_string=false|
+                    r = nil
+                    i = vardefs.select{|v| v.symbol == vs}[0]
+                    if i.kind == Binary::Struct::FIELD_KINDS[:var]
+                        r = i.variable.strip.to_sym
+                        r = ":#{r.to_s}" if force_string
+                    elsif i.kind == Binary::Struct::FIELD_KINDS[:literal_int]
+                        r = i.int_value
+                    else
+                        r = i.float_value
+                    end
+                    r
+                end
+
+                op_sym = Proc.new do |opc|
+                    Dsl::FilterInstructions::OP_INS.select{|k,v| v==opc}.keys[0]
+                end
+
+                ins = vars.input_fields.map { |f|
+                    vardefs.select{|v| v.symbol == f}[0].variable.strip.to_sym
+                }
+
+                outs = vars.output_fields.map { |f|
+                    vardefs.select{|v| v.symbol == f}[0].variable.strip.to_sym
+                }
+
+                instructions = record.instructions.map do |i|
+                    [
+                        "#{op_sym.call(i.operation)} ",
+                        i.input_fields.map{|f| vars_val.call(f) }.to_s,
+                        " , ", vars_val.call(i.output_field, true).to_s
+                    ].join("")
+                end
+
+                f = Dsl::Filter.define(ins, outs){
+                    self.instance_eval(instructions.join("\n"))
+                }
+
+                return f
+            end
+
+            # @!endgroup
+ 
+        end
+    end
+end

data/lib/image_filter_dsl/binary/struct.rb

@@ -0,0 +1,98 @@
+require 'bindata'
+##
+# Image Filter DSL Library
+# (c) 2018 VDTDEV/Wade H. ~ MIT License
+# @author Wade H. <vdtdev@gmail.com>
+module ImageFilterDsl
+    module Binary
+        ##
+        # Data structures used for storing Filter Kernels
+        # in binary format
+        module Struct
+
+            ##
+            # Symbols used to indicate kind of a field
+            FIELD_KINDS = {
+                var:            0x1a,
+                literal_int:    0x12,
+                literal_float:  0x1f
+            }
+
+            ##
+            # Constants used in header
+            HEADER_VALUES = {
+                header: "ifdKernel",
+                version: 0.01
+            }
+
+            ##
+            # Look up hex symbol for instruction in FilterInstructions module
+            # @param [Symbol] ins Instruction to look up
+            # @return [Integer] Instruction hex symbol
+            def self.instruction_symbol(ins)
+                Dsl::FilterInstructions::OP_INS[ins]
+            end
+
+            ##
+            # Image Filter DSL Field record
+            class IfdField < BinData::Record
+                uint16le    :symbol
+                uint16le    :kind
+                uint8le     :name_length
+                string      :variable, :length => :name_length,
+                    :onlyif => lambda { kind == FIELD_KINDS[:var] }
+                int32le     :int_value,
+                    :onlyif => lambda { kind == FIELD_KINDS[:literal_int] }
+                float_le    :float_value,
+                    :onlyif => lambda { kind == FIELD_KINDS[:literal_float] }
+            end
+
+            ##
+            # Image Filter DSL Instruction record
+            class IfdInstruction < BinData::Record
+                uint16le    :operation
+                uint8le     :input_count
+                array       :input_fields, :initial_length => :input_count do
+                    uint16le    :symbol
+                end
+                uint16le    :output_field
+            end
+
+            ##
+            # Image Filter DSL Variables definition record
+            class IfdVariables < BinData::Record
+                uint8le     :field_count
+                uint8le     :input_count
+                uint8le     :output_count
+                array       :definition, :initial_length => :field_count do
+                    ifd_field    :field
+                end
+                array       :input_fields, :initial_length => :input_count do
+                    uint16le    :field
+                end 
+                array       :output_fields, :initial_length => :output_count do
+                    uint16le    :field
+                end
+            end
+
+            ##
+            # Image Filter DSL Header record
+            class IfdHeader < BinData::Record
+                string      :header, read_length: HEADER_VALUES[:header].length,
+                            value: HEADER_VALUES[:header]
+                float_le    :version, value: HEADER_VALUES[:version]
+            end
+
+            ##
+            # Main Image Filter DSL Kernel record
+            class IfdKernel < BinData::Record
+                ifd_header      :header
+                ifd_variables    :variables
+                uint16le        :instruction_count
+                array           :instructions, :initial_length => :instruction_count do
+                    ifd_instruction      :instruction
+                end
+            end
+        end
+    end
+end

data/lib/image_filter_dsl/dsl/filter.rb

@@ -0,0 +1,47 @@
+##
+# Image Filter DSL Library
+# (c) 2018 VDTDEV/Wade H. ~ MIT License
+# @author Wade H. <vdtdev@gmail.com>
+module ImageFilterDsl
+    module Dsl
+        ##
+        # Module used for declaring Filter w/ DSL
+        module Filter
+
+            ##
+            # Define method
+            # @param [Array] ins Input symbols
+            # @param [Array] outs Output symbols
+            # @param [Proc] &block Filter instructions body
+            # @return [FilterKernel] new Filter Kernel
+            def self.define(ins,outs,&block)
+                kernel = Kernel::FilterKernel.new(ins,outs)
+                ip = processor(kernel)
+                ip.instance_eval &block
+                return kernel
+            end
+        
+            private
+
+            ##
+            # Process filter, creating new Instruction Processing module
+            # @param [FilterKernel] kernel Target FilterKernel
+            # @return [Module] module wrapping instructions to target kernel
+            def self.processor(kernel)
+                instruction_proc = Module.new
+        
+                FilterInstructions::OPS.each do |op|
+                    p = Proc.new do |ins,outs|
+                        kernel.store_instruction(
+                            Kernel::KernelInstruction.new(op,ins,outs)
+                        )
+                    end
+                    instruction_proc.class.send(:define_method, op, p)
+                end
+        
+                instruction_proc
+            end
+    
+        end
+    end
+end

data/lib/image_filter_dsl/dsl/filter_instructions.rb

@@ -0,0 +1,225 @@
+##
+# Image Filter DSL Library
+# (c) 2018 VDTDEV/Wade H. ~ MIT License
+# @author Wade H. <vdtdev@gmail.com>
+module ImageFilterDsl
+    module Dsl
+        ##
+        # Module defining filter kernel instruction logic
+        module FilterInstructions
+
+            ##
+            # Hash of binary instruction symbols
+            OP_INS = {
+                # math = 0x0X-0xAF
+                add:    0x01,
+                mult:   0x02,
+                div:    0x03,
+                mod:    0x04,
+                abs:    0x05,
+                # collection op = 0xB0-0xCF
+                min:    0xb0,
+                max:    0xb1,
+                avg:    0xb2,
+                # logic/mem/conv op = 0xD0-??
+                copy:   0xd0,
+                above:  0xd1,
+                below:  0xd2,
+                floor:  0xd3,
+                ceil:   0xd4,
+                float:  0xd5,
+                round:  0xd6,
+                switch: 0xd7,
+                eq:     0xd8,
+                bnot:   0xd9
+            }
+
+            ##
+            # Array of all valid filter instructions
+            OPS = OP_INS.keys
+        
+            ##
+            # Add instruction
+            # @param [Array] input values
+            # @return [Integer|Float] output value
+            def self.add(i) 
+                i.sum
+            end
+        
+            ##
+            # Multiply instruction
+            # @param [Array] input values
+            # @return [Integer|Float] output value
+            def self.mult(i)
+                v=1;
+                i.each{|n|v=v*n}
+                v
+            end
+
+            ##
+            # Multiply instruction
+            # @param [Array] input values
+            # @return [Integer|Float] output value
+            def self.div(i)
+                i[0]/i[1]
+            end
+            ##
+            # Calculate modulo
+            # @param [Array] input values
+            # @return [Integer|] output value
+            def self.mod(i)
+                i[0] % i[1]
+            end
+
+            ##
+            # Absolute value
+            # @param [Array] input value
+            # @return [Integer|Float] output value
+            def self.abs(i)
+                i[0].abs
+            end
+
+            ##
+            # Minimum instruction
+            # @param [Array] input values
+            # @return [Integer|Float] output value
+            def self.min(i)
+                i.min
+            end
+        
+            ##
+            # Maximum instruction
+            # @param [Array] input values
+            # @return [Integer|Float] output value
+            def self.max(i)
+                i.max
+            end
+        
+            ##
+            # Average instruction
+            # @param [Array] input values
+            # @return [Integer|Float] output value
+            def self.avg(i)
+                i.sum / (1.0 * i.length)
+            end
+        
+            ##
+            # Copy instruction
+            # @param [Array] input values (src)
+            # @return [Integer|Float] output value
+            def self.copy(i)
+                i[0]
+            end
+        
+            ##
+            # Above instruction
+            # @param [Array] input values (a,b,trueVal,falseVal)
+            # @return [Integer|Float] output value
+            def self.above(i)
+                if(i[0]>i[1])
+                    if i.length < 3
+                        1
+                    else
+                        i[2]
+                    end
+                else
+                    if i.length < 4
+                        0
+                    else
+                        i[3]
+                    end
+                end
+            end
+        
+            ##
+            # Below instruction
+            # @param [Array] input values (a,b,trueVal,falseVal)
+            # @return [Integer|Float] output value
+            def self.below(i)
+                if(i[0]<i[1])
+                    if i.length < 3
+                        1
+                    else
+                        i[2]
+                    end
+                else
+                    if i.length < 4
+                        0
+                    else
+                        i[3]
+                    end
+                end
+            end
+
+            ##
+            # Floor instruction
+            # @param [Array] input value (v)
+            # @return [Integer|Float] output value
+            def self.floor(i)
+                i[0].floor
+            end
+
+            ##
+            # Ceil instruction
+            # @param [Array] input value (v)
+            # @return [Integer|Float] output value
+            def self.ceil(i)
+                i[0].ceil
+            end
+
+            ##
+            # Float cast instruction
+            # @param [Array] input value (v)
+            # @return [Integer|Float] output value
+            def self.float(i)
+                i[0].to_f
+            end
+
+            ##
+            # Round instruction
+            # @param [Array] input value (val, decimal_places)
+            # @return [Integer|Float] output value
+            def self.round(i)
+                i[0].round(i[1])
+            end
+
+            ##
+            # 'Switch' instruction (basically if)
+            #
+            # switch [condition (0/1/0.0/1.0), trueval, falseval]
+            # @param [Array] input value (condition, true val, false val)
+            # @return [Integer|Float] output value
+            def self.switch(i)
+                if i[0].to_i == 1
+                    i[1]
+                else
+                    i[2]
+                end
+            end
+
+            ##
+            # Equal condition instruction
+            # @param [Array] input value (a, b)
+            # @return [Integer|Float] output value 1 true 0 falsew
+            def self.eq(i)
+                if i[0] == i[1]
+                    1
+                else
+                    0
+                end
+            end
+
+            ##
+            # Logic invert  instruction
+            # @param [Array] input value (0 or 1)
+            # @return [Integer|Float] output value (1 if in 0, 0 if in 1)
+            def self.bnot(i)
+                if i[0].to_i == 1
+                    0
+                else
+                    1
+                end
+            end
+        end
+    end
+end

data/lib/image_filter_dsl/dsl/kernel.rb

@@ -0,0 +1,85 @@
+##
+# Image Filter DSL Library
+# (c) 2018 VDTDEV/Wade H. ~ MIT License
+# @author Wade H. <vdtdev@gmail.com>
+module ImageFilterDsl
+    module Dsl
+        module Kernel
+            ##
+            # IFD Filter Kernel class
+            # @author vdtdev <vdtdev@gmail.com>
+            class FilterKernel
+                attr_accessor :instructions
+                attr_accessor :inputs
+                attr_accessor :outputs
+
+                ##
+                # Kernel constructor
+                # @param [Array] inputs Input symbols
+                # @param [Array] outputs Output symbols
+                def initialize(inputs=[],outputs=[])
+                    @inputs = inputs
+                    @outputs = outputs
+                    @instructions = []
+                end
+
+                ##
+                # Store instruction in kernel
+                # @param [Kernel::KernelInstruction] instruction Instruction to add
+                # @return [Integer] total number of instructions
+                def store_instruction(instruction)
+                    @instructions.append(instruction)
+                    @instructions.length
+                end
+
+                ##
+                # Process filter kernel and produce output hash
+                # @param [Hash] initial_values Hash of values for inputs
+                # @return [Hash] hash of result values for output symbols
+                def process(initial_values)
+                    outs = Hash[* @outputs.map{|o| [o,nil] }.flatten]
+                    @instructions.each do |i|
+                        v = i.calculate(initial_values)
+                        if @outputs.include?(i.out)
+                            outs[i.out] = v
+                        else
+                            initial_values[i.out] = v
+                        end
+                    end
+                    outs
+                end
+            end
+
+            ##
+            # Class representing a FilterKernel instruction
+            class KernelInstruction
+                attr_accessor :op
+                attr_accessor :inputs
+                attr_accessor :out
+
+                ##
+                # Construct new Filter Kernel Instruction
+                # @param [Symbol] op Instruction operation
+                # @param [Array] ins Input symbols
+                # @param [Symbol] out Output symbol
+                def initialize(op,ins,out)
+                    @op = op
+                    @inputs = ins
+                    unless @inputs.kind_of?(Array)
+                        @inputs = [@inputs]
+                    end
+                    @out = out
+                end
+
+                ##
+                # Calculate instruction output
+                # @param [Hash] variables Hash of variable values
+                # @return [Integer|Float] output value
+                def calculate(variables)
+                    vals = @inputs.map{|v| (v.kind_of?(Symbol))? variables[v] : v }
+                    FilterInstructions.method(@op).call(vals)
+                end
+            end
+        end
+    end
+end

data/lib/image_filter_dsl/engine/image_processor.rb

@@ -0,0 +1,199 @@
+require 'chunky_png'
+
+##
+# Image Filter DSL Library
+# (c) 2018 VDTDEV/Wade H. ~ MIT License
+# @author Wade H. <vdtdev@gmail.com>
+module ImageFilterDsl
+    module Engine
+        ##
+        # Image Processor class applies Filter Kernels to images
+        class ImageProcessor
+
+            attr_accessor :kernel, :config
+
+            ##
+            # Constructor
+            # @param [Dsl::Kernel::FilterKernel|String] filter_kernel FilterKernel object or path to binary kernel file
+            # @param [Integer] thread_count How many threads for processor to use
+            def initialize(filter_kernel, thread_count=6)
+                @config = {
+                    filter_kernel_filename: nil,
+                    threads: thread_count
+                }
+
+                if filter_kernel.is_a?(String)
+                    @config[:filter_kernel_filename] = filter_kernel
+
+                    @kernel = Engine::IO.read(
+                        filter_kernel,
+                        Engine::IO::DataFormat::KERNEL
+                    )
+                else
+                    @kernel = filter_kernel
+                end
+            end
+
+            ##
+            # Process image
+            # @param [String] img_src_filename Source image filename
+            # @param [String] img_out_filename Output image filename
+            def process_image(img_src_filename, img_out_filename)
+                img = load_image(img_src_filename)
+
+                size = [img[:image].width, img[:image].height]
+                p_count = size[0] * size[1]
+
+                p_part = p_count / @config[:threads]
+                thread_loads = [].fill(p_part, (0..(@config[:threads])-1))
+
+                if (p_part * @config[:threads]) < p_count
+                    thread_loads[-1] += (p_count - (p_part * @config[:threads]))
+                end
+
+                ranges = thread_loads.map.with_index do |l,i|
+                    start = thread_loads[0..i][0..-2].sum
+                    fin = start + (l - 1)
+                    (start..fin)
+                end
+
+                ranges = ranges.map{|r| r.map{|i| i }}
+
+                threads = []
+
+                (0..@config[:threads]-1).each do |i|
+                    threads << Thread.new {
+                        run_process(img, ranges[i])
+                    }
+                end
+
+                threads.each { |th| th.join }
+
+                save_image(img, img_out_filename)
+            end
+
+            private
+
+            ##
+            # Convert point index to x,y coord
+            # @param [Integer] p Point index
+            # @param [Integer] width Grid width
+            # @return [Hash] Coordinate {:x, :y}
+            def point_coord(p,width)
+                {
+                    x: (p % width),
+                    y: (p / width)
+                }
+            end
+
+            ##
+            # Execute processing for point range
+            # Called inside Thread.new
+            # @param [Hash] data Image data
+            # @param [Array] range Array of range points
+            def run_process(data, range)
+
+                range.each do |p|
+                    c = point_coord(p, data[:image].width)
+                    process_pixel(data, c[:x], c[:y])
+                end
+
+            end
+
+            ##
+            # Process pixel using filter
+            # @param [Hash] data Image data hash
+            # @param [Integer] x Source (possibly dest) X coordinate
+            # @param [Integer] y Source (possibly dest) Y coordinate
+            # @return [Hash] Copy of filter outputs
+            def process_pixel(data, x, y)
+                clr = ChunkyPNG::Color
+                pixel = data[:image].get_pixel(x,y)
+
+                # r = (clr.r(pixel)/255.0).round(2)
+                # g = (clr.g(pixel)/255.0).round(2)
+                # b = (clr.b(pixel)/255.0).round(2)
+                # a = (clr.a(pixel)/255.0).round(2)
+
+                r = clr.r(pixel)
+                g = clr.g(pixel)
+                b = clr.b(pixel)
+                a = clr.a(pixel)
+                
+
+                inputs = Hash[*@kernel.inputs.map{|k|[k,0]}.flatten]
+                inputs[:x] = x if inputs.keys.include?(:x)
+                inputs[:y] = y if inputs.keys.include?(:y)
+                inputs[:r] = r if inputs.keys.include?(:r)
+                inputs[:g] = g if inputs.keys.include?(:g)
+                inputs[:b] = b if inputs.keys.include?(:b)
+                inputs[:a] = a if inputs.keys.include?(:a)
+                inputs[:width] = data[:image].width if inputs.keys.include?(:width)
+                inputs[:hght] = data[:image].height if inputs.keys.include?(:hght)
+
+
+                o = @kernel.process(inputs)
+
+                outputs = {
+                    x: x, y: y, r: r, g: g, b: b, a: a
+                }
+
+                o.keys.each do |k|
+                    if o[k] == Float::INFINITY
+                        p "Infinity: #{k}"
+                    end
+                    outputs[k] = o[k].to_i
+                end
+
+                # o_color = clr.rgba(
+                #     (255*outputs[:r]).to_i,
+                #     (255*outputs[:g]).to_i,
+                #     (255*outputs[:b]).to_i,
+                #     (255*outputs[:a]).to_i
+                # )
+
+                o_color = clr.rgba(
+                    outputs[:r].to_i,
+                    outputs[:g].to_i,
+                    outputs[:b].to_i,
+                    outputs[:a].to_i
+                )
+
+                data[:image].set_pixel(
+                    outputs[:x], outputs[:y],
+                    o_color
+                )
+            end
+
+            ##
+            # Load PNG image using ChunkyPNG
+            # @param [String] filename Filename of image to load
+            # @return [Hash] Hash with :stream as ChunkyPNG::Datastream and
+            #   :image as ChunkyPNG::Image and :filename with original filename
+            def load_image(filename)
+                stream = ChunkyPNG::Datastream.from_file(filename)
+                image = ChunkyPNG::Image.from_datastream(stream)
+                
+                return {
+                    filename: filename,
+                    stream: stream,
+                    image: image
+                }
+            end
+
+            ##
+            # Save image data to disk as PNG
+            # @param [Hash] data Image data as provided by load_image
+            # @param [String] filename Optional filename to save to; if none given,
+            #   uses the original filename from data hash
+            # @return [File] file object written to
+            def save_image(data, filename = nil)
+                # If no filename given, use original
+                filename = data[:filename] if filename.nil?
+                stream = data[:image].to_datastream()
+                stream.save(filename)
+            end
+
+        end
+    end
+end

data/lib/image_filter_dsl/engine/io.rb

@@ -0,0 +1,54 @@
+##
+# Image Filter DSL Library
+# (c) 2018 VDTDEV/Wade H. ~ MIT License
+# @author Wade H. <vdtdev@gmail.com>
+module ImageFilterDsl
+    module Engine
+        ##
+        # I/O methods for reading/writing Filter Kernel data to files
+        module IO
+
+            ##
+            # Constants for format option used in read
+            module DataFormat
+                KERNEL = :kernel
+                RECORD = :record
+            end
+
+            ##
+            # Read Filter Kernel from file
+            # @param [String] filename Filename to read from
+            # @param [Symbol] format Format to return (constants from
+            #   DataFormat module; KERNEL or RECORD)
+            # @return [Dsl::Kernel::FilterKernel|Binary::Struct::IfdKernel] loaded data, 
+            #   in specified format
+            def self.read(filename, format=DataFormat::KERNEL)
+                record = Binary::Struct::IfdKernel.new
+                File.open(filename, 'rb'){|f| record.read(f) }
+
+                if format == DataFormat::RECORD
+                    return record
+                else
+                    return Binary::Serialize.to_kernel(record)
+                end
+            end
+
+            ##
+            # Write filter kernel to file
+            # @param [String] filename File name to write to
+            # @param [Binary::Struct::IfdKernel|Dsl::Kernel::FilterKernel] filter Filter kernel or record to write
+            # @return [Binary::Struct::IfdKernel] IfdKernel record
+            def self.write(filename, filter)
+                rec = nil
+                if filter.is_a?(Dsl::Kernel::FilterKernel)
+                    rec = Binary::Serialize.to_record(filter)
+                elsif filter.is_a?(Binary::Struct::IfdKernel)
+                    rec = filter
+                end
+
+                File.open(filename, 'wb') { |f| rec.write(f) }
+            end
+
+        end
+    end
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: image_filter_dsl
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Wade H.
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-07-02 00:00:00.000000000 Z
+dependencies: []
+description: Image Filter DSL with processing
+email: vdtdev.prod@gmail.com
+executables:
+- image_filter_dsl
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/image_filter_dsl
+- lib/image_filter_dsl.rb
+- lib/image_filter_dsl/binary/serialize.rb
+- lib/image_filter_dsl/binary/struct.rb
+- lib/image_filter_dsl/dsl/filter.rb
+- lib/image_filter_dsl/dsl/filter_instructions.rb
+- lib/image_filter_dsl/dsl/kernel.rb
+- lib/image_filter_dsl/engine/image_processor.rb
+- lib/image_filter_dsl/engine/io.rb
+homepage: https://bitbucket.org/WadeH/image_filter_dsl/src
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://bitbucket.org/WadeH/image_filter_dsl/src
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.8
+signing_key: 
+specification_version: 4
+summary: Image Filter DSL
+test_files: []