image_filter_dsl 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64f070bf94d94ef0c6e0de6a78fa7ccd8f29f181e866d4aa374f26a4e427f18f
-  data.tar.gz: 6347c8d1b350387e369e2e56d023f0fa944dd70a4870035af55619287e11bd7f
+  metadata.gz: b3c5ec517d5379d54dcac83356f816f4e460ea651956600c4a406766483fff9e
+  data.tar.gz: a26273761002413d8f2944fce7c6d9da591a3b3124be8a640f9c375a029df739
 SHA512:
-  metadata.gz: a8c55bf124bf7e454021ec8b644373566467eeec81786875bc9fa4d89ee0fa86e7e7044c71c83aa0396a3e97c7b0347d3cdd55e952e98c256c02b9f48a524d4e
-  data.tar.gz: 4590228397df810c7b75a5c59c1a4a1510e4e7ce723dd36e168f7a9f377dc6decf1b434cdca926e0c6ecc7a4196dae96b7ba6d0beda91b3743994b6e96bd910d
+  metadata.gz: 573236b32a4096fe6d8e57106cf9e4e79e9c4571583d0b9d1ceb710e8cb2dd227cadc51597bd5d8751fd55efd86ee4038207598833a38f3f41da8d8e3c9b5e47
+  data.tar.gz: f3703bc27fce75391023a2e8ab056f721471f3e522326f4201fa98600f62f70b75e3fb9b7a5850208c395883746e5d8ee5d4bd0b0e847f4b1e25b101bdeb2a21

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/dsl/filter_instructions.rb

@@ -5,7 +5,6 @@
 module ImageFilterDsl
     ##
     # Module defining DSL
-    # {include:file:dsl.md}
     module Dsl
         ##
         # Module defining filter kernel instruction logic

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/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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: image_filter_dsl
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Wade H.
@@ -89,14 +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.0
+  documentation_uri: https://rubydoc.info/gems/image_filter_dsl/0.1.1
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -112,7 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.0.0
 signing_key: 
 specification_version: 4
 summary: Image Filter DSL