fusuma 2.0.0.pre → 2.0.3

data/lib/fusuma/plugin/buffers/timer_buffer.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative './buffer.rb'
+require_relative './buffer'
 
 module Fusuma
   module Plugin
@@ -12,8 +12,8 @@ module Fusuma
 
         def config_param_types
           {
-            'source': [String],
-            'seconds_to_keep': [Float, Integer]
+            source: [String],
+            seconds_to_keep: [Float, Integer]
           }
         end
 

data/lib/fusuma/plugin/detectors/detector.rb

@@ -1,13 +1,24 @@
 # frozen_string_literal: true
 
-require_relative '../base.rb'
-require_relative '../events/event.rb'
+require_relative '../base'
+require_relative '../events/event'
 
 module Fusuma
   module Plugin
     module Detectors
       # Inherite this base
       class Detector < Base
+        # @return [Array<String>]
+        def sources
+          @source ||= self.class.const_get('SOURCES')
+        end
+
+        # Always watch buffers and detect them or not
+        # @return [TrueClass,FalseClass]
+        def watch?
+          false
+        end
+
         # @param _buffers [Array<Buffer>]
         # @return [Event] if event is detected
         # @return [NilClass] if event is NOT detected
@@ -21,7 +32,7 @@ module Fusuma
         # @return [Events::Event]
         def create_event(record:)
           @last_time = Time.now
-          Events::Event.new(time: Time.now, tag: tag, record: record)
+          Events::Event.new(time: @last_time, tag: tag, record: record)
         end
 
         def last_time
@@ -33,11 +44,21 @@ module Fusuma
         end
 
         def tag
-          self.class.name.split('Detectors::').last.underscore
+          self.class.tag
         end
 
         def type
-          self.class.name.underscore.split('/').last.gsub('_detector', '')
+          self.class.type
+        end
+
+        class << self
+          def tag
+            name.split('Detectors::').last.underscore
+          end
+
+          def type(tag_name = tag)
+            tag_name.gsub('_detector', '')
+          end
         end
       end
     end

data/lib/fusuma/plugin/detectors/pinch_detector.rb

@@ -1,50 +1,111 @@
 # frozen_string_literal: true
 
-require_relative './detector.rb'
+require_relative './detector'
 
 module Fusuma
   module Plugin
     module Detectors
       class PinchDetector < Detector
+        SOURCES = ['gesture'].freeze
         BUFFER_TYPE = 'gesture'
         GESTURE_RECORD_TYPE = 'pinch'
 
         FINGERS = [2, 3, 4].freeze
-        BASE_THERESHOLD = 0.1
-        BASE_INTERVAL   = 0.1
+        BASE_THERESHOLD = 1.3
 
         # @param buffers [Array<Buffer>]
-        # @return [Event] if event is detected
+        # @return [Events::Event] if event is detected
         # @return [NilClass] if event is NOT detected
         def detect(buffers)
-          buffer = buffers.find { |b| b.type == BUFFER_TYPE }
-                          .select_by_events { |e| e.record.gesture == GESTURE_RECORD_TYPE }
-
-          return if buffer.empty?
-
-          finger = buffer.finger
-
-          avg_zoom = buffer.avg_attrs(:zoom)
-          first_zoom = buffer.events.first.record.direction.zoom
-          diameter = avg_zoom / first_zoom
-
-          direction = Direction.new(diameter: diameter).to_s
-          quantity = Quantity.new(diameter: diameter).to_f
-
-          index = create_index(gesture: type,
-                               finger: finger,
-                               direction: direction)
-
-          return unless enough?(index: index, quantity: quantity)
+          gesture_buffer = buffers.find { |b| b.type == BUFFER_TYPE }
+                                  .select_from_last_begin
+                                  .select_by_events { |e| e.record.gesture == GESTURE_RECORD_TYPE }
+
+          updating_events = gesture_buffer.updating_events
+          return if updating_events.empty?
+
+          finger = gesture_buffer.finger
+
+          status = case gesture_buffer.events.last.record.status
+                   when 'end'
+                     'end'
+                   when 'update'
+                     if updating_events.length == 1
+                       'begin'
+                     else
+                       'update'
+                     end
+                   else
+                     gesture_buffer.events.last.record.status
+                   end
+
+          prev_event, event = if status == 'end'
+                                [
+                                  gesture_buffer.events[-3],
+                                  gesture_buffer.events[-2]
+                                ]
+                              else
+                                [
+                                  gesture_buffer.events[-2],
+                                  gesture_buffer.events[-1]
+                                ]
+                              end
+          delta = event.record.delta
+          prev_delta = prev_event.record.delta
+
+          repeat_direction = Direction.new(target: delta.zoom, base: (prev_delta&.zoom || 1.0)).to_s
+          # repeat_quantity = Quantity.new(target: delta.zoom, base: (prev_delta&.zoom || 1.0)).to_f
+
+          repeat_index = create_repeat_index(gesture: type, finger: finger,
+                                             direction: repeat_direction,
+                                             status: status)
+          if status == 'update'
+            return unless moved?(prev_event, event)
+
+            avg_zoom = gesture_buffer.avg_attrs(:zoom)
+            first_zoom = updating_events.first.record.delta.zoom
+
+            oneshot_quantity = Quantity.new(target: avg_zoom, base: first_zoom).to_f
+            oneshot_direction = Direction.new(target: avg_zoom, base: first_zoom).to_s
+            oneshot_index = create_oneshot_index(gesture: type, finger: finger,
+                                                 direction: oneshot_direction)
+            if enough_oneshot_threshold?(index: oneshot_index, quantity: oneshot_quantity)
+              return [
+                create_event(record: Events::Records::IndexRecord.new(
+                  index: oneshot_index, trigger: :oneshot, args: delta.to_h
+                )),
+                create_event(record: Events::Records::IndexRecord.new(
+                  index: repeat_index, trigger: :repeat, args: delta.to_h
+                ))
+              ]
+            end
+          end
+          create_event(record: Events::Records::IndexRecord.new(
+            index: repeat_index, trigger: :repeat, args: delta.to_h
+          ))
+        end
 
-          create_event(record: Events::Records::IndexRecord.new(index: index))
+        # @param [String] gesture
+        # @param [Integer] finger
+        # @param [String] direction
+        # @param [String] status
+        # @return [Config::Index]
+        def create_repeat_index(gesture:, finger:, direction:, status:)
+          Config::Index.new(
+            [
+              Config::Index::Key.new(gesture),
+              Config::Index::Key.new(finger.to_i),
+              Config::Index::Key.new(direction, skippable: true),
+              Config::Index::Key.new(status)
+            ]
+          )
         end
 
         # @param [String] gesture
         # @param [Integer] finger
         # @param [String] direction
         # @return [Config::Index]
-        def create_index(gesture:, finger:, direction:)
+        def create_oneshot_index(gesture:, finger:, direction:)
           Config::Index.new(
             [
               Config::Index::Key.new(gesture),
@@ -56,41 +117,25 @@ module Fusuma
 
         private
 
-        def enough?(index:, quantity:)
-          enough_interval?(index: index) && enough_diameter?(index: index, quantity: quantity)
+        def moved?(prev_event, event)
+          zoom_delta = (event.record.delta.zoom - prev_event.record.delta.zoom).abs
+          updating_time = (event.time - prev_event.time) * 100
+          zoom_delta / updating_time > 0.01
         end
 
-        def enough_diameter?(index:, quantity:)
+        def enough_oneshot_threshold?(index:, quantity:)
           quantity >= threshold(index: index)
         end
 
-        def enough_interval?(index:)
-          return true if first_time?
-          return true if (Time.now - last_time) > interval_time(index: index)
-
-          false
-        end
-
         def threshold(index:)
           @threshold ||= {}
           @threshold[index.cache_key] ||= begin
-                           keys_specific = Config::Index.new [*index.keys, 'threshold']
-                           keys_global   = Config::Index.new ['threshold', type]
-                           config_value  = Config.search(keys_specific) ||
-                                           Config.search(keys_global) || 1
-                           BASE_THERESHOLD * config_value
-                         end
-        end
-
-        def interval_time(index:)
-          @interval_time ||= {}
-          @interval_time[index.cache_key] ||= begin
-                               keys_specific = Config::Index.new [*index.keys, 'interval']
-                               keys_global = Config::Index.new ['interval', type]
-                               config_value = Config.search(keys_specific) ||
-                                              Config.search(keys_global) || 1
-                               BASE_INTERVAL * config_value
-                             end
+            keys_specific = Config::Index.new [*index.keys, 'threshold']
+            keys_global   = Config::Index.new ['threshold', type]
+            config_value  = Config.search(keys_specific) ||
+                            Config.search(keys_global) || 1
+            BASE_THERESHOLD * config_value
+          end
         end
 
         # direction of gesture
@@ -98,8 +143,9 @@ module Fusuma
           IN = 'in'
           OUT = 'out'
 
-          def initialize(diameter:)
-            @diameter = diameter
+          def initialize(target:, base:)
+            @target = target.to_f
+            @base = base.to_f
           end
 
           def to_s
@@ -107,7 +153,7 @@ module Fusuma
           end
 
           def calc
-            if @diameter > 1
+            if @target > @base
               IN
             else
               OUT
@@ -117,8 +163,9 @@ module Fusuma
 
         # quantity of gesture
         class Quantity
-          def initialize(diameter:)
-            @diameter = diameter
+          def initialize(target:, base:)
+            @target = target.to_f
+            @base = base.to_f
           end
 
           def to_f
@@ -126,7 +173,11 @@ module Fusuma
           end
 
           def calc
-            (1.0 - @diameter).abs
+            if @target > @base
+              @target / @base
+            else
+              @base / @target
+            end
           end
         end
       end

data/lib/fusuma/plugin/detectors/rotate_detector.rb

@@ -1,47 +1,106 @@
 # frozen_string_literal: true
 
-require_relative './detector.rb'
+require_relative './detector'
 
 module Fusuma
   module Plugin
     module Detectors
       class RotateDetector < Detector
+        SOURCES = ['gesture'].freeze
         BUFFER_TYPE = 'gesture'
         GESTURE_RECORD_TYPE = 'pinch'
 
         FINGERS = [2, 3, 4].freeze
         BASE_THERESHOLD = 0.5
-        BASE_INTERVAL   = 0.1
 
         # @param buffers [Array<Buffer>]
-        # @return [Event] if event is detected
+        # @return [Events::Event] if event is detected
         # @return [NilClass] if event is NOT detected
         def detect(buffers)
-          buffer = buffers.find { |b| b.type == BUFFER_TYPE }
-                          .select_by_events { |e| e.record.gesture == GESTURE_RECORD_TYPE }
-
-          return if buffer.empty?
-
-          angle = buffer.avg_attrs(:rotate)
-
-          finger = buffer.finger
-          direction = Direction.new(angle: angle).to_s
-          quantity = Quantity.new(angle: angle).to_f
-
-          index = create_index(gesture: type,
-                               finger: finger,
-                               direction: direction)
-
-          return unless enough?(index: index, quantity: quantity)
+          gesture_buffer = buffers.find { |b| b.type == BUFFER_TYPE }
+                                  .select_from_last_begin
+                                  .select_by_events { |e| e.record.gesture == GESTURE_RECORD_TYPE }
+
+          updating_events = gesture_buffer.updating_events
+          return if updating_events.empty?
+
+          updating_time = 100 * (updating_events.last.time - updating_events.first.time)
+          oneshot_angle = gesture_buffer.sum_attrs(:rotate) / updating_time
+
+          return if updating_events.empty?
+
+          finger = gesture_buffer.finger
+
+          status = case gesture_buffer.events.last.record.status
+                   when 'end'
+                     'end'
+                   when 'update'
+                     if updating_events.length == 1
+                       'begin'
+                     else
+                       'update'
+                     end
+                   else
+                     gesture_buffer.events.last.record.status
+                   end
+
+          delta = if status == 'end'
+                    gesture_buffer.events[-2].record.delta
+                  else
+                    gesture_buffer.events.last.record.delta
+                  end
+
+          repeat_direction = Direction.new(angle: delta.rotate).to_s
+          repeat_quantity = Quantity.new(angle: delta.rotate).to_f
+
+          repeat_index = create_repeat_index(gesture: type, finger: finger,
+                                             direction: repeat_direction,
+                                             status: status)
+
+          if status == 'update'
+            return unless moved?(repeat_quantity)
+
+            oneshot_direction = Direction.new(angle: oneshot_angle).to_s
+            oneshot_quantity = Quantity.new(angle: oneshot_angle).to_f
+            oneshot_index = create_oneshot_index(gesture: type, finger: finger,
+                                                 direction: oneshot_direction)
+            if enough_oneshot_threshold?(index: oneshot_index, quantity: oneshot_quantity)
+              return [
+                create_event(record: Events::Records::IndexRecord.new(
+                  index: oneshot_index, trigger: :oneshot, args: delta.to_h
+                )),
+                create_event(record: Events::Records::IndexRecord.new(
+                  index: repeat_index, trigger: :repeat, args: delta.to_h
+                ))
+              ]
+            end
+          end
+          create_event(record: Events::Records::IndexRecord.new(
+            index: repeat_index, trigger: :repeat, args: delta.to_h
+          ))
+        end
 
-          create_event(record: Events::Records::IndexRecord.new(index: index))
+        # @param [String] gesture
+        # @param [Integer] finger
+        # @param [String] direction
+        # @param [String] status
+        # @return [Config::Index]
+        def create_repeat_index(gesture:, finger:, direction:, status:)
+          Config::Index.new(
+            [
+              Config::Index::Key.new(gesture),
+              Config::Index::Key.new(finger.to_i),
+              Config::Index::Key.new(direction),
+              Config::Index::Key.new(status)
+            ]
+          )
         end
 
         # @param [String] gesture
         # @param [Integer] finger
         # @param [String] direction
         # @return [Config::Index]
-        def create_index(gesture:, finger:, direction:)
+        def create_oneshot_index(gesture:, finger:, direction:)
           Config::Index.new(
             [
               Config::Index::Key.new(gesture),
@@ -53,41 +112,23 @@ module Fusuma
 
         private
 
-        def enough?(index:, quantity:)
-          enough_interval?(index: index) && enough_angle?(index: index, quantity: quantity)
+        def moved?(repeat_quantity)
+          repeat_quantity > 0.2
         end
 
-        def enough_angle?(index:, quantity:)
+        def enough_oneshot_threshold?(index:, quantity:)
           quantity > threshold(index: index)
         end
 
-        def enough_interval?(index:)
-          return true if first_time?
-          return true if (Time.now - last_time) > interval_time(index: index)
-
-          false
-        end
-
         def threshold(index:)
           @threshold ||= {}
           @threshold[index.cache_key] ||= begin
-                           keys_specific = Config::Index.new [*index.keys, 'threshold']
-                           keys_global   = Config::Index.new ['threshold', type]
-                           config_value  = Config.search(keys_specific) ||
-                                           Config.search(keys_global) || 1
-                           BASE_THERESHOLD * config_value
-                         end
-        end
-
-        def interval_time(index:)
-          @interval_time ||= {}
-          @interval_time[index.cache_key] ||= begin
-                               keys_specific = Config::Index.new [*index.keys, 'interval']
-                               keys_global = Config::Index.new ['interval', type]
-                               config_value = Config.search(keys_specific) ||
-                                              Config.search(keys_global) || 1
-                               BASE_INTERVAL * config_value
-                             end
+            keys_specific = Config::Index.new [*index.keys, 'threshold']
+            keys_global   = Config::Index.new ['threshold', type]
+            config_value  = Config.search(keys_specific) ||
+                            Config.search(keys_global) || 1
+            BASE_THERESHOLD * config_value
+          end
         end
 
         # direction of gesture
@@ -96,7 +137,7 @@ module Fusuma
           COUNTERCLOCKWISE = 'counterclockwise'
 
           def initialize(angle:)
-            @angle = angle
+            @angle = angle.to_f
           end
 
           def to_s
@@ -104,7 +145,7 @@ module Fusuma
           end
 
           def calc
-            if @angle > 0
+            if @angle.positive?
               CLOCKWISE
             else
               COUNTERCLOCKWISE