image_filter_dsl 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11cb37a368d81f59215c62674f34ede4fa48628aec1836cb42d70529afca1fab
-  data.tar.gz: e3a48733e741052828f1a894179990fb2aa964b0f5964ccce2db5650f2667cd6
+  metadata.gz: f36219d0037d3f5d26ca5d4aa9c06465964094c89afe256ad3d79e63dda611d6
+  data.tar.gz: 310be0964d3c2f293b43c2022437effbdefa1df00588d27b36743642c0502ac8
 SHA512:
-  metadata.gz: cc94cd228532001187ce242a1aa266ac7cf0281166fa74e61b939773f385c6d89f5e3a0136d4e33c595211d4427f679103e43eda87cdf73cee460b573d3fd584
-  data.tar.gz: a7c47d86d6487be190bc0b73589d0562a43a769cbca2c8a8cb1301d7e4c5bc099373d1c8f35a138afe4a77b63035236b3bf150dc00eb382c214ef3584a4ec0b2
+  metadata.gz: db69c17700799b782c73169fab41f56fcec07ba2695dcb15815eb8aa53944bc65af5684205a09f0bdc99164e01a6e24939fb15603375fd0cfc2991422bdcfa7a
+  data.tar.gz: 9b765299f432bab3d67d40ce3e29568461409ec83b394cb248979b4826d73dfe5e9a4c04d4a52c69208d73e4bcf863fe224d61029f5379d235eaae0d2bf89457

data/README.md

@@ -4,48 +4,175 @@ _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)
 
+## DSL
+
+### Filter Block
+
+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
+
+
+### 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 (4 values) `[n1,n1,true_val,false_val]`
+
+    ```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]`
+
+    ```ruby
+        # if r < g, store 0 in r, else store r in r (keep r the same)
+        below [:r,:g,0,:r], :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 (`[val1,val2]`)
+- `bnot` if input is 1 or 1.0, store 0, else 1 (`[bool]`)
+- `copy` copy input directly to output (`[src]`)
+- `ceil` nearest whole integer of input, rounded up (`[val]`)
+- `float` cast input to float (`[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
 
-```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
-```
+<!--```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
-ImageFilterDsl::Engine::IO.write("./swizzle.ifdkk", swizzle)
-```
+<!--```ruby-->
+    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')
-```
-
-- See {ImageFilterDsl::Dsl} for instruction overview (or go directly to {file:docs/dsl.md DSL summary} )
-- See `./sample_filters/samples.rb`
-- See Also: [image_filter_dsl_samples](https://bitbucket.org/WadeH/image_filter_dsl_samples/src/master/) for samples
+<!--```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')
+<!--```-->
+
+- 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
 

data/lib/image_filter_dsl/dsl/filter_instructions.rb

@@ -5,7 +5,7 @@
 module ImageFilterDsl
     ##
     # Module defining DSL
-    # {include:file:docs/dsl.md}
+    # {include:file:dsl.md}
     module Dsl
         ##
         # Module defining filter kernel instruction logic
@@ -37,7 +37,10 @@ module ImageFilterDsl
                 bnot:   0xd9,
                 mix:    0xda,
                 # generation
-                rand:   0xe0
+                rand:   0xf0,
+                sin:    0xf1,
+                cos:    0xf2,
+                tan:    0xf3
             }
 
             ##
@@ -192,7 +195,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)
@@ -245,6 +248,30 @@ module ImageFilterDsl
                 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: image_filter_dsl
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Wade H.
@@ -96,6 +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
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -111,7 +112,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubyforge_project: 
+rubygems_version: 2.7.8
 signing_key: 
 specification_version: 4
 summary: Image Filter DSL