Merge lp:~jpakkane/evemu/touchviewer into lp:evemu

[Jussi Pakkanen]

This branch adds the touch viewer application originally developed under Grail: https://code.launchpad.net/~jpakkane/utouch-grail/touchviewer/+merge/71893

It reads the touches data from a trace file and plots it graphically. It parses the data file itself rather than use evemu's output. The main reason for this being that there are no Python bindings for evemu as of yet.

The app can be extended to have an evemu output backend when the bindings appear. It could even parse both at the same time and plot their results next to each other, making debugging easier.

[Chase Douglas (chasedouglas)]

Just to carry over from the previous review, I think the concept is good but it should use the evemu library to get the events. That means it's blocked on adding python bindings to evemu.

I don't think it would be too difficult to add python bindings. If for some reason it is, we can revisit whether to merge this without the evemu library linkage.

review: Needs Fixing

[Stephen M. Webb (bregma)]

On 09/02/2011 01:42 PM, Chase Douglas wrote:
> Review: Needs Fixing
> Just to carry over from the previous review, I think the concept is good but it should use the evemu library to get the events. That means it's blocked on adding python bindings to evemu.
>
> I don't think it would be too difficult to add python bindings. If for some reason it is, we can revisit whether to merge this without the evemu library linkage.
See bug #731678 and the branch
lp:~oubiwann/utouch-evemu/731678-python-wrapper.

--
Stephen M. Webb <email address hidden>
Canonical Ltd.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:42
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~jpakkane/evemu/touchviewer/+merge/73815/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/evemu-ci/3/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/evemu-raring-amd64-ci/3//console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/evemu-raring-armhf-ci/3//console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/evemu-raring-i386-ci/3//console

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/evemu-ci/3//rebuild/?

review: Needs Fixing (continuous-integration)

Unmerged revisions

42. By Jussi Pakkanen on 2011-09-02

Imported touch viewer from Grail repo.

=== added file 'tools/eventparser.py'
--- tools/eventparser.py	1970-01-01 00:00:00 +0000
+++ tools/eventparser.py	2011-09-02 13:53:23 +0000
@@ -0,0 +1,240 @@
+#!/usr/bin/python -tt
+#
+# @file eventparser
+# @brief a demo/test program to parse multitouch input files
+#
+# Copyright (C) 2011 Canonical Ltd
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+import sys, copy
+
+# Evdev protocol constants
+
+SYN_REPORT    = 0
+SYN_CONFIG    = 1
+SYN_MT_REPORT = 2
+
+ABS_MT_SLOT        = 0x2f    # MT slot being modified 
+ABS_MT_TOUCH_MAJOR = 0x30    # Major axis of touching ellipse
+ABS_MT_TOUCH_MINOR = 0x31    # Minor axis (omit if circular)
+ABS_MT_WIDTH_MAJOR = 0x32    # Major axis of approaching ellipse
+ABS_MT_WIDTH_MINOR = 0x33    # Minor axis (omit if circular)
+ABS_MT_ORIENTATION = 0x34    # Ellipse orientation
+ABS_MT_POSITION_X  = 0x35    # Center X ellipse position
+ABS_MT_POSITION_Y  = 0x36    # Center Y ellipse position
+ABS_MT_TOOL_TYPE   = 0x37    # Type of touching device
+ABS_MT_BLOB_ID     = 0x38    # Group a set of packets as a blob
+ABS_MT_TRACKING_ID = 0x39    # Unique ID of initiated contact
+ABS_MT_PRESSURE    = 0x3a    # Pressure on contact area 
+ABS_MT_DISTANCE    = 0x3b    # Contact hover distance 
+
+class RawEvent():
+    def __init__(self, time, type, code, value):
+        self.time = time
+        self.type = type
+        self.code = code
+        self.value = value
+
+class Absolute():
+    def __init__(self, minimum, maximum, fuzz, flat):
+        self.minimum = minimum
+        self.maximum = maximum
+        self.fuzz = fuzz
+        self.flat = flat
+
+class Slot():
+    def __init__(self):
+        self.tracking_id = -1
+        self.x = -1
+        self.y = -1
+        
+    def set_tracking_id(self, newid):
+        self.tracking_id = newid
+    
+    def set_x(self, x):
+        self.x = x
+    
+    def set_y(self, y):
+        self.y = y
+
+class State():
+    def __init__(self, time, slots):
+        self.time = time
+        self.slots = slots
+
+class StateTracker():
+    
+    def __init__(self, reader):
+        self.reader = reader
+        self.raw_event_id = 0
+        self.active_slot_num = 0
+        self.slots = {}
+        self.slots[self.active_slot_num] = Slot()
+        self.start_time = self.reader.events[0].time
+        self.current_time = self.reader.events[0].time
+        
+
+    def active_slot(self):
+        # If a slot has been destroyed and it immediately
+        # accessed again, we need to create a new slot.
+        if not self.active_slot_num in self.slots:
+            self.slots[self.active_slot_num] = Slot()
+        return self.slots[self.active_slot_num]
+
+    def get_next_state(self):
+        events = self.reader.events
+        if self.raw_event_id >= len(events):
+            return None
+        while events[self.raw_event_id].type != SYN_REPORT:
+            e = events[self.raw_event_id]
+            code = e.code
+            if code == ABS_MT_SLOT:
+                self.active_slot_num = e.value
+                if not self.active_slot_num in self.slots:
+                    self.slots[self.active_slot_num] = Slot()
+            elif code == ABS_MT_TRACKING_ID:
+                id = e.value
+                if id < 0:
+                    del self.slots[self.active_slot_num]
+                else:
+                    self.active_slot().set_tracking_id(id)
+            elif code == ABS_MT_POSITION_X:
+                self.active_slot().set_x(e.value)
+            elif code == ABS_MT_POSITION_Y:
+                self.active_slot().set_y(e.value)
+            self.raw_event_id += 1
+        self.current_time = events[self.raw_event_id].time
+        self.raw_event_id += 1
+        return self.slots
+    
+    def get_current_time(self):
+        return self.current_time - self.start_time
+
+def event_from_string(string):
+    arr = string.split()
+    if len(arr) != 5:
+        return None
+    time = float(arr[1])
+    type = int(arr[2], 16)
+    code = int(arr[3], 16)
+    value = int(arr[4])
+    return RawEvent(time, type, code, value)
+
+def build_state_array(state_tracker):
+    states = []
+    current_state = state_tracker.get_next_state()
+    while current_state is not None:
+        current_time = state_tracker.current_time
+        state_copy = copy.deepcopy(current_state)
+        states.append(State(current_time, state_copy))
+        current_state = state_tracker.get_next_state()
+    return states
+
+def absolute_from_string(string):
+    arr = string.split()
+    assert(len(arr) == 6)
+    index = int(arr[1], 16)
+    minimum = int(arr[2])
+    maximum = int(arr[3])
+    fuzz = int(arr[4])
+    flat = int(arr[5])
+    a = Absolute(minimum, maximum, fuzz, flat)
+    return (index, a)
+class EventReader():
+    def __init__(self, ifilename):
+        self.ifilename = ifilename
+        self.read_events()
+    
+
+    def parse_lines(self, infile):
+        for line in infile:
+            line = line.strip()
+            if line.startswith('P:'):
+                self.properties.append(line)
+            elif line.startswith('B:'):
+                self.masks.append(line)
+            elif line.startswith('A:'):
+                self.add_abs(line)
+            elif line.startswith('E:'):
+                e = event_from_string(line)
+                if e is None:
+                    print 'Malformed line in input'
+                else:
+                    self.events.append(e)
+            else:
+                raise RuntimeError('Unparseable line in input: ' + line)
+
+    def read_events(self):
+        self.description  = 'No description'
+        self.masks = []
+        self.bustype = ''
+        self.vendor = ''
+        self.product = ''
+        self.version = ''
+        self.masks = []
+        self.properties = []
+        self.abs = {}
+        self.events = []
+        infile = file(self.ifilename, 'r')
+        
+        first = infile.readline()
+        if first.startswith('N:'):
+            self.description = first.strip().split(' ', 1)[1]
+            (dummy, self.bustype, self.vendor, self.product, self.version) = \
+            infile.readline().strip().split()
+        elif first.startswith('E:'):
+            self.description = 'MISSING'
+            self.bustype = 'MISSING'
+            self.vendor = 'MISSING'
+            self.product = 'MISSING'
+            self.version = 'MISSING'
+            infile.seek(0)
+        else:
+            raise RuntimeError('Tried to open unsupported file.')
+        self.parse_lines(infile)
+
+    def add_abs(self, line):
+        (index, a) = absolute_from_string(line)
+        self.abs[index] = a
+        
+
+    def get_absolutes(self):
+        return self.abs
+
+    def print_stats(self):
+        print "RawEvent source:", self.description
+        print "USB Bustype %s vendor %s product %s version %s" % \
+        (self.bustype, self.vendor, self.product, self.version)
+        print "Number of masks:", len(self.masks)
+        print "Number of properties:", len(self.properties)
+        print "Number of absolutes:", len(self.abs)
+        print "Number of events:", len(self.events)
+        if len(self.events) > 0:
+            print "Duration:", self.events[-1].time - self.events[0].time
+
+if __name__ == '__main__':
+    input = sys.argv[1]
+    try:
+        reader = EventReader(input)
+    except RuntimeError, e:
+        print "Processing failed:", e
+        sys.exit(2)
+    reader.print_stats()
+    state = StateTracker(reader)
+    num_states = 0
+    while state.get_next_state() != None:
+        num_states += 1
+    print "Unique states:", num_states

=== added file 'tools/eventviewer.glade'
--- tools/eventviewer.glade	1970-01-01 00:00:00 +0000
+++ tools/eventviewer.glade	2011-09-02 13:53:23 +0000
@@ -0,0 +1,57 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <requires lib="gtk+" version="2.24"/>
+  <!-- interface-naming-policy project-wide -->
+  <object class="GtkWindow" id="MainWindow">
+    <property name="can_focus">False</property>
+    <child>
+      <object class="GtkTable" id="table1">
+        <property name="visible">True</property>
+        <property name="can_focus">False</property>
+        <property name="n_rows">2</property>
+        <property name="n_columns">2</property>
+        <child>
+          <object class="GtkDrawingArea" id="canvas">
+            <property name="width_request">800</property>
+            <property name="height_request">600</property>
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+          </object>
+          <packing>
+            <property name="right_attach">2</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkLabel" id="StatusLabel">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <property name="xalign">0.81999999284744263</property>
+            <property name="label" translatable="yes">This is some text</property>
+          </object>
+          <packing>
+            <property name="left_attach">1</property>
+            <property name="right_attach">2</property>
+            <property name="top_attach">1</property>
+            <property name="bottom_attach">2</property>
+            <property name="y_options"></property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkToggleButton" id="animate">
+            <property name="label" translatable="yes">Animate</property>
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="receives_default">True</property>
+            <property name="use_action_appearance">False</property>
+            <property name="xalign">0</property>
+          </object>
+          <packing>
+            <property name="top_attach">1</property>
+            <property name="bottom_attach">2</property>
+            <property name="y_options"></property>
+          </packing>
+        </child>
+      </object>
+    </child>
+  </object>
+</interface>

=== added file 'tools/eventviewer.py'
--- tools/eventviewer.py	1970-01-01 00:00:00 +0000
+++ tools/eventviewer.py	2011-09-02 13:53:23 +0000
@@ -0,0 +1,190 @@
+#!/usr/bin/python -tt
+#
+# @file event-viewer
+# @brief a demo/test program that shows the progress of touches
+#
+# Copyright (C) 2011 Canonical Ltd
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from eventparser import *
+
+import glib, gtk, gobject
+from math import pi
+import sys, os, time
+
+class EventViewer():
+    
+    def __init__(self, state_file_name):
+        self.state_file_name = state_file_name
+        self.glade_filename = os.path.join(os.path.split(__file__)[0], 'eventviewer.glade')
+        self.build_gui()
+        self.window.set_title('Multitouch viewer: ' + os.path.basename(state_file_name))
+        self.load_states()
+        self.current_index = 0
+        #self.max_x = 1020.0 # FIXME, get from event stream absolutes
+        #self.max_y = 600.0
+        self.max_x = 32762.0 # FIXME, get from event stream absolutes
+        self.max_y = 32762.0
+        self.source_aspect = self.max_x/float(self.max_y)
+        self.set_status_text()
+        
+    def load_states(self):
+        state_tracker = StateTracker(EventReader(self.state_file_name))
+        self.states = build_state_array(state_tracker)
+
+    def get_current_relative_time(self):
+        min_time = self.states[0].time
+        cur_time = self.get_current_time()
+        return (cur_time - min_time)
+
+    def move_through_time(self, delta):
+        self.current_index += delta
+        if self.current_index < 0:
+            self.current_index = 0
+        if self.current_index >= len(self.states):
+            self.current_index = len(self.states)-1
+        self.set_status_text()
+        return self.states[self.current_index]
+
+    def set_status_text(self):
+        state = self.states[self.current_index]
+        self.status_label.set_text('%d touches at %.3f s, frame %d/%d' %\
+            (len(state.slots), self.get_current_relative_time(),\
+             self.current_index, len(self.states)))
+
+    def build_gui(self):
+        self.builder = gtk.Builder()
+        self.builder.add_from_file(self.glade_filename)
+        self.window = self.builder.get_object('MainWindow')
+        self.canvas = self.builder.get_object('canvas')
+        self.status_label = self.builder.get_object('StatusLabel')
+        self.animate = self.builder.get_object('animate')
+        self.window.connect("destroy", gtk.main_quit)
+        self.window.connect("expose-event", self.canvas_expose)
+        self.window.connect("key-press-event", self.key_pressed)
+        self.animate.connect('toggled', self.animate_toggled)
+        self.window.show_all()
+        
+    def key_pressed(self, widget, event):
+        if event.keyval == gtk.keysyms.Right:
+            self.move_through_time(1)
+            self.canvas_expose(None, None)
+        if event.keyval == gtk.keysyms.Left:
+            self.move_through_time(-1)
+            self.canvas_expose(None, None)
+        if event.keyval == gtk.keysyms.Up:
+            self.move_through_time(10)
+            self.canvas_expose(None, None)
+        if event.keyval == gtk.keysyms.Down:
+            self.move_through_time(-10)
+            self.canvas_expose(None, None)
+        if event.keyval == gtk.keysyms.Page_Up:
+            self.move_through_time(100)
+            self.canvas_expose(None, None)
+        if event.keyval == gtk.keysyms.Page_Down:
+            self.move_through_time(-100)
+        if event.keyval == gtk.keysyms.q or \
+            event.keyval == gtk.keysyms.Escape:
+            gtk.main_quit()
+
+    def get_current_state(self):
+        return self.states[self.current_index]
+        
+    def get_current_slots(self):
+        return self.get_current_state().slots
+    
+    def get_current_time(self):
+        return self.get_current_state().time
+    
+    def animate_toggled(self, dummy):
+        if self.animate.get_active():
+            self.start_animation()
+        else:
+            self.stop_animation()
+    
+    def canvas_expose(self, widget, event):
+        cr = self.canvas.window.cairo_create()
+        # Erase all
+        cr.set_source_rgb(1.0, 1.0, 1.0)
+        (w, h) = self.canvas.window.get_size()
+        cr.rectangle(0, 0, w, h)
+        cr.fill()
+
+        canvas_aspect = w/float(h)
+        if canvas_aspect > self.source_aspect:
+            area_y = int(0.05*h)
+            area_h = h - 2*area_y
+            area_w = self.source_aspect*area_h
+            area_x = (w - area_w)/2
+        else:
+            area_x = int(0.05*w)
+            area_w = (w - 2*area_x)
+            area_h= area_w/self.source_aspect
+            area_y = (h - area_h)/2
+            
+        # Draw area box.
+        cr.set_source_rgb(0.0, 0.0, 0.0)
+        cr.rectangle(area_x, area_y, area_w, area_h)
+        cr.stroke()
+        # Draw spots
+        for v in self.get_current_slots().values():
+            plot_x = area_x + v.x/self.max_x*area_w
+            plot_y = area_y + v.y/self.max_y*area_h
+            cr.arc(plot_x, plot_y, 10, 0, 2*pi)
+            cr.fill()
+
+
+    def set_animation_callback(self):
+        delay = self.delay_to_next_frame()
+        if delay >= 0:
+            gobject.timeout_add(int(delay*1000), self.animation_loop)
+        else:
+            self.animate.set_active(False)
+            self.current_index = 0
+            self.animate.set_active(True)
+
+    def start_animation(self):
+        # If necessary, evaluate and store animation start time.
+        #self.current_index = 0
+        self.set_animation_callback()
+        
+    def stop_animation(self):
+        pass
+    
+    def animation_loop(self):
+        self.move_through_time(1)
+        self.canvas_expose(None, None)
+        if self.animate.get_active():
+            self.set_animation_callback()
+        
+    
+    def delay_to_next_frame(self):
+        try:
+            # Note that this will drift because we just add
+            # delta t:s one after the other. This should not be
+            # an issue, but if it is we need to evaluate times
+            # relative to a specified point in time.
+            now_time = self.states[self.current_index].time
+            next_time = self.states[self.current_index+1].time
+            delay = next_time - now_time
+            return delay
+        except IndexError:
+            return -1
+    
+if __name__ == '__main__':
+    if len(sys.argv) != 2:
+        print sys.argv[0], '<evemu file>'
+    viewer = EventViewer(sys.argv[1])
+    gtk.main()