sparkle_motion 0.1.0

data/lib/sparkle_motion/lazy_request_config.rb

@@ -0,0 +1,87 @@
+module SparkleMotion
+  # Evil hack to convince Curb to grab simulation-based information as late as
+  # possible, to undo the temporal skew that comes from updating the simulation
+  # then spending a bunch of time feeding updates to lights.
+  class LazyRequestConfig
+    GLOBAL_HISTORY = []
+    # TODO: Transition should be updated late as well...
+    def initialize(logger, config, url, results = nil, debug: nil, &callback)
+      @logger     = logger
+      @config     = config
+      @url        = url
+      @results    = results
+      @callback   = callback
+      @fixed      = create_fixed(url)
+      @debug      = debug
+    end
+
+    def each(&block)
+      EASY_OPTIONS.each do |kv|
+        block.call(kv)
+      end
+    end
+
+    def delete(field)
+      return @fixed[field] if @fixed.key?(field)
+      if field == :put_data
+        tmp = Oj.dump(@callback.call)
+        journal("BEGIN", body: tmp)
+        return tmp
+      end
+
+      @logger.error { "Request for unknown field: `#{field}`!  Has Curb changed internally?" }
+      nil
+    end
+
+  protected
+
+    def error(msg); "#{@config['name']}; #{@url}: #{msg}"; end
+    def overloaded(easy); error("Bridge overloaded: #{easy.body}"); end
+    def unknown_error(easy); error("Unknown error: #{easy.response_code}, #{easy.body}"); end
+    def hard_timeout(_easy); error("Request timed out."); end
+    def soft_timeout(easy); error("Failed updating light: #{easy.body}"); end
+
+    def create_fixed(url)
+      # TODO: Maybe skip per-event callbacks and go for single handler?
+      { url:         url,
+        method:      :put,
+        headers:     nil,
+        on_failure:  proc { |easy, _| failure!(easy) },
+        on_success:  proc { |easy| success!(easy) },
+        on_progress: nil,
+        on_debug:    nil,
+        on_body:     nil,
+        on_header:   nil }
+    end
+
+    def journal(stage, easy)
+      return unless @debug
+      GLOBAL_HISTORY << "#{Time.now.to_f},#{stage},#{@url},#{easy.try(:body_str)}"
+    end
+
+    def failure!(easy)
+      journal("END", easy)
+      case easy.response_code
+      when 404  # Hit Bridge hardware limit.
+        @results.failure!(overloaded(easy)) if @results
+      when 0    # Hit timeout.
+        @results.hard_timeout!(hard_timeout(easy)) if @results
+      else
+        @results.failure!(unknown_error(easy))
+      end
+    end
+
+    def success!(easy)
+      journal("END", easy)
+      if easy.body =~ /error/
+        # TODO: Check the error type field to be sure, and handle accordingly.
+
+        # Hit bridge rate limit / possibly ZigBee
+        # limit?.
+        @results.soft_timeout!(soft_timeout(easy)) if @results
+      else
+        @results.success! if @results
+      end
+    end
+  end
+end

data/lib/sparkle_motion/node.rb

@@ -0,0 +1,80 @@
+# TODO: Namespacing/classes/etc!
+
+module SparkleMotion
+  # Base class representing the state of an ordered set of lights, with an ability to debug
+  # things via PNG dump.
+  class Node
+    FRAME_PERIOD  = 0.04
+    DEBUG_SCALE   = Vector2.new(x: 2, y: 1)
+
+    attr_accessor :history, :debug, :lights
+
+    def initialize(lights:)
+      @lights   = lights
+      @state    = Array.new(@lights)
+      lights.times do |n|
+        @state[n] = 0.0
+      end
+    end
+
+    def debug=(val)
+      @debug = val
+      @history ||= [] if @debug
+    end
+
+    def [](n); @state[n]; end
+    def []=(n, val); @state[n] = val; end
+
+    def update(t)
+      return unless @debug
+      prev_t  = @history.last
+      prev_t  = prev_t ? prev_t[:t] : t
+      @history << { t:     t,
+                    dt:    t - prev_t,
+                    state: (0..(@lights - 1)).map { |n| self[n] } }
+    end
+
+    def snapshot_to!(fname)
+      enrich_history!
+      png = new_image
+      history.inject(0) do |y, snapshot|
+        next_y = y + (snapshot[:y] || 0)
+        colors = snapshot[:state].map { |z| to_color(z) }
+        (y..(next_y - 1)).each do |yy|
+          colors.each_with_index do |c, x|
+            x1 = (x * DEBUG_SCALE.x).to_i
+            x2 = ((x + 1) * DEBUG_SCALE.x).to_i - 1
+            (x1..x2).each do |xx|
+              png[xx, yy] = c
+            end
+          end
+        end
+        next_y
+      end
+      png.save(fname, interlace: false)
+    end
+
+  protected
+
+    def new_image
+      require "oily_png" unless defined?(::ChunkyPNG)
+      ChunkyPNG::Image.new((@lights * DEBUG_SCALE.x).to_i,
+                           history.map { |sn| sn[:y] }.inject(0) { |a, e| (a || 0) + e },
+                           ChunkyPNG::Color::TRANSPARENT)
+    end
+
+    def enrich_history!
+      @history.each do |snapshot|
+        frames       = snapshot[:dt] * (1 / FRAME_PERIOD) # A "frame" == fixed update interval, ms.
+        elapsed      = (frames * DEBUG_SCALE.y).round.to_i
+        snapshot[:y] = (elapsed > 0) ? elapsed : DEBUG_SCALE.y.to_i
+      end
+    end
+
+    def to_color(val)
+      # Based on precision of Hue API...
+      z = (val * 254).to_i
+      ChunkyPNG::Color.rgba(z, z, z, 255)
+    end
+  end
+end

data/lib/sparkle_motion/nodes/generator.rb

@@ -0,0 +1,8 @@
+module SparkleMotion
+  module Nodes
+    # A sub-class of `Node` for any node that operates as the root of a DAG, rather than as a
+    # transform.
+    class Generator < Node
+    end
+  end
+end

data/lib/sparkle_motion/nodes/generators/const.rb

@@ -0,0 +1,15 @@
+module SparkleMotion
+  module Nodes
+    module Generators
+      # For debugging, output 1.0 all the time.
+      class Const < Generator
+        def initialize(lights:, value: 1.0)
+          super(lights: lights)
+          @lights.times do |n|
+            self[n] = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sparkle_motion/nodes/generators/perlin.rb

@@ -0,0 +1,26 @@
+require "perlin_noise"
+
+module SparkleMotion
+  module Nodes
+    module Generators
+      # Manage and run a Perlin-noise based simulation.
+      #
+      # TODO: Play with octaves / persistence, etc.
+      class Perlin < Generator
+        def initialize(lights:, speed:)
+          super(lights: lights)
+          @speed  = speed
+          # TODO: See if we need/want to tinker with the `interval` option...
+          @perlin = ::Perlin::Noise.new(2, seed: 0)
+        end
+
+        def update(t)
+          @lights.times do |n|
+            self[n] = @perlin[n * @speed.x, t * @speed.y]
+          end
+          super(t)
+        end
+      end
+    end
+  end
+end

data/lib/sparkle_motion/nodes/generators/wave2.rb

@@ -0,0 +1,20 @@
+module SparkleMotion
+  module Nodes
+    module Generators
+      # Manage and run a simulation of just `sin(x + y)`.
+      class Wave2 < Generator
+        def initialize(lights:, speed:)
+          super(lights: lights)
+          @speed = speed
+        end
+
+        def update(t)
+          @lights.times do |n|
+            self[n] = (Math.sin((n * @speed.x) + (t * @speed.y)) * 0.5) + 0.5
+          end
+          super(t)
+        end
+      end
+    end
+  end
+end

data/lib/sparkle_motion/nodes/transform.rb

@@ -0,0 +1,34 @@
+module SparkleMotion
+  module Nodes
+    # A sub-class of `Node` for any node that operates as a transform, rather than as a root node.
+    #
+    # Sub-classes should override `update(t)` and call it like so:
+    #
+    # ```ruby
+    # def update(t)
+    #   super(t) do |x|
+    #     # calculate value for light `x` from `@source[x]` here.
+    #   end
+    # end
+    # ```
+    class Transform < Node
+      def initialize(source:, mask: nil)
+        super(lights: source.lights)
+        @source = source
+        @mask   = mask
+      end
+
+      def update(t)
+        @source.update(t)
+        if block_given?
+          (0..(@lights - 1)).each do |x|
+            # Apply to all lights if no mask, and apply to specific lights if mask.
+            apply_transform = !@mask || @mask[x]
+            @state[x]       = apply_transform ? yield(x) : @source[x]
+          end
+        end
+        super(t)
+      end
+    end
+  end
+end

data/lib/sparkle_motion/nodes/transforms/contrast.rb

@@ -0,0 +1,20 @@
+module SparkleMotion
+  module Nodes
+    module Transforms
+      # Transform values from 0..1 into a new range.
+      class Contrast < Transform
+        def initialize(function:, iterations:, source:, mask: nil)
+          super(source: source, mask: mask)
+          function  = Perlin::Curve.const_get(function.to_s.upcase)
+          @contrast = Perlin::Curve.contrast(function, iterations.to_i)
+        end
+
+        def update(t)
+          super(t) do |x|
+            @contrast.call(@source[x])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sparkle_motion/nodes/transforms/range.rb

@@ -0,0 +1,41 @@
+module SparkleMotion
+  module Nodes
+    module Transforms
+      # Transform values from 0..1 into a new range.
+      #
+      # TODO: Allow change to range to apply over time?
+      class Range < Transform
+        def initialize(mid_point:, delta:, source:, mask: nil, logger:)
+          super(source: source, mask: mask)
+          @logger = logger
+          set_range(mid_point, delta)
+        end
+
+        def update(t)
+          super(t) do |x|
+            (@source[x] * (@max - @min)) + @min
+          end
+        end
+
+        def set_range(mid_point, delta)
+          @min = clamp("min", mid_point, delta, (mid_point - delta).round)
+          @max = clamp("max", mid_point, delta, (mid_point + delta).round)
+        end
+
+      protected
+
+        def clamp(name, mid_point, delta, val)
+          if val < 0
+            @logger.warn { "Bad range [#{mid_point} +/- #{delta}] - #{name} was <0! (#{val})" }
+            val = 0
+          end
+          if val > 255
+            @logger.warn { "Bad range [#{mid_point} +/- #{delta}] - #{name} was >255! (#{val})" }
+            val = 255
+          end
+          val
+        end
+      end
+    end
+  end
+end

data/lib/sparkle_motion/nodes/transforms/spotlight.rb

@@ -0,0 +1,35 @@
+module SparkleMotion
+  module Nodes
+    module Transforms
+      # Spotlight a particular point on the line.
+      #
+      # TODO: Integrate the underlying light value but ensure we contrast-stretch
+      # TODO: to ensure a bright-enough spotlight over the destination.  Maybe a LERP?
+      #
+      # TODO: Allow effect to come in / go out over time.
+      class Spotlight < Transform
+        def initialize(source:, mask: nil)
+          super(source: source, mask: mask)
+          @spotlight = nil
+        end
+
+        def spotlight!(x)
+          @spotlight = x
+        end
+
+        def clear!; @spotlight = nil; end
+
+        def update(t)
+          super(t) do |x|
+            val = @source[x]
+            if @spotlight
+              falloff   = 0.9**((@spotlight - x).abs**3)
+              val       = falloff
+            end
+            val
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sparkle_motion/output.rb

@@ -0,0 +1,69 @@
+# TODO: Namespacing/classes/etc!
+def announce_iteration_config(iters)
+  SparkleMotion.logger.unknown do
+    if iters > 0
+      "Running for #{iters} iterations."
+    else
+      "Running until we're killed.  Send SIGHUP to terminate with stats."
+    end
+  end
+end
+
+def format_float(num); num ? num.round(2) : "-"; end
+
+def format_rate(rate); "#{format_float(rate)}/sec"; end
+
+def print_stat(name, value, rate)
+  SparkleMotion.logger.unknown { "* #{value} #{name} (#{format_rate(rate)})" }
+end
+
+STATS = [
+  ["requests",       :requests,      :requests_sec],
+  ["successes",      :successes,     :successes_sec],
+  ["failures",       :failures,      :failures_sec],
+  ["hard timeouts",  :hard_timeouts, :hard_timeouts_sec],
+  ["soft timeouts",  :soft_timeouts, :soft_timeouts_sec],
+]
+
+def print_basic_stats(results)
+  STATS.each do |(name, count, rate)|
+    print_stat(name, results.send(count), results.send(rate))
+  end
+end
+
+def print_other_stats(results)
+  SparkleMotion.logger.unknown { "* #{format_float(results.failure_rate)}% failure rate" }
+  suffix = " (#{format_float(results.elapsed / ITERATIONS.to_f)}/iteration)" if ITERATIONS > 0
+  SparkleMotion.logger.unknown { "* #{format_float(results.elapsed)} seconds elapsed#{suffix}" }
+end
+
+# TODO: Show per-bridge and aggregate stats.
+def print_results(results)
+  SparkleMotion.logger.unknown { "Results:" }
+  print_basic_stats(results)
+  print_other_stats(results)
+end
+
+def dump_node_debug_data!(prefix)
+  nodes_under_debug.each_with_index do |(name, node), index|
+    node.snapshot_to!("tmp/%s_%02d_%s.png" % [prefix, index, name.downcase])
+  end
+end
+
+def dump_output_debug_data!(prefix)
+  return unless DEBUG_FLAGS["OUTPUT"] && USE_LIGHTS
+  File.open("tmp/#{prefix}_output.raw", "w") do |fh|
+    fh.write(SparkleMotion::LazyRequestConfig::GLOBAL_HISTORY.join("\n"))
+    fh.write("\n")
+  end
+end
+
+def dump_debug_data!
+  return unless debugging?
+  prefix = "%010.0f" % Time.now.to_f
+
+  SparkleMotion.logger.unknown { "Dumping debug and/or profiling data to `tmp/#{prefix}_*`." }
+  stop_ruby_prof!
+  dump_node_debug_data!(prefix)
+  dump_output_debug_data!(prefix)
+end