fusuma-plugin-touchscreen 0.0.1.alpha → 0.1.0

data/lib/fusuma/plugin/events/records/touch_records/features/direction.rb

@@ -0,0 +1,36 @@
+module Fusuma
+  module Plugin
+    module Events
+      module Records
+        module TouchRecords
+          module Features
+            module Direction
+
+              def self.prepended(base)
+                base.class_eval do
+                  attr_reader :direction
+                end
+              end
+
+              def initialize(direction:, **args)
+                super(**args)
+                @direction = direction.to_s
+              end
+
+              def ==(other)
+                super(other) && direction == other.direction
+              end
+
+              protected
+
+              def config_index_keys
+                super << Config::Index::Key.new(@direction)
+              end
+
+            end # module WithDirection
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fusuma/plugin/events/records/touch_records/pinch_record.rb

@@ -0,0 +1,23 @@
+require_relative './base'
+require_relative './features/direction'
+
+# frozen_string_literal: true
+
+module Fusuma
+  module Plugin
+    module Events
+      module Records
+        module TouchRecords
+          class PinchRecord < Base
+            prepend Features::Direction
+
+            def repeatable?
+              true
+            end
+
+          end # class PinchRecord
+        end
+      end
+    end
+  end
+end

data/lib/fusuma/plugin/events/records/touch_records/rotate_record.rb

@@ -0,0 +1,23 @@
+require_relative './base'
+require_relative './features/direction'
+
+# frozen_string_literal: true
+
+module Fusuma
+  module Plugin
+    module Events
+      module Records
+        module TouchRecords
+          class RotateRecord < Base
+            prepend Features::Direction
+
+            def repeatable?
+              true
+            end
+
+          end # class RotateRecord
+        end
+      end
+    end
+  end
+end

data/lib/fusuma/plugin/events/records/touch_records/swipe_record.rb

@@ -1,4 +1,5 @@
 require_relative './base'
+require_relative './features/direction'
 
 # frozen_string_literal: true
 
@@ -8,23 +9,12 @@ module Fusuma
       module Records
         module TouchRecords
           class SwipeRecord < Base
-
-            def initialize(direction:, **args)
-              super(**args)
-              @direction = direction.to_s
-            end
+            prepend Features::Direction
 
             def repeatable?
               true
             end
 
-            protected
-
-            def config_index_keys
-              super << Config::Index::Key.new(@direction)
-            end
-
-
           end # class SwipeRecord
         end
       end

data/lib/fusuma/plugin/parsers/touch_parser.rb

@@ -1,58 +1,13 @@
 # frozen_string_literal: true
 
+require 'fusuma/plugin/parsers/parser'
+
 module Fusuma
   module Plugin
     module Parsers
       class TouchParser < Parser
         DEFAULT_SOURCE = 'libinput_command_input'
 
-=begin
-3-finger touch:
-
- event4   TOUCH_DOWN              +0.000s       0 (0) 58.64/44.04 (148.16/73.74mm)
- event4   TOUCH_DOWN              +0.000s       1 (1) 49.33/47.67 (124.63/79.84mm)
- event4   TOUCH_DOWN              +0.000s       2 (2) 43.54/64.23 (110.00/107.56mm)
- event4   TOUCH_UP                +0.079s       2 (2)
- event4   TOUCH_UP                +0.099s       1 (1)
- event4   TOUCH_UP                +0.108s       0 (0)
-=end
-
-=begin
-2-finger swipe:
-
- event4   TOUCH_DOWN              +0.000s       0 (0) 27.07/42.62 (68.39/71.37mm)
- event4   TOUCH_DOWN              +0.000s       1 (1) 26.45/53.27 (66.82/89.21mm)
- event4   TOUCH_MOTION            +0.051s       1 (1) 26.84/53.27 (67.82/89.21mm)
- event4   TOUCH_MOTION            +0.061s       0 (0) 27.40/42.91 (69.24/71.86mm)
- event4   TOUCH_MOTION            +0.061s       1 (1) 27.21/53.28 (68.74/89.23mm)
- event4   TOUCH_MOTION            +0.071s       0 (0) 28.03/43.27 (70.82/72.47mm)
- event4   TOUCH_MOTION            +0.071s       1 (1) 27.67/53.33 (69.92/89.30mm)
- event4   TOUCH_MOTION            +0.082s       0 (0) 28.59/43.49 (72.24/72.84mm)
- event4   TOUCH_MOTION            +0.082s       1 (1) 28.43/53.37 (71.84/89.37mm)
- event4   TOUCH_MOTION            +0.091s       0 (0) 29.32/43.66 (74.08/73.12mm)
- event4   TOUCH_MOTION            +0.091s       1 (1) 28.90/53.41 (73.03/89.44mm)
- event4   TOUCH_MOTION            +0.101s       0 (0) 30.17/43.99 (76.24/73.67mm)
- event4   TOUCH_MOTION            +0.101s       1 (1) 29.84/53.21 (75.39/89.12mm)
- event4   TOUCH_MOTION            +0.111s       0 (0) 30.51/44.08 (77.08/73.81mm)
- event4   TOUCH_MOTION            +0.111s       1 (1) 30.47/53.35 (76.97/89.35mm)
- event4   TOUCH_MOTION            +0.121s       0 (0) 31.84/44.59 (80.45/74.67mm)
- event4   TOUCH_MOTION            +0.121s       1 (1) 31.65/53.73 (79.97/89.98mm)
- event4   TOUCH_MOTION            +0.131s       0 (0) 32.56/44.76 (82.26/74.95mm)
- event4   TOUCH_MOTION            +0.131s       1 (1) 32.62/54.21 (82.42/90.79mm)
- event4   TOUCH_MOTION            +0.141s       0 (0) 33.51/44.94 (84.66/75.26mm)
- event4   TOUCH_MOTION            +0.141s       1 (1) 33.49/54.46 (84.61/91.21mm)
- event4   TOUCH_MOTION            +0.151s       0 (0) 34.88/45.38 (88.13/76.00mm)
- event4   TOUCH_MOTION            +0.151s       1 (1) 35.05/54.74 (88.55/91.67mm)
- event4   TOUCH_MOTION            +0.162s       0 (0) 36.14/45.72 (91.32/76.56mm)
- event4   TOUCH_MOTION            +0.162s       1 (1) 36.62/55.28 (92.53/92.58mm)
- event4   TOUCH_MOTION            +0.171s       0 (0) 37.53/46.12 (94.82/77.23mm)
- event4   TOUCH_MOTION            +0.171s       1 (1) 38.21/55.84 (96.55/93.51mm)
- event4   TOUCH_MOTION            +0.181s       0 (0) 39.94/47.08 (100.92/78.84mm)
- event4   TOUCH_MOTION            +0.181s       1 (1) 39.91/56.03 (100.84/93.84mm)
- event4   TOUCH_UP                +0.220s       0 (0)
- event4   TOUCH_UP                +0.220s       1 (1)
-=end
-
         def parse_record(record)
           MultiLogger.debug("#{self.class.name}##{__method__}")
           MultiLogger.debug("  record = #{record.inspect}")

data/lib/fusuma/plugin/touchscreen/math.rb

@@ -0,0 +1,68 @@
+module Fusuma
+  module Plugin
+    module Touchscreen
+      module Math
+
+        def self.angles_difference(angle1, angle2)
+          normalized_angle1 = normalize_angle(angle1)
+          normalized_angle2 = normalize_angle(angle2)
+
+          raw_difference = normalized_angle2 - normalized_angle1
+
+          if raw_difference < -180
+            raw_difference += 360
+          elsif raw_difference > 180
+            raw_difference -= 360
+          end
+
+          raw_difference
+        end
+
+        def self.normalize_angle(angle)
+          angle %= 360
+          angle < 0 ? angle + 360 : angle
+        end
+        private_class_method :normalize_angle
+
+        def self.angles_average(angles)
+          sum_x = 0.0
+          sum_y = 0.0
+
+          angles.each do |angle|
+            radians = angle * ::Math::PI / 180.0
+            sum_x += ::Math.cos(radians)
+            sum_y += ::Math.sin(radians)
+          end
+
+          average_radians = ::Math.atan2(sum_y, sum_x)
+          average_degrees = average_radians * 180.0 / ::Math::PI
+          average_degrees += 360.0 if average_degrees < 0
+
+          average_degrees
+        end
+
+        def self.distance(point1, point2)
+          ::Math.sqrt((point1[:x] - point2[:x])**2 + (point1[:y] - point2[:y])**2)
+        end
+
+        def self.distance_from_line(x, y, k, b)
+          (k * x + b - y).abs / ::Math.sqrt(k**2 + 1)
+        end
+
+        def self.center(points)
+          x = points.map { |p| p[:x] }.reduce(:+) / points.size
+          y = points.map { |p| p[:y] }.reduce(:+) / points.size
+          { x: x, y: y }
+        end
+
+        def self.angle_between(base_point, other_point)
+          radians = ::Math.atan2(other_point[:y] - base_point[:y], other_point[:x] - base_point[:x])
+          degrees = radians * 180.0 / ::Math::PI
+          degrees += 360.0 if degrees < 0
+          degrees
+        end
+
+      end # module Math
+    end
+  end
+end

data/lib/fusuma/plugin/touchscreen/version.rb

@@ -3,7 +3,7 @@
 module Fusuma
   module Plugin
     module Touchscreen
-      VERSION = "0.0.1.alpha"
+      VERSION = "0.1.0"
     end
   end
 end

data/spec/fusuma/plugin/buffers/touch_buffer_spec.rb

@@ -0,0 +1,216 @@
+require 'spec_helper'
+require 'timecop'
+require 'fusuma/plugin/events/event'
+require 'fusuma/plugin/buffers/touch_buffer'
+require 'fusuma/plugin/events/records/touch_record'
+
+module Fusuma
+  RSpec.describe Plugin::Buffers::TouchBuffer do
+    subject { described_class.new }
+
+    it 'builds finger_events_map' do
+      event = generate_touch_event
+      subject.buffer(event)
+      expect(subject.finger_events_map[event.record.finger]).not_to be_empty
+      expect(subject.finger_events_map[event.record.finger].first).to eq event
+    end
+
+
+    it 'clears finger_events_map' do
+      event = generate_touch_event
+      subject.buffer(event)
+      subject.clear
+      expect(subject.finger_events_map).to be_empty
+    end
+
+    describe '#clear_expired' do
+      it 'outdated' do
+        allow(subject).to receive(:config_params).and_call_original
+        allow(subject).to receive(:config_params).with(:seconds_to_keep).and_return(50)
+        expired_event = generate_touch_event(time: Time.now - 100)
+        actual_event = generate_touch_event
+        subject.buffer(expired_event)
+        subject.buffer(actual_event)
+        subject.clear_expired
+        expect(subject.finger_events_map[actual_event.record.finger]).not_to include(expired_event)
+        expect(subject.finger_events_map[actual_event.record.finger]).to include(actual_event)
+      end
+
+      it 'ended' do
+        subject.buffer(generate_touch_event(record: generate_touch_record(status: 'begin')))
+        subject.clear_expired
+        expect(subject.finger_events_map).not_to be_empty
+
+        subject.buffer(generate_touch_event(record: generate_touch_record(status: 'end')))
+        subject.clear_expired
+        expect(subject.finger_events_map).to be_empty
+      end
+    end
+
+    describe '#empty?' do
+      it 'is empty' do
+        expect(subject.empty?).to be_truthy
+      end
+
+      it 'is not empty' do
+        event = generate_touch_event
+        subject.buffer(event)
+        expect(subject.empty?).to be_falsey
+      end
+    end
+
+    describe '#finger' do
+      it 'returns 0 if finger_events_map is empty' do
+        expect(subject.finger).to eq 0
+      end
+
+      it 'returns count of fingers' do
+        subject.buffer(generate_touch_event(record: generate_touch_record(finger: 1)))
+        subject.buffer(generate_touch_event(record: generate_touch_record(finger: 2)))
+        expect(subject.finger).to eq 2
+      end
+
+      it 'is based on count of fingers, not finger number' do
+        subject.buffer(generate_touch_event(record: generate_touch_record(finger: 2)))
+        expect(subject.finger).to eq 1
+      end
+    end
+
+    describe '#began?' do
+      it 'not began yet' do
+        expect(subject.began?).to be_falsey
+      end
+
+      it 'began' do
+        subject.buffer(generate_touch_event(record: generate_touch_record(status: 'begin')))
+        expect(subject.began?).to be_truthy
+      end
+
+      it 'doesn\'t contain begin events (being updated or so, but began before that)' do
+        subject.buffer(generate_touch_event(record: generate_touch_record(status: 'update')))
+        expect(subject.began?).to be_falsey
+      end
+
+      it 'one finger began, other continued to update' do
+        subject.buffer(generate_touch_event(record: generate_touch_record(status: 'begin', finger: 1)))
+        subject.buffer(generate_touch_event(record: generate_touch_record(status: 'update', finger: 2)))
+        expect(subject.began?).to be_falsey
+      end
+    end
+
+    describe '#ended?' do
+      it 'not ended yet' do
+        expect(subject.ended?).to be_falsey
+      end
+
+      it 'ended' do
+        subject.buffer(generate_touch_event(record: generate_touch_record(status: 'end')))
+        expect(subject.ended?).to be_truthy
+      end
+
+      it 'doesn\'t contain end events (being updated or so, but ended before that)' do
+        subject.buffer(generate_touch_event(record: generate_touch_record(status: 'update')))
+        expect(subject.ended?).to be_falsey
+      end
+
+      it 'one finger ended, other continued to update' do
+        subject.buffer(generate_touch_event(record: generate_touch_record(status: 'end', finger: 1)))
+        subject.buffer(generate_touch_event(record: generate_touch_record(status: 'update', finger: 2)))
+        expect(subject.ended?).to be_falsey
+      end
+    end
+
+    describe '#finger_movements / #moved' do
+      before do
+        allow(subject).to receive(:movement_threshold).and_return(0.5)
+      end
+
+      it 'returns empty array if finger_events_map is empty' do
+        expect(subject.finger_movements).to be_empty
+        expect(subject.moved?).to be_falsey
+      end
+
+      it 'no movement if only one event' do
+        event = generate_touch_event
+        subject.buffer(event)
+        expect(subject.finger_movements).to be_empty
+        expect(subject.moved?).to be_falsey
+      end
+
+      it 'does not detect movement lesser than movement threshold' do
+        event1 = generate_touch_event(record: generate_touch_record(status: 'begin', x_mm: 0, y_mm: 0))
+        event2 = generate_touch_event(record: generate_touch_record(status: 'update', x_mm: 0.4, y_mm: 0))
+        subject.buffer(event1)
+        subject.buffer(event2)
+        expect(subject.finger_movements).to be_empty
+        expect(subject.moved?).to be_falsey
+      end
+
+      it 'detects movement outside jitter threshold' do
+        event1 = generate_touch_event(record: generate_touch_record(status: 'begin', x_mm: 0, y_mm: 0))
+        event2 = generate_touch_event(record: generate_touch_record(status: 'update', x_mm: 1, y_mm: 2))
+        subject.buffer(event1)
+        subject.buffer(event2)
+        expect(subject.finger_movements).to eq({ 0 => { first_position: { x: 0.0, y: 0.0 }, last_position: { x: 1.0, y: 2.0 } } })
+        expect(subject.moved?).to be_truthy
+      end
+    end
+
+    describe '#begin_time' do
+      it 'returns nil if no begin event' do
+        expect(subject.begin_time).to be_nil
+      end
+
+      it 'returns begin event time' do
+        begin_event = generate_touch_event(time: Time.now - 60, record: generate_touch_record(status: 'begin'))
+        subject.buffer(begin_event)
+        update_event = generate_touch_event(time: Time.now, record: generate_touch_record(status: 'end'))
+        subject.buffer(update_event)
+        expect(subject.begin_time).to eq(begin_event.time)
+      end
+    end
+
+    describe '#end_time' do
+      it 'returns nil if no end event' do
+        expect(subject.end_time).to be_nil
+      end
+
+      it 'returns end event time' do
+        begin_event = generate_touch_event(time: Time.now - 60, record: generate_touch_record(status: 'begin'))
+        subject.buffer(begin_event)
+        end_event = generate_touch_event(time: Time.now, record: generate_touch_record(status: 'end'))
+        subject.buffer(end_event)
+        expect(subject.end_time).to eq(end_event.time)
+      end
+    end
+
+    describe '#duration' do
+      it 'zero if nothing happened' do
+        expect(subject.duration).to eq(0)
+      end
+
+      it 'gesture ended' do
+        t = Time.now
+        begin_event = generate_touch_event(time: t - 60, record: generate_touch_record(status: 'begin'))
+        subject.buffer(begin_event)
+        update_event = generate_touch_event(time: t - 40, record: generate_touch_record(status: 'update'))
+        subject.buffer(update_event)
+        end_event = generate_touch_event(time: t - 20, record: generate_touch_record(status: 'end'))
+        subject.buffer(end_event)
+        expect(subject.duration).to eq(40)
+      end
+
+      it 'gesture not ended' do
+        t = Time.now
+        Timecop.freeze(t) do
+          begin_event = generate_touch_event(time: t - 60, record: generate_touch_record(status: 'begin'))
+          subject.buffer(begin_event)
+          update_event = generate_touch_event(time: t - 40, record: generate_touch_record(status: 'update'))
+          subject.buffer(update_event)
+          expect(subject.duration.round).to eq(60)
+        end
+      end
+    end # duration
+
+  end
+end

data/spec/fusuma/plugin/detectors/hold_detector_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'timecop'
+require 'fusuma/plugin/events/event'
+require 'fusuma/plugin/parsers/touch_parser'
+require 'fusuma/plugin/buffers/touch_buffer'
+require 'fusuma/plugin/detectors/touch_detectors/hold_detector'
+require 'fusuma/plugin/events/records/touch_records/hold_record'
+
+module Fusuma
+  RSpec.describe Plugin::Detectors::TouchDetectors::HoldDetector do
+    subject { described_class.new }
+    let(:touch_buffer) { Plugin::Buffers::TouchBuffer.new }
+    let(:t) { Time.now }
+
+    before do
+      allow(touch_buffer).to receive(:movement_threshold).and_return(0.5)
+      allow(subject).to receive(:tap_hold_threshold).and_return(0.5)
+      allow(subject).to receive(:jitter_threshold).and_return(5.0)
+    end
+
+    it 'no events' do
+      expect(subject.detect(touch_buffer)).to be nil
+    end
+
+    it 'under tap_hold_threshold' do
+      touch_buffer.buffer(generate_touch_event(time: t - 0.1, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 10, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 10, y_mm: 10)))
+
+      expect(subject.detect(touch_buffer)).to be nil
+    end
+
+    it 'not moved' do
+      touch_buffer.buffer(generate_touch_event(time: t - 1, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 10, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 10, y_mm: 10)))
+
+      expect(subject.detect(touch_buffer)).to be_a(Plugin::Events::Records::TouchRecords::HoldRecord)
+    end
+
+    it 'moved under jitter_threshold' do
+      touch_buffer.buffer(generate_touch_event(time: t - 1, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 10, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 10, y_mm: 15)))
+
+      expect(subject.detect(touch_buffer)).to be_a(Plugin::Events::Records::TouchRecords::HoldRecord)
+    end
+
+    it 'moved more than jitter_threshold' do
+      touch_buffer.buffer(generate_touch_event(time: t - 1, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 10, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 10, y_mm: 20)))
+
+      expect(subject.detect(touch_buffer)).to be nil
+    end
+
+    it 'works on real data' do
+      parser = Plugin::Parsers::TouchParser.new
+      buffer = Plugin::Buffers::TouchBuffer.new
+      lines = File.readlines("spec/samples/1-finger-hold.txt").map(&:strip).reject(&:empty?)
+      t = Time.now - 30
+      lines.each do |line|
+        record = parser.parse_record(line)
+        next unless record
+
+        event = Plugin::Events::Event.new(tag: 'libinput_touch_parser', record: record, time: t += 1)
+        buffer.buffer(event)
+      end
+      gesture = subject.detect(buffer)
+      expect(gesture).to be_a(Plugin::Events::Records::TouchRecords::HoldRecord)
+      expect(gesture.finger).to eq(1)
+    end
+
+  end
+end

data/spec/fusuma/plugin/detectors/pinch_detector_spec.rb

@@ -0,0 +1,96 @@
+require 'fusuma/plugin/detectors/touch_detectors/pinch_detector'
+
+module Fusuma
+  RSpec.describe Plugin::Detectors::TouchDetectors::PinchDetector do
+    include_context 'with touch buffer'
+    subject { described_class.new }
+
+    before do
+      allow(subject).to receive(:jitter_threshold).and_return(5.0)
+    end
+
+    it 'no events' do
+      expect(subject.detect(touch_buffer)).to be_nil
+    end
+
+    it 'not moved' do
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 10, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 10, y_mm: 10)))
+
+      expect(subject.detect(touch_buffer)).to be_nil
+    end
+
+    it 'moved, only one finger' do
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 10, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 20, y_mm: 20)))
+
+      expect(subject.detect(touch_buffer)).to be_nil
+    end
+
+    it 'moved, not enough distance change between first 2 fingers' do
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 10, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 8, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 2, x_mm: 10, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 2, x_mm: 12, y_mm: 10)))
+
+      expect(subject.detect(touch_buffer)).to be_nil
+    end
+
+    it 'just two fingers' do
+      # inside down left
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 0, y_mm: 0)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 10, y_mm: 10)))
+      # inside up right
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 2, x_mm: 20, y_mm: 20)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 2, x_mm: 10, y_mm: 10)))
+
+      gesture = subject.detect(touch_buffer)
+      expect(gesture).to be_a(Plugin::Events::Records::TouchRecords::PinchRecord)
+      expect(gesture.finger).to eq(2)
+      expect(gesture.direction).to eq('in')
+    end
+
+    it 'three fingers, the third finger moved in wrong direction' do
+      # outside up right
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 20, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 30, y_mm: 0)))
+      # outside down left
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 2, x_mm: 10, y_mm: 20)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 2, x_mm: 0, y_mm: 30)))
+      # inside up left
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 3, x_mm: 30, y_mm: 30)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 3, x_mm: 20, y_mm: 20)))
+
+      expect(subject.detect(touch_buffer)).to be_nil
+    end
+
+    it 'three fingers' do
+      # outside up right
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 1, x_mm: 20, y_mm: 10)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 1, x_mm: 30, y_mm: 0)))
+      # outside down left
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 2, x_mm: 10, y_mm: 20)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 2, x_mm: 0, y_mm: 30)))
+      # outside down right
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'begin', finger: 3, x_mm: 20, y_mm: 20)))
+      touch_buffer.buffer(generate_touch_event(time: t, record: generate_touch_record(status: 'update', finger: 3, x_mm: 30, y_mm: 30)))
+
+      gesture = subject.detect(touch_buffer)
+      expect(gesture).to be_a(Plugin::Events::Records::TouchRecords::PinchRecord)
+      expect(gesture.direction).to eq('out')
+      expect(gesture.finger).to eq(3)
+    end
+
+    it_behaves_like 'real sample',
+                    detector_class: Plugin::Detectors::TouchDetectors::PinchDetector,
+                    sample_path: 'spec/samples/3-fingers-pinch-in.txt',
+                    expected_gesture_class: Plugin::Events::Records::TouchRecords::PinchRecord,
+                    expected_gesture_attributes: { finger: 3, direction: 'in' }
+    it_behaves_like 'real sample',
+                    detector_class: Plugin::Detectors::TouchDetectors::PinchDetector,
+                    sample_path: 'spec/samples/3-fingers-pinch-out.txt',
+                    expected_gesture_class: Plugin::Events::Records::TouchRecords::PinchRecord,
+                    expected_gesture_attributes: { finger: 3, direction: 'out' }
+
+  end
+end