image_filter_dsl 0.0.6 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f36219d0037d3f5d26ca5d4aa9c06465964094c89afe256ad3d79e63dda611d6
-  data.tar.gz: 310be0964d3c2f293b43c2022437effbdefa1df00588d27b36743642c0502ac8
+  metadata.gz: 64f070bf94d94ef0c6e0de6a78fa7ccd8f29f181e866d4aa374f26a4e427f18f
+  data.tar.gz: 6347c8d1b350387e369e2e56d023f0fa944dd70a4870035af55619287e11bd7f
 SHA512:
-  metadata.gz: db69c17700799b782c73169fab41f56fcec07ba2695dcb15815eb8aa53944bc65af5684205a09f0bdc99164e01a6e24939fb15603375fd0cfc2991422bdcfa7a
-  data.tar.gz: 9b765299f432bab3d67d40ce3e29568461409ec83b394cb248979b4826d73dfe5e9a4c04d4a52c69208d73e4bcf863fe224d61029f5379d235eaae0d2bf89457
+  metadata.gz: a8c55bf124bf7e454021ec8b644373566467eeec81786875bc9fa4d89ee0fa86e7e7044c71c83aa0396a3e97c7b0347d3cdd55e952e98c256c02b9f48a524d4e
+  data.tar.gz: 4590228397df810c7b75a5c59c1a4a1510e4e7ce723dd36e168f7a9f377dc6decf1b434cdca926e0c6ecc7a4196dae96b7ba6d0beda91b3743994b6e96bd910d

data/README.md

@@ -18,23 +18,23 @@ _An Image Filter DSL (duh)_
 
 Using `ImageFilterDsl::Dsl::Filter`
 
-
-    # - 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
-
+```ruby
+# - 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
 
@@ -47,19 +47,19 @@ __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
+    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
+    mult [:r,2], :r # Replace r with r * 2
      ```
 
 - `div` divide 2 inputs
 
     ```ruby
-        div [:r, 2], :g # Write r/2 to g
+    div [:r, 2], :g # Write r/2 to g
     ```
 
 - `mod` store modulo of two inputs in output
@@ -97,20 +97,29 @@ __Collection__
 
 __Logic/Conversion/Memory__
 
-- `above` choose one of two values based on greater than comparison (4 values) `[n1,n1,true_val,false_val]`
+- `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 (4 values) `[n1,n1,true_val,false_val]`
+- `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
@@ -118,11 +127,15 @@ __Logic/Conversion/Memory__
         switch [:c,:r,:g], :a
     ```
 
-- `eq` if two input values are equal, store 1, else 0 (`[val1,val2]`)
-- `bnot` if input is 1 or 1.0, store 0, else 1 (`[bool]`)
+- `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 (`[val]`)
-- `float` cast input to float (`[val]`)
+- `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]`)
 
@@ -142,24 +155,24 @@ __Generators__
 
 Define 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
     end
-<!--```-->
+```
 
 Optionally write filter kernal to binary file on disk
 
-<!--```ruby-->
+```ruby
     ImageFilterDsl::Engine::IO.write("./swizzle.ifdk", swizzle)
-<!--```-->
+```
 
 Use filter kernal to process image
 
-<!--```ruby-->
+```ruby
     # From binary kernal file
     processor = ImageFilterDsl::Engine::ImageProcessor.new('./swizzle.ifdk')
     # OR from filter object
@@ -169,7 +182,7 @@ Use filter kernal to process image
 
     # Process image and store output
     processor.process_image('./my_source.png', './my_output.png')
-<!--```-->
+```
 
 - 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

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

@@ -36,6 +36,10 @@ module ImageFilterDsl
                 eq:     0xd8,
                 bnot:   0xd9,
                 mix:    0xda,
+                between: 0xdb,
+                clamp:  0xdc,
+                band:   0xdd,
+                bor:    0xde,
                 # generation
                 rand:   0xf0,
                 sin:    0xf1,
@@ -122,9 +126,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
@@ -142,9 +148,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
@@ -160,6 +168,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)
@@ -230,6 +260,22 @@ module ImageFilterDsl
                 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)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: image_filter_dsl
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.1.0
 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
@@ -96,7 +96,7 @@ licenses:
 - MIT
 metadata:
   source_code_uri: https://bitbucket.org/WadeH/image_filter_dsl
-  documentation_uri: https://rubydoc.info/gems/image_filter_dsl/0.0.6
+  documentation_uri: https://rubydoc.info/gems/image_filter_dsl/0.1.0
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -112,8 +112,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.1
 signing_key: 
 specification_version: 4
 summary: Image Filter DSL