image_filter_dsl 0.0.3 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c683878731b0e51f247aff3462f53272a04c13e4c31fbbf1daa14e9ec606f235
-  data.tar.gz: 606bc6208d106f867700b051bb73c917fc55d9985e8df0071e882a90e644f4db
+  metadata.gz: b3c5ec517d5379d54dcac83356f816f4e460ea651956600c4a406766483fff9e
+  data.tar.gz: a26273761002413d8f2944fce7c6d9da591a3b3124be8a640f9c375a029df739
 SHA512:
-  metadata.gz: 88a3935892903034fdef3c0d1e1065d3886a5b6d636b6f46d693cb53fc2a7409cb151bda74ae15b83c39f7dd850a126d83c737da55204262a1592000f9294d55
-  data.tar.gz: 43cbfb2c910938575dbc1a83835e454d0ff1f61000a8f1a8d93247a10fb0b6fa6e2f9288f86a49e4f338a59264e498f513d316957aa693f8b6e543f673cf69db
+  metadata.gz: 573236b32a4096fe6d8e57106cf9e4e79e9c4571583d0b9d1ceb710e8cb2dd227cadc51597bd5d8751fd55efd86ee4038207598833a38f3f41da8d8e3c9b5e47
+  data.tar.gz: f3703bc27fce75391023a2e8ab056f721471f3e522326f4201fa98600f62f70b75e3fb9b7a5850208c395883746e5d8ee5d4bd0b0e847f4b1e25b101bdeb2a21

data/README.md

@@ -4,54 +4,202 @@ _An Image Filter DSL (duh)_
 
 [![Gem Version](https://badge.fury.io/rb/image_filter_dsl.svg)](https://badge.fury.io/rb/image_filter_dsl)
 
+{file:CHANGELOG.md Change Log}
+
 ## Features
 
 - DSL with customizable input and output variables, and a set of basic instructions
 - IO with serialization so Kernels can be written to binary files and loaded from binary files
 - Image Processor that generates image file by applying Filter Kernel to every pixel of input image (supports multi-threading)
 
-### Sample
+## DSL
 
-Define filter
+### Filter Block
+
+Using `ImageFilterDsl::Dsl::Filter`
 
 ```ruby
-swizzle = Filter.define [:r,:g,:b], [:r,:g,:b] do
-    copy [:g], :t # copy green to temp
-    copy [:r], :g # copy red to green
-    copy [:b], :r # copy blue to red
-    copy [:t], :b # copy temp (original green) to blue
+# - First array contains input variables
+# x, y, r, g, b, a, :width and :hght are automatically
+# populated by image filter process
+# - Second array contains output vars; r,g,b,a and optionally
+# x,y for images
+filter = Filter.define [:x,:y,:r,:g,:b], [:r,:g,:b] do 
+    # Instructions go here
+    # instruction [input(s)], output
+    add [:x,:r], :g
+
+    # output can be an existing symbol in out, or a custom one up to 5 letters 
+    # long (longer will be trimmed if serialized to a binary file)
+
+    # input can be any declared input or custom variable
 end
 ```
 
+### Instructions
+
+Basic Use:
+
+``instruction [argument1,argument2,...], :output_variable``
+
+__Math__
+
+- `add` add 2 or more input values, storing in output (<code>a+b</code>)
+
+    ```ruby
+    add [:r,5], :r # replace r with r + 5
+    ```
+
+- `mult` add 2 or more inputs, storing in out (<code>a*b</code>)
+
+    ```ruby 
+    mult [:r,2], :r # Replace r with r * 2
+     ```
+
+- `div` divide 2 inputs
+
+    ```ruby
+    div [:r, 2], :g # Write r/2 to g
+    ```
+
+- `mod` store modulo of two inputs in output
+
+    ```ruby
+        mod [2,4], :t # Write 2$4 (2) to t
+    ```
+
+- `abs` store absolute value of input in output
+
+    ```ruby
+        abs [-5], :r # Writes abs(5) to r
+    ```
+
+__Collection__
+
+- `min` store smallest of inputs in output (accepts 2 or more values)
+
+    ```ruby
+        min [:r,255,:g], :s # Writes smallest of r, 255 and g to s
+    ```
+
+- `max` store largest of inputs in output (accepts 2 or more values)
+
+    ```ruby
+        max [:r,0,:g], :s # Writes largest of r, 0 and g to s
+    ```
+
+- `avg` store average of inputs in output (accepts 2 or more values)
+
+    ```ruby
+        avg [:r,:g,:b], :ca # Writes (r+g+b)/3 to ca
+    ```
+
+
+__Logic/Conversion/Memory__
+
+- `above` choose one of two values based on greater than comparison (2 or 4 values) `[n1,n1,true_val,false_val]` (If not specified, `true_val` is 1 and `false_val` is 0)
+
+    ```ruby
+        # if r > g, store 0 in g, else store g in g (keep g the same)
+        above [:r,:g,0,:g], :g
+    ```
+
+- `below` choose one of two values based on less than comparison (2 or 4 values) `[n1,n1,true_val,false_val]` (If not specified, `true_val` is 1 and `false_val` is 0)
+
+    ```ruby
+        # if r < g, store 0 in r, else store r in r (keep r the same)
+        below [:r,:g,0,:r], :r
+    ```
+
+- `between` choose one of two values based on whether value is between two others (3 or 5 values) `[min,max,value,true_val,false_val]` (If not specified, `true_val` is 1 and `false_val` is 0)
+
+    ```ruby
+        # Returns value since val > 1 && val < 3
+        below [1,3,2], :r
+        # Returns 1 since -1 < 1
+        below [1,-1,5], :r
+    ```
+
+- `switch` choose one of two values based on condition value (1/1.0 = true, 0/0.0 = false) `[cond,true_val,false_val]`
+
+    ```ruby
+        # If c is true, store r in a, else store g in a
+        switch [:c,:r,:g], :a
+    ```
+
+- `eq` if two input values are equal, store 1, else 0 (_2 values_) (`[val1,val2]`)
+- `bnot` if input is 1 or 1.0, store 0, else 1 (_1 value_) (`[bool]`)
+- `band` if _all_ input values are 1 or 1.0, store 1, else 0 (_1+ values_) (`[val1,val2,...]`)
+- `bor` if _any_ input values are 1 or 1.0, store 1, else 0 (_1+ values_) (`[val1,val2,...]`)
+- `copy` copy input directly to output (`[src]`)
+- `ceil` nearest whole integer of input, rounded up (_1 value_) (`[val]`)
+- `floor` nearest whole integer of input, rounded down (_1 value_) (`[val]`)
+- `clamp` input clamped to be no less than min, no greater than max (`[min,max,val]`)
+- `float` cast input to float (_1 value_) (`[val]`)
+- `round` round first input value to second value decimals (`[value,decimal_count]`)
+- `mix` Mix two values together with a ratio (0*a + (1-r)*b) (`[ratio,a,b]`)
+
+    ```ruby
+        # store (0.3*r) + (0.7*g) in b
+        mix [0.3,:r,:g], :b
+    ```
+
+__Generators__
+
+- `rand` random float between min and max (`[min,max]`)
+- `sin` sine function on single value
+- `cos` cosine function on single value
+- `tan` tangent function on single value
+
+### Sample
+
+Define filter
+
+```
+    swizzle = Filter.define [:r,:g,:b], [:r,:g,:b] do
+        copy [:g], :t # copy green to temp
+        copy [:r], :g # copy red to green
+        copy [:b], :r # copy blue to red
+        copy [:t], :b # copy temp (original green) to blue
+    end
+```
+
 Optionally write filter kernal to binary file on disk
 
 ```ruby
-ImageFilterDsl::Engine::IO.write("./swizzle.ifdkk", swizzle)
+    ImageFilterDsl::Engine::IO.write("./swizzle.ifdk", swizzle)
 ```
 
 Use filter kernal to process image
 
 ```ruby
-# From binary kernal file
-processor = ImageFilterDsl::Engine::ImageProcessor.new('./swizzle.ifdk')
-# OR from filter object
-processor = ImageFilterDsl::Engine::ImageProcessor.new(swizzle)
-# or use aliases in main module
-processor = ImageFilterDsl.image_processor(swizzle)
-
-# Process image and store output
-processor.process_image('./my_source.png', './my_output.png')
+    # From binary kernal file
+    processor = ImageFilterDsl::Engine::ImageProcessor.new('./swizzle.ifdk')
+    # OR from filter object
+    processor = ImageFilterDsl::Engine::ImageProcessor.new(swizzle)
+    # or use aliases in main module
+    processor = ImageFilterDsl.image_processor(swizzle)
+
+    # Process image and store output
+    processor.process_image('./my_source.png', './my_output.png')
 ```
 
-- See `./sample_filters/samples.rb`
-- See Also: [image_filter_dsl_samples](https://bitbucket.org/WadeH/image_filter_dsl_samples/src/master/) for samples
+- See `./sample_filters/samples.rb` for sample filters
+- See Also: [image_filter_dsl_samples](https://bitbucket.org/WadeH/image_filter_dsl_samples/src/master/) for more samples
 
 ## Gem
 
 Either
+
 - Build into a gem using included `gemspec` file; includes CLI functionality
 - Install using gem with `gem install image_filter_dsl`
 
+## CLI
+
+Image Filter DSL can be made to process an image from a binary kernal using
+its CLI tool, `image_filter_dsl`
+
+- Usage: `image_filter_dsl <kernel_file> <image_in> <image_out>`
 
 ## License
 

data/bin/image_filter_dsl

@@ -2,9 +2,11 @@
 
 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
+# 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
+
+ImageFilterDsl::Engine::CLI.run

data/lib/image_filter_dsl.rb

@@ -5,7 +5,8 @@ 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'
-
+require_relative './image_filter_dsl/serialize.rb'
+require_relative './image_filter_dsl/engine/cli.rb'
 ##
 # Image Filter DSL Library
 # (c) 2018-2020 VDTDEV/Wade H. ~ MIT License

data/lib/image_filter_dsl/binary/struct.rb

@@ -22,7 +22,7 @@ module ImageFilterDsl
             # Constants used in header
             HEADER_VALUES = {
                 header: "ifdKernel",
-                version: 0.01
+                version: 0.02
             }
 
             ##

data/lib/image_filter_dsl/dsl/filter_instructions.rb

@@ -3,6 +3,8 @@
 # (c) 2018-2020 VDTDEV/Wade H. ~ MIT License
 # @author Wade H. <vdtdev.prod@gmail.com>
 module ImageFilterDsl
+    ##
+    # Module defining DSL
     module Dsl
         ##
         # Module defining filter kernel instruction logic
@@ -31,7 +33,17 @@ module ImageFilterDsl
                 round:  0xd6,
                 switch: 0xd7,
                 eq:     0xd8,
-                bnot:   0xd9
+                bnot:   0xd9,
+                mix:    0xda,
+                between: 0xdb,
+                clamp:  0xdc,
+                band:   0xdd,
+                bor:    0xde,
+                # generation
+                rand:   0xf0,
+                sin:    0xf1,
+                cos:    0xf2,
+                tan:    0xf3
             }
 
             ##
@@ -113,9 +125,11 @@ module ImageFilterDsl
         
             ##
             # Above instruction
-            # @param [Array] i input values (a,b,trueVal,falseVal)
+            # @param [Array] i input values `(a,b,trueVal,falseVal)`
+            #   `trueVal` defaults to `1`, `falseVal` defaults to `0`
             # @return [Integer|Float] output value
             def self.above(i)
+                i = [i,1,0].flatten if i.length == 2
                 if(i[0]>i[1])
                     if i.length < 3
                         1
@@ -133,9 +147,11 @@ module ImageFilterDsl
         
             ##
             # Below instruction
-            # @param [Array] i input values (a,b,trueVal,falseVal)
+            # @param [Array] i input values `(a,b,trueVal,falseVal)`
+            #   `trueVal` defaults to `1`, `falseVal` defaults to `0`
             # @return [Integer|Float] output value
             def self.below(i)
+                i = [i,1,0].flatten if i.length == 2
                 if(i[0]<i[1])
                     if i.length < 3
                         1
@@ -151,6 +167,28 @@ module ImageFilterDsl
                 end
             end
 
+            ##
+            # Between instruction (check if value is between two others)
+            # @param [Array] i input values `[min, max, value, trueVal, falseVal]`
+            #   `trueVal` defaults to `1`, `falseVal` defaults to `0`
+            # @return [Integer] 1 if true, 0 if false
+            def self.between(i)
+                i = [i,1,0].flatten if i.length == 3
+                a,b,v,t,f = i
+                r = (v>=a) && (v<=b)
+                (r)? t : f
+            end
+
+            ##
+            # Clamp value between a min and a max
+            # @param [Array] i input values `[min,max,val]`
+            # @return [Integer|Float] Value forced to be no greater than `max`
+            #   and no less than `min`
+            def self.clamp(i)
+                a,b,v = i
+                [b,[a,v].max].min
+            end
+
             ##
             # Floor instruction
             # @param [Array] i input value (v)
@@ -186,7 +224,7 @@ module ImageFilterDsl
             ##
             # 'Switch' instruction (basically if)
             #
-            # switch [condition (0/1/0.0/1.0), trueval, falseval]
+            # switch condition (0/1/0.0/1.0), trueval, falseval]
             # @param [Array] i input value (condition, true val, false val)
             # @return [Integer|Float] output value
             def self.switch(i)
@@ -220,6 +258,65 @@ module ImageFilterDsl
                     1
                 end
             end
+
+            ##
+            # Logical AND instruction
+            # @param [Array] i input values (ints or floats)
+            # @return [Integer] 1 if all values are `1` or `1.0`, else 0
+            def self.band(i)
+                (i.reduce(:+).to_i == i.length)? 1 : 0
+            end
+
+            ##
+            # Logical OR instruction
+            # @param [Array] i input values (ints or floats)
+            # @return [Integer] 1 if any values are `1` or `1.0`, else 0
+            def self.bor(i)
+                (i.reduce(:+).to_i > 0)? 1 : 0
+            end
+
+            ##
+            # Mix two values with a ratio
+            # @param [Array] i input values (ratio (0-1.0), a, b)
+            # @return [Float] output value of ((ratio*a) + ((1.0-ratio)*b))
+            def self.mix(i)
+                ratio, a, b = i
+                (ratio*a)+((1.0-ratio)*b)
+            end
+
+            ##
+            # Random number instruction
+            # @param [Array] i input values (min, max)
+            # @return [Float] Random number between min and max
+            def self.rand(i)
+                r=Random.new
+                min,max = i
+                (-min) + (r.rand * (max + min))
+            end
+
+            ##
+            # Sine function
+            # @param [Array] i input value to use sin on
+            # @return [Float] Sine of input value
+            def self.sin(i)
+                Math.sin(i[0])
+            end
+
+            ##
+            # Cosine function
+            # @param [Array] i input value to use cos on
+            # @return [Float] Cosine of input value
+            def self.cos(i)
+                Math.cos(i[0])
+            end
+
+            ##
+            # Tangent function
+            # @param [Array] i input value to use tan on
+            # @return [Float] Tangent of input value
+            def self.tan(i)
+                Math.tan(i[0])
+            end
         end
     end
 end

data/lib/image_filter_dsl/engine/cli.rb

@@ -0,0 +1,83 @@
+##
+# Image Filter DSL Library
+# (c) 2018-2020 VDTDEV/Wade H. ~ MIT License
+# @author Wade H. <vdtdev.prod@gmail.com>
+module ImageFilterDsl
+    module Engine
+        ##
+        # CLI Argument parser and handler module
+        module CLI
+            extend self
+
+            Options = Struct.new(:action, :filter, :input, :output)
+            RequiredArgs = {
+                process: [:filter, :input, :output],
+                compile: [:input, :output]
+            }
+
+            def parse(args)
+                opts = Options.new
+                args=args.map{|s|s.strip}
+
+                p = args[0]
+                
+                if !p.nil? && p.downcase == '--process'
+                    opts.action = :process
+                elsif !p.nil? && p.downcase == '--compile'
+                    opts.action = :compile
+                end
+
+                unless opts.action.nil?
+                    case opts.action
+                    when :process
+                        f,i,o = args[1..-1]
+                        opts.filter = f
+                        opts.input = i
+                        opts.output = o
+                    when :compile
+                        s,k = args[1..-1]
+                        opts.input = s
+                        opts.output = k
+                    end
+                end
+
+                return opts
+            end
+
+            def run()
+                options = parse(ARGV)
+                if options.action.nil?
+                    show_usage
+                else
+                    p options
+                    if RequiredArgs[options.action].select{|o| options[o].nil?}.length == 0
+                        do_action(options)
+                    else
+                        show_usage(options.action)
+                    end
+                end
+            end
+
+            def show_usage(action=nil)
+                if !action.nil?
+                    print "Invalid arguments for #{action.to_s}\n"
+                end
+                print [
+                    "Usage: image_filter_dsl <action<",
+                    "\t--process <kernel_file> <image in> <image out>\t\tProcess image with binary kernel",
+                    "\t--compile <source_file> <output_kernel>\t\tCompile given ruby source to binary kernel"
+                ].join("\n")
+                print "\n"
+            end
+
+            def do_action(opts)
+                if opts.action == :process
+                    ip = ImageFilterDsl.image_processor(opts.filter)
+                    ip.process_image(opts.input, opts.output)
+                elsif opts.action == :compile
+                    print "(Not yet implemented :)\n"
+                end
+            end
+        end
+    end
+end

data/lib/image_filter_dsl/engine/image_processor.rb

@@ -13,6 +13,8 @@ module ImageFilterDsl
 
             attr_accessor :kernel, :config
 
+
+
             ##
             # Constructor
             # @param [Dsl::Kernel::FilterKernel|String] filter_kernel FilterKernel object or path to binary kernel file
@@ -121,7 +123,6 @@ module ImageFilterDsl
                 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)

data/lib/image_filter_dsl/serialize.rb

@@ -0,0 +1,69 @@
+require_relative './serializers/common.rb'
+require_relative './serializers/msg_pack.rb'
+require_relative './serializers/json.rb'
+require_relative './serializers/yaml.rb'
+require_relative './serializers/intermediate.rb'
+##
+# Image Filter DSL Library
+# (c) 2018-2020 VDTDEV/Wade H. ~ MIT License
+# @author Wade H. <vdtdev.prod@gmail.com>
+module ImageFilterDsl
+    ##
+    # Module providing access to kernel serialization and 
+    # deserialization functionality. Actual serialization/deserialization
+    # logic defined in modules within `Serializers`
+    module Serialize
+        extend self
+        # include Serialize::Json
+        # include Serializers::Json
+
+        ##
+        # Intermediate serializer module
+        INTERMEDIATE = Serializers::Intermediate
+        
+        ##
+        # Available serializers, mapping format symbol to
+        # module
+        SERIALIZERS = {
+            json: Serializers::Json,
+            msgpack: Serializers::MsgPack,
+            yaml: Serializers::Yaml
+        }
+        ##
+        # Available serializer symbols
+        FORMATS = SERIALIZERS.keys
+
+        ##
+        # Serialize kernel, optionally using intermediate step
+        # @param [ImageFilterDsl::Dsl::Kernel] kernel Kernel
+        # @param [Symbol] format Format to serialize to from FORMATS, or
+        #   `nil` to convert to intermediate
+        # @return [Hash|String] serialized kernel 
+        def from_kernel(kernel, format=nil)
+            i = INTERMEDIATE.from_kernel(kernel)
+            if format.nil?
+                return i
+            else
+                m = SERIALIZERS[format]
+                return m.send(:serialize, i)
+            end
+        end
+
+        ##
+        # Deserialize to kernel, optionally using intermediate step
+        # @param [Hash|String] data Serialized data
+        # @param [Symbol] format Format to convert from from FORMATS, or
+        #   `nil` to convert from intermediate
+        # @return [Kernel] Kernal from deserialization
+        def to_kernel(data,format=nil)
+            if format.nil?
+                return INTERMEDIATE.to_kernel(data)
+            else
+                i = SERIALIZERS[format].send(:deserialize, data)
+                return INTERMEDIATE.to_kernel(i)
+            end
+        end        
+    end
+end
+            
+

data/lib/image_filter_dsl/serializers/common.rb

@@ -0,0 +1,57 @@
+#
+# Image Filter DSL Library
+# (c) 2018-2020 VDTDEV/Wade H. ~ MIT License
+# @author Wade H. <vdtdev.prod@gmail.com>
+module ImageFilterDsl
+    module Serializers
+        ##
+        # Common helper methods for serializers; Include in serializer modules
+        # with `include Common`
+        module Common
+            extend self
+            ##
+            # Normalize symbol/value, stripping out
+            # any colons and converting to symbol; Non strings
+            # are returned unaltered; if array, logic is applied to all items
+            # @param [String|Number|Symbol|Array] val
+            # @return [Symbol|Number|Array] Normalized value
+            def normalize_sym(val)
+                if val.is_a?(String)
+                    val.gsub(':','').to_sym
+                elsif val.is_a?(Array)
+                    val.map{|v|normalize_sym(v)}
+                else
+                    val
+                end
+            end
+            ##
+            # 'Fix' hash, converting keys to symbols (if keys provided)
+            # and converting values/arrays of values so any strings are 
+            # normalized and cast to symbols using {normalize_sym}
+            # @param [Hash] hash Hash to fix
+            # @param [Array] keys Optional array of key symbols to check for and
+            #   convert string equivalents over to symbols if found
+            # @return [Hash] Fixed copy of input hash
+            def fix_hash(hash,keys=[])
+                h2=hash.dup
+                unless keys.length == 0
+                    keys.each do |k|
+                        if !h2.has_key?(k) && h2.has_key?(k.to_s)
+                            h2[k] = h2[k.to_s]
+                            h2.delete k.to_s
+                        end
+                    end
+                end
+                h2.keys.each do |k|
+                    if h2[k].is_a?(Array)
+                        h2[k] = h2[k].map{|v|normalize_sym(v)}
+                    else
+                        h2[k] = normalize_sym(h2[k])
+                    end
+                end
+                return h2
+            end
+        end
+    end
+end
+

data/lib/image_filter_dsl/serializers/intermediate.rb

@@ -0,0 +1,65 @@
+##
+# Image Filter DSL Library
+# (c) 2018-2020 VDTDEV/Wade H. ~ MIT License
+# @author Wade H. <vdtdev.prod@gmail.com>
+module ImageFilterDsl
+    ##
+    # Kernel data serializers
+    module Serializers
+        ##
+        # Provides serialization/deserialization for Kernels
+        # to an intermediate format representing kernel as hash.
+        # Used by other serializers as intermediate between serializing
+        # from and deserializing to kernels
+        module Intermediate
+            include Common
+            extend self
+            ##
+            # Convert kernel to intermediate hash struct
+            # @param [ImageFilterDsl::Dsl::Kernel] kernel Source kernel
+            # @return [Hash] Intermediate hash version of kernel
+            def from_kernel(kernel)
+                data = {
+                    inputs: kernel.inputs,
+                    outputs: kernel.outputs
+                }
+                data[:instructions] = kernel.instructions.map do |i|
+                    {op: i.op, in: i.inputs, out: i.out}
+                end
+                data
+            end
+
+            ##
+            # Convert intermediate kernel hash to kernel object
+            # @param [Hash] data Intermediate kernel data
+            # @return [ImageFilterDsl::Dsl::Kernel] Constructed kernel
+            def to_kernel(data)
+                ins = data[:instructions].map{|i| fix_instruction_symbols(i) }
+                filt = ImageFilterDsl::Dsl::Filter.define(data[:inputs],data[:outputs]) do
+                    ins.each do |i|
+                        send(i[:op], i[:in], i[:out])
+                    end
+                end
+                return filt
+            end
+
+            private
+
+            def fix_instruction_symbols(ins_hash)
+                fix_hash(ins_hash,[:op,:in,:out])
+                # r_k=Proc.new {|k| (ins_hash.has_key?(k))? k : k.to_s}
+                # op_h = r_k.call(:op)
+                # in_h = r_k.call(:in)
+                # out_h = r_k.call(:out)
+                # norm_sym = Proc.new {|s| (s.is_a?(String))? s.gsub(':','').to_sym : s}
+                # {
+                #     op: norm_sym.call(ins_hash[op_h]),
+                #     in: ins_hash[in_h].map { |i|
+                #         norm_sym.call(i)
+                #     },
+                #     out: norm_sym.call(ins_hash[out_h])
+                # }
+            end
+        end
+    end
+end

data/lib/image_filter_dsl/serializers/json.rb

@@ -0,0 +1,43 @@
+require 'json'
+##
+# Image Filter DSL Library
+# (c) 2018-2020 VDTDEV/Wade H. ~ MIT License
+# @author Wade H. <vdtdev.prod@gmail.com>
+module ImageFilterDsl
+    module Serializers
+        ##
+        # Provides serialization/deserialization to/from JSON using
+        # intermediate serializer
+        module Json
+            include Common
+            extend self
+            ##
+            # Serialize kernel to JSON string
+            # @param [Hash] kernel Kernel in intermediate format
+            # @return [String] JSON serialized version of kernel
+            def serialize(kernel)
+                {
+                    header: ImageFilterDsl::Binary::Struct::HEADER_VALUES,
+                    inputs: kernel[:inputs],
+                    outputs: kernel[:outputs],
+                    instructions: kernel[:instructions]
+                }.to_json
+            end
+            ##
+            # Deserialize JSON kernel to intermediate format
+            # @param [String] data JSON kernel data
+            # @return [Hash] Intermediate format of kernel data
+            def deserialize(data)
+                data = JSON.load(data)
+                data = fix_hash(data,[:inputs,:outputs,:instructions])
+                data[:instructions] = data[:instructions].map {|i| fix_hash(i,[:op,:in,:out])}
+                
+                {
+                    inputs: data[:inputs],
+                    outputs: data[:outputs],
+                    instructions: data[:instructions]
+                }
+            end
+        end
+    end
+end

data/lib/image_filter_dsl/serializers/msg_pack.rb

@@ -0,0 +1,51 @@
+require 'msgpack'
+##
+# Image Filter DSL Library
+# (c) 2018-2020 VDTDEV/Wade H. ~ MIT License
+# @author Wade H. <vdtdev.prod@gmail.com>
+module ImageFilterDsl
+    module Serializers
+        ##
+        # Provides serialization/deserialization to/from MessagePack strings 
+        # using intermediate serializer
+        module MsgPack
+            include Common
+            extend self
+            ##
+            # 'Header' added to start of array packed with MsgPack
+            HEADER = ['mp',ImageFilterDsl::Binary::Struct::HEADER_VALUES.values].flatten
+            ##
+            # Serialize kernel to MessagePack string
+            # @param [Hash] kernel Kernel in intermediate format
+            # @return [String] MessagePack serialized version of kernel
+            def serialize(kernel)
+                [
+                    HEADER,
+                    kernel[:inputs],
+                    kernel[:outputs],
+                    kernel[:instructions].map do |i|
+                        [i[:op],i[:in],i[:out]]
+                    end
+                ].to_msgpack
+            end
+            ##
+            # Deserialize MessagePack kernel to intermediate format
+            # @param [String] data MessagePack kernel data
+            # @return [Hash] Intermediate format of kernel data
+            def deserialize(data)
+                data = MessagePack.unpack(data)
+                head,inps,outs,ins=data
+                d = {
+                    inputs: normalize_sym(inps),
+                    outputs: normalize_sym(outs),
+                    instructions: ins.map do |i|
+                        op,iin,iout=i
+                        fix_hash({op: op, in: iin, out: iout})
+                    end
+                }
+                
+                return d
+            end
+        end
+    end
+end

data/lib/image_filter_dsl/serializers/yaml.rb

@@ -0,0 +1,42 @@
+require 'yaml'
+##
+# Image Filter DSL Library
+# (c) 2018-2020 VDTDEV/Wade H. ~ MIT License
+# @author Wade H. <vdtdev.prod@gmail.com>
+module ImageFilterDsl
+    module Serializers
+        ##
+        # Provides serialization/deserialization to/from YAML using
+        # intermediate serializer
+        module Yaml
+            include Common
+            extend self
+            ##
+            # Serialize kernel to YAML string
+            # @param [Hash] kernel Kernel in intermediate format
+            # @return [String] YAML serialized version of kernel
+            def serialize(kernel)
+                {
+                    header: ImageFilterDsl::Binary::Struct::HEADER_VALUES,
+                    inputs: kernel[:inputs],
+                    outputs: kernel[:outputs],
+                    instructions: kernel[:instructions]
+                }.to_yaml
+            end
+            ##
+            # Deserialize YAML kernel to intermediate format
+            # @param [String] data YAML kernel data
+            # @return [Hash] Intermediate format of kernel data
+            def deserialize(data)
+                data = YAML.load(data)
+                data = fix_hash(data,[:inputs,:outputs,:instructions])
+                data[:instructions] = data[:instructions].map {|i| fix_hash(i,[:op,:in,:out])}
+                {
+                    inputs: data[:inputs],
+                    outputs: data[:outputs],
+                    instructions: data[:instructions]
+                }
+            end
+        end
+    end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: image_filter_dsl
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.1
 platform: ruby
 authors:
 - Wade H.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-02 00:00:00.000000000 Z
+date: 2020-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chunky_png
@@ -89,13 +89,21 @@ files:
 - 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/cli.rb
 - lib/image_filter_dsl/engine/image_processor.rb
 - lib/image_filter_dsl/engine/io.rb
+- lib/image_filter_dsl/serialize.rb
+- lib/image_filter_dsl/serializers/common.rb
+- lib/image_filter_dsl/serializers/intermediate.rb
+- lib/image_filter_dsl/serializers/json.rb
+- lib/image_filter_dsl/serializers/msg_pack.rb
+- lib/image_filter_dsl/serializers/yaml.rb
 homepage: https://bitbucket.org/WadeH/image_filter_dsl
 licenses:
 - MIT
 metadata:
   source_code_uri: https://bitbucket.org/WadeH/image_filter_dsl
+  documentation_uri: https://rubydoc.info/gems/image_filter_dsl/0.1.1
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -111,8 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.8
+rubygems_version: 3.0.0
 signing_key: 
 specification_version: 4
 summary: Image Filter DSL