def test_immediate(self):
gdb = Recognizer(db=[self.Tinvar, self.Ninvar])
r = gdb.recognize([Ncandidate], max_gpf=0)
self.assertEqual(r._match_ops, 4)
self.assertEqual(r._completed, 2)
self.assertEqual(r.progress, 1)
self.assertTrue(r.best['score'] > 0.94 and r.best['score'] < 0.95)
def test_scheduling_limits(self):
global best_score
from kivy.clock import Clock
gdb = Recognizer(db=[self.Ninvar])
tpls = len(self.Ninvar.templates)
best_score = 0
gdb.db.append(self.Ninvar)
r = gdb.recognize([Ncandidate], max_gpf=1)
r.bind(on_complete=best_score_cb)
self.assertEqual(r.progress, 0)
Clock.tick()
self.assertEqual(r.progress, 0.5)
self.assertEqual(best_score, 0)
Clock.tick()
self.assertEqual(r.progress, 1)
self.assertTrue(best_score > 0.94 and best_score < 0.95)
best_score = 0
gdb.db.append(self.Ninvar)
r = gdb.recognize([Ncandidate], max_gpf=1)
r.bind(on_complete=best_score_cb)
self.assertEqual(r.progress, 0)
Clock.tick()
self.assertEqual(r.progress, 1 / 3.)
Clock.tick()
self.assertEqual(r.progress, 2 / 3.)
self.assertEqual(best_score, 0)
Clock.tick()
self.assertEqual(r.progress, 1)
self.assertTrue(best_score > 0.94 and best_score < 0.95)
def test_immediate(self):
gdb = Recognizer(db=[self.Tinvar, self.Ninvar])
r = gdb.recognize([Ncandidate], max_gpf=0)
self.assertEqual(r._match_ops, 4)
self.assertEqual(r._completed, 2)
self.assertEqual(r.progress, 1)
self.assertTrue(r.best['score'] > 0.94 and r.best['score'] < 0.95)
def __init__(self, parent, data, loglevel):
self.strokes = [[]]
self.time = time.time()
self.gdb = Recognizer()
self.logger = logging.getLogger('StrokeRecognition')
self.logger.setLevel(loglevel)
self.logger.addHandler(CH)
self.logger.info('Creating Gestures Templates..')
circle = [[Vector(int(10+10*cos(t)),
int(10+10*sin(t)))
for t in np.linspace(0,2*pi,8)]]
self.gdb.add_gesture('Circle',circle, strokes_sensitive=True)
#Horizontal or vertical lines give error
self.gdb.add_gesture('Line', [[Vector(10,60),Vector(40,50)]],
strokes_sensitive=True, priority=50)
self.gdb.add_gesture('Triangle', [[Vector(10,10),
Vector(15,15),
Vector(20,20),
Vector(20,20),
Vector(25,15),
Vector(30,10),
Vector(30,10),
Vector(20,10),
Vector(10,10)]],
strokes_sensitive=False,
orientation_sensitive=False,
permute=False)
self.gdb.add_gesture('Rectangle', [[Vector(10,10),
Vector(10,15),
Vector(10,20),
Vector(10,20),
Vector(15,20),
Vector(20,20),
Vector(20,20),
Vector(20,15),
Vector(20,10),
Vector(20,10),
Vector(15,10),
Vector(10,10)]],
strokes_sensitive=False,
orientation_sensitive=False,
permute=False)
self.logger.info('Templates created')
self.found_gesture = False
self.gesture = None
self._data = data
self._parent = parent
self.ran = False
self.gdb.bind(on_search_complete=self.search_stop)
self.dist_thres = 0
self.time_thres = 2
self.skel_sub = mfilters.Subscriber(
"skeleton", Image)
self.clas_sub = mfilters.Subscriber(
"class", TimeReference)
self.image_ts = mfilters.TimeSynchronizer(
[self.skel_sub, self.clas_sub], 30)
self.image_ts.registerCallback(
self.callback)
self.bridge = CvBridge()
def test_scheduling_limits(self):
global best_score
from kivy.clock import Clock
gdb = Recognizer(db=[self.Ninvar])
tpls = len(self.Ninvar.templates)
best_score = 0
gdb.db.append(self.Ninvar)
r = gdb.recognize([Ncandidate], max_gpf=1)
r.bind(on_complete=best_score_cb)
self.assertEqual(r.progress, 0)
Clock.tick()
self.assertEqual(r.progress, 0.5)
self.assertEqual(best_score, 0)
Clock.tick()
self.assertEqual(r.progress, 1)
self.assertTrue(best_score > 0.94 and best_score < 0.95)
best_score = 0
gdb.db.append(self.Ninvar)
r = gdb.recognize([Ncandidate], max_gpf=1)
r.bind(on_complete=best_score_cb)
self.assertEqual(r.progress, 0)
Clock.tick()
self.assertEqual(r.progress, 1 / 3.)
Clock.tick()
self.assertEqual(r.progress, 2 / 3.)
self.assertEqual(best_score, 0)
Clock.tick()
self.assertEqual(r.progress, 1)
self.assertTrue(best_score > 0.94 and best_score < 0.95)
def test_transfer(self):
gdb1 = Recognizer(db=[self.Ninvar])
gdb2 = Recognizer()
gdb1.transfer_gesture(gdb2, name='N')
r = gdb2.recognize([Ncandidate], max_gpf=0)
self.assertEqual(r.best['name'], 'N')
self.assertTrue(r.best['score'] > 0.94 and r.best['score'] < 0.95)
def save_selection_to_file(self, filename, *l):
if not self.selected_count:
self.recognizer.export_gesture(filename=filename)
else:
tmpgdb = Recognizer()
for i in self.ids.gesture_list.children:
if i.ids.select.state == 'down':
for g in i.gesture_list:
tmpgdb.db.append(g)
tmpgdb.export_gesture(filename=filename)
def save_selection_to_file(self, filename, *l):
if not self.selected_count:
self.recognizer.export_gesture(filename=filename)
else:
tmpgdb = Recognizer()
for i in self.ids.gesture_list.children:
if i.ids.select.state == 'down':
for g in i.gesture_list:
tmpgdb.db.append(g)
tmpgdb.export_gesture(filename=filename)
def test_protractor_bound(self):
gdb = Recognizer(db=[self.Tbound, self.Nbound])
r = gdb.recognize([NGesture], orientation_sensitive=True, max_gpf=0)
self.assertEqual(r.best['name'], 'N')
self.assertTrue(r.best['score'] >= 0.99)
r = gdb.recognize([NGesture], orientation_sensitive=False, max_gpf=0)
self.assertEqual(r.best['name'], None)
self.assertEqual(r.best['score'], 0)
r = gdb.recognize([Ncandidate], orientation_sensitive=True, max_gpf=0)
self.assertEqual(r.best['name'], 'N')
self.assertTrue(r.best['score'] > 0.94 and r.best['score'] < 0.95)
def test_timeout_case_1(self):
global best_score
from kivy.clock import Clock
from time import sleep
best_score = 0
gdb = Recognizer(db=[self.Tbound, self.Ninvar])
r = gdb.recognize([Ncandidate], max_gpf=1, timeout=0.4)
Clock.tick() # matches Tbound in this tick
self.assertEqual(best_score, 0)
sleep(0.4)
Clock.tick() # should match Ninv, but times out (got T)
self.assertEqual(r.status, 'timeout')
self.assertEqual(r.progress, .5)
self.assertTrue(r.best['name'] == 'T')
self.assertTrue(r.best['score'] < 0.5)
def test_protractor_bound(self):
gdb = Recognizer(db=[self.Tbound, self.Nbound])
r = gdb.recognize([NGesture], orientation_sensitive=True,
max_gpf=0)
self.assertEqual(r.best['name'], 'N')
self.assertTrue(r.best['score'] >= 0.99)
r = gdb.recognize([NGesture], orientation_sensitive=False,
max_gpf=0)
self.assertEqual(r.best['name'], None)
self.assertEqual(r.best['score'], 0)
r = gdb.recognize([Ncandidate], orientation_sensitive=True,
max_gpf=0)
self.assertEqual(r.best['name'], 'N')
self.assertTrue(r.best['score'] > 0.94 and r.best['score'] < 0.95)
def test_timeout_case_1(self):
global best_score
from kivy.clock import Clock
from time import sleep
best_score = 0
gdb = Recognizer(db=[self.Tbound, self.Ninvar])
r = gdb.recognize([Ncandidate], max_gpf=1, timeout=0.4)
Clock.tick() # matches Tbound in this tick
self.assertEqual(best_score, 0)
sleep(0.4)
Clock.tick() # should match Ninv, but times out (got T)
self.assertEqual(r.status, 'timeout')
self.assertEqual(r.progress, .5)
self.assertTrue(r.best['name'] == 'T')
self.assertTrue(r.best['score'] < 0.5)
def test_scheduling(self):
global best_score
from kivy.clock import Clock
gdb = Recognizer(db=[self.Tinvar, self.Ninvar])
r = gdb.recognize([Ncandidate], max_gpf=1)
r.bind(on_complete=best_score_cb)
# _recognize_tick is scheduled here; compares to Tinvar
Clock.tick()
self.assertEqual(r.progress, .5)
self.assertEqual(best_score, .0)
# Now complete the search operation
Clock.tick()
self.assertEqual(r.progress, 1)
self.assertTrue(best_score > 0.94 and best_score < 0.95)
def test_scheduling(self):
global best_score
from kivy.clock import Clock
gdb = Recognizer(db=[self.Tinvar, self.Ninvar])
r = gdb.recognize([Ncandidate], max_gpf=1)
r.bind(on_complete=best_score_cb)
# _recognize_tick is scheduled here; compares to Tinvar
Clock.tick()
self.assertEqual(r.progress, .5)
self.assertEqual(best_score, .0)
# Now complete the search operation
Clock.tick()
self.assertEqual(r.progress, 1)
self.assertTrue(best_score > 0.94 and best_score < 0.95)
def build(self):
self.manager = ScreenManager(transition=SlideTransition(duration=.15))
self.recognizer = Recognizer()
self.recognizer.import_gesture(filename='../res/calc_symbols.kg')
self.calc_bar = CalcBar()
# Gesture screen
surface = GestureSurface(line_width=2,
draw_bbox=True,
use_random_color=True)
surface_screen = Screen(name='surface')
surface_screen.add_widget(surface)
self.manager.add_widget(surface_screen)
surface.bind(on_gesture_discard=self.handle_gesture_discard)
surface.bind(on_gesture_complete=self.handle_gesture_complete)
surface.bind(on_gesture_cleanup=self.handle_gesture_cleanup)
self.surface = surface
# NumPad screen
numpad = Numpad(self.calc_bar)
numpad_screen = Screen(name='numpad')
numpad_screen.add_widget(numpad)
self.manager.add_widget(numpad_screen)
# Settings screen
app_settings = CalculatorAppSettings()
ids = app_settings.ids
ids.max_strokes.bind(value=surface.setter('max_strokes'))
ids.temporal_win.bind(value=surface.setter('temporal_window'))
ids.timeout.bind(value=surface.setter('draw_timeout'))
ids.line_width.bind(value=surface.setter('line_width'))
ids.draw_bbox.bind(value=surface.setter('draw_bbox'))
ids.use_random_color.bind(value=surface.setter('use_random_color'))
settings_screen = Screen(name='settings')
settings_screen.add_widget(app_settings)
self.manager.add_widget(settings_screen)
# Wrap in a gridlayout so the main menu is always visible
layout = GridLayout(cols=1)
layout.add_widget(self.calc_bar)
layout.add_widget(MainMenu())
layout.add_widget(self.manager)
return layout
def test_export_import_case_1(self):
gdb1 = Recognizer(db=[self.Ninvar])
gdb2 = Recognizer()
g = gdb1.export_gesture(name='N')
gdb2.import_gesture(g)
r = gdb2.recognize([Ncandidate], max_gpf=0)
self.assertEqual(r.best['name'], 'N')
self.assertTrue(r.best['score'] > 0.94 and r.best['score'] < 0.95)
def test_timeout_case_2(self):
global best_score
from kivy.clock import Clock
from time import sleep
best_score = 0
gdb = Recognizer(db=[self.Tbound, self.Ninvar, self.Tinvar])
r = gdb.recognize([Ncandidate], max_gpf=1, timeout=0.8)
Clock.tick() # matches Tbound in this tick
self.assertEqual(best_score, 0)
sleep(0.4)
Clock.tick() # matches Ninvar in this tick
sleep(0.4)
Clock.tick() # should match Tinvar, but times out
self.assertEqual(r.status, 'timeout')
self.assertEqual(r.progress, 2 / 3.)
self.assertTrue(r.best['score'] >= .94 and r.best['score'] <= .95)
def test_timeout_case_2(self):
global best_score
from kivy.clock import Clock
from time import sleep
best_score = 0
gdb = Recognizer(db=[self.Tbound, self.Ninvar, self.Tinvar])
r = gdb.recognize([Ncandidate], max_gpf=1, timeout=0.8)
Clock.tick() # matches Tbound in this tick
self.assertEqual(best_score, 0)
sleep(0.4)
Clock.tick() # matches Ninvar in this tick
sleep(0.4)
Clock.tick() # should match Tinvar, but times out
self.assertEqual(r.status, 'timeout')
self.assertEqual(r.progress, 2 / 3.)
self.assertTrue(r.best['score'] >= .94 and r.best['score'] <= .95)
def test_transfer(self):
gdb1 = Recognizer(db=[self.Ninvar])
gdb2 = Recognizer()
gdb1.transfer_gesture(gdb2, name='N')
r = gdb2.recognize([Ncandidate], max_gpf=0)
self.assertEqual(r.best['name'], 'N')
self.assertTrue(r.best['score'] > 0.94 and r.best['score'] < 0.95)
def test_priority_sorting(self):
gdb = Recognizer()
gdb.add_gesture('N', [NGesture], priority=10)
gdb.add_gesture('T', [TGesture], priority=5)
r = gdb.recognize([Ncandidate], goodscore=0.01, max_gpf=0,
force_priority_sort=True)
self.assertEqual(r.best['name'], 'T')
r = gdb.recognize([Ncandidate], goodscore=0.01,
force_priority_sort=False, max_gpf=0)
self.assertEqual(r.best['name'], 'N')
r = gdb.recognize([Ncandidate], goodscore=0.01, max_gpf=0,
priority=10)
self.assertEqual(r.best['name'], 'T')
r = gdb.recognize([Ncandidate], goodscore=0.01, max_gpf=0,
priority=4)
self.assertEqual(r.best['name'], None)
def build(self):
# Setting NoTransition breaks the "history" screen! Possibly related
# to some inexplicable rendering bugs on my particular system
self.manager = ScreenManager(transition=SlideTransition(
duration=.15))
self.recognizer = Recognizer()
# Setup the GestureSurface and bindings to our Recognizer
surface = GestureSurface(line_width=2, draw_bbox=True,
use_random_color=True)
surface_screen = Screen(name='surface')
surface_screen.add_widget(surface)
self.manager.add_widget(surface_screen)
surface.bind(on_gesture_discard=self.handle_gesture_discard)
surface.bind(on_gesture_complete=self.handle_gesture_complete)
surface.bind(on_gesture_cleanup=self.handle_gesture_cleanup)
self.surface = surface
# History is the list of gestures drawn on the surface
history = GestureHistoryManager()
history_screen = Screen(name='history')
history_screen.add_widget(history)
self.history = history
self.manager.add_widget(history_screen)
# Database is the list of gesture templates in Recognizer
database = GestureDatabase(recognizer=self.recognizer)
database_screen = Screen(name='database')
database_screen.add_widget(database)
self.database = database
self.manager.add_widget(database_screen)
# Settings screen
app_settings = MultistrokeAppSettings()
ids = app_settings.ids
ids.max_strokes.bind(value=surface.setter('max_strokes'))
ids.temporal_win.bind(value=surface.setter('temporal_window'))
ids.timeout.bind(value=surface.setter('draw_timeout'))
ids.line_width.bind(value=surface.setter('line_width'))
ids.draw_bbox.bind(value=surface.setter('draw_bbox'))
ids.use_random_color.bind(value=surface.setter('use_random_color'))
settings_screen = Screen(name='settings')
settings_screen.add_widget(app_settings)
self.manager.add_widget(settings_screen)
# Wrap in a gridlayout so the main menu is always visible
layout = GridLayout(cols=1)
layout.add_widget(self.manager)
layout.add_widget(MainMenu())
return layout
def test_numstrokes_filter(self):
gdb = Recognizer(db=[self.Ninvar, self.Nbound])
n = gdb.filter(numstrokes=2)
self.assertEqual(len(n), 0)
gdb.add_gesture('T', [TGesture, TGesture])
n = gdb.filter(numstrokes=2)
self.assertEqual(len(n), 1)
n = gdb.filter(numstrokes=[1, 2])
self.assertEqual(len(n), 3)
def test_numpoints_filter(self):
gdb = Recognizer(db=[self.Ninvar, self.Nbound])
n = gdb.filter(numpoints=100)
self.assertEqual(len(n), 0)
gdb.add_gesture('T', [TGesture], numpoints=100)
n = gdb.filter(numpoints=100)
self.assertEqual(len(n), 1)
n = gdb.filter(numpoints=[100, 16])
self.assertEqual(len(n), 3)
def test_orientation_filter(self):
gdb = Recognizer(db=[self.Ninvar, self.Nbound])
n = gdb.filter(orientation_sensitive=True)
self.assertEqual(len(n), 1)
n = gdb.filter(orientation_sensitive=False)
self.assertEqual(len(n), 1)
n = gdb.filter(orientation_sensitive=None)
self.assertEqual(len(n), 2)
gdb.db.append(self.Tinvar)
n = gdb.filter(orientation_sensitive=True)
self.assertEqual(len(n), 1)
n = gdb.filter(orientation_sensitive=False)
self.assertEqual(len(n), 2)
n = gdb.filter(orientation_sensitive=None)
self.assertEqual(len(n), 3)
def test_parallel_recognize(self):
global counter
from kivy.clock import Clock
counter = 0
gdb = Recognizer()
for i in range(9):
gdb.add_gesture('T', [TGesture], priority=50)
gdb.add_gesture('N', [NGesture])
r1 = gdb.recognize([Ncandidate], max_gpf=1)
r1.bind(on_complete=counter_cb)
Clock.tick() # first run scheduled here; 9 left
r2 = gdb.recognize([Ncandidate], max_gpf=1)
r2.bind(on_complete=counter_cb)
Clock.tick() # 8 left
r3 = gdb.recognize([Ncandidate], max_gpf=1)
r3.bind(on_complete=counter_cb)
Clock.tick() # 7 left
# run some immediate searches, should not interfere.
for i in range(5):
n = gdb.recognize([TGesture], max_gpf=0)
self.assertEqual(n.best['name'], 'T')
self.assertTrue(round(n.best['score'], 1) == 1.0)
for i in range(6):
Clock.tick()
self.assertEqual(counter, 0)
Clock.tick()
self.assertEqual(counter, 1)
Clock.tick()
self.assertEqual(counter, 2)
Clock.tick()
self.assertEqual(counter, 3)
def test_priority_sorting(self):
gdb = Recognizer()
gdb.add_gesture('N', [NGesture], priority=10)
gdb.add_gesture('T', [TGesture], priority=5)
r = gdb.recognize([Ncandidate], goodscore=0.01, max_gpf=0,
force_priority_sort=True)
self.assertEqual(r.best['name'], 'T')
r = gdb.recognize([Ncandidate], goodscore=0.01,
force_priority_sort=False, max_gpf=0)
self.assertEqual(r.best['name'], 'N')
r = gdb.recognize([Ncandidate], goodscore=0.01, max_gpf=0,
priority=10)
self.assertEqual(r.best['name'], 'T')
r = gdb.recognize([Ncandidate], goodscore=0.01, max_gpf=0,
priority=4)
self.assertEqual(r.best['name'], None)
def test_export_import_case_2(self):
from tempfile import mkstemp
import os
gdb1 = Recognizer(db=[self.Ninvar, self.Tinvar])
gdb2 = Recognizer()
fh, fn = mkstemp()
os.close(fh)
g = gdb1.export_gesture(name='N', filename=fn)
gdb2.import_gesture(filename=fn)
os.unlink(fn)
self.assertEqual(len(gdb1.db), 2)
self.assertEqual(len(gdb2.db), 1)
r = gdb2.recognize([Ncandidate], max_gpf=0)
self.assertEqual(r.best['name'], 'N')
self.assertTrue(r.best['score'] > 0.94 and r.best['score'] < 0.95)
def test_numpoints_filter(self):
gdb = Recognizer(db=[self.Ninvar, self.Nbound])
n = gdb.filter(numpoints=100)
self.assertEqual(len(n), 0)
gdb.add_gesture('T', [TGesture], numpoints=100)
n = gdb.filter(numpoints=100)
self.assertEqual(len(n), 1)
n = gdb.filter(numpoints=[100, 16])
self.assertEqual(len(n), 3)
def test_export_import_case_1(self):
gdb1 = Recognizer(db=[self.Ninvar])
gdb2 = Recognizer()
g = gdb1.export_gesture(name='N')
gdb2.import_gesture(g)
r = gdb2.recognize([Ncandidate], max_gpf=0)
self.assertEqual(r.best['name'], 'N')
self.assertTrue(r.best['score'] > 0.94 and r.best['score'] < 0.95)
def test_numstrokes_filter(self):
gdb = Recognizer(db=[self.Ninvar, self.Nbound])
n = gdb.filter(numstrokes=2)
self.assertEqual(len(n), 0)
gdb.add_gesture('T', [TGesture, TGesture])
n = gdb.filter(numstrokes=2)
self.assertEqual(len(n), 1)
n = gdb.filter(numstrokes=[1, 2])
self.assertEqual(len(n), 3)
def test_orientation_filter(self):
gdb = Recognizer(db=[self.Ninvar, self.Nbound])
n = gdb.filter(orientation_sensitive=True)
self.assertEqual(len(n), 1)
n = gdb.filter(orientation_sensitive=False)
self.assertEqual(len(n), 1)
n = gdb.filter(orientation_sensitive=None)
self.assertEqual(len(n), 2)
gdb.db.append(self.Tinvar)
n = gdb.filter(orientation_sensitive=True)
self.assertEqual(len(n), 1)
n = gdb.filter(orientation_sensitive=False)
self.assertEqual(len(n), 2)
n = gdb.filter(orientation_sensitive=None)
self.assertEqual(len(n), 3)
def test_parallel_recognize(self):
global counter
from kivy.clock import Clock
counter = 0
gdb = Recognizer()
for i in range(9):
gdb.add_gesture('T', [TGesture], priority=50)
gdb.add_gesture('N', [NGesture])
r1 = gdb.recognize([Ncandidate], max_gpf=1)
r1.bind(on_complete=counter_cb)
Clock.tick() # first run scheduled here; 9 left
r2 = gdb.recognize([Ncandidate], max_gpf=1)
r2.bind(on_complete=counter_cb)
Clock.tick() # 8 left
r3 = gdb.recognize([Ncandidate], max_gpf=1)
r3.bind(on_complete=counter_cb)
Clock.tick() # 7 left
# run some immediate searches, should not interfere.
for i in range(5):
n = gdb.recognize([TGesture], max_gpf=0)
self.assertEqual(n.best['name'], 'T')
self.assertTrue(round(n.best['score'], 1) == 1.0)
for i in range(6):
Clock.tick()
self.assertEqual(counter, 0)
Clock.tick()
self.assertEqual(counter, 1)
Clock.tick()
self.assertEqual(counter, 2)
Clock.tick()
self.assertEqual(counter, 3)
def test_export_import_case_2(self):
from tempfile import mkstemp
import os
gdb1 = Recognizer(db=[self.Ninvar, self.Tinvar])
gdb2 = Recognizer()
fh, fn = mkstemp()
os.close(fh)
g = gdb1.export_gesture(name='N', filename=fn)
gdb2.import_gesture(filename=fn)
os.unlink(fn)
self.assertEqual(len(gdb1.db), 2)
self.assertEqual(len(gdb2.db), 1)
r = gdb2.recognize([Ncandidate], max_gpf=0)
self.assertEqual(r.best['name'], 'N')
self.assertTrue(r.best['score'] > 0.94 and r.best['score'] < 0.95)
def test_name_filter(self):
gdb = Recognizer(db=[self.Ninvar, self.Nbound])
n = gdb.filter()
self.assertEqual(len(n), 2)
n = gdb.filter(name='X')
self.assertEqual(len(n), 0)
class StrokeRecognition(object):
def __init__(self, parent, data, loglevel):
self.strokes = [[]]
self.time = time.time()
self.gdb = Recognizer()
self.logger = logging.getLogger('StrokeRecognition')
self.logger.setLevel(loglevel)
self.logger.addHandler(CH)
self.logger.info('Creating Gestures Templates..')
circle = [[Vector(int(10+10*cos(t)),
int(10+10*sin(t)))
for t in np.linspace(0,2*pi,8)]]
self.gdb.add_gesture('Circle',circle, strokes_sensitive=True)
#Horizontal or vertical lines give error
self.gdb.add_gesture('Line', [[Vector(10,60),Vector(40,50)]],
strokes_sensitive=True, priority=50)
self.gdb.add_gesture('Triangle', [[Vector(10,10),
Vector(15,15),
Vector(20,20),
Vector(20,20),
Vector(25,15),
Vector(30,10),
Vector(30,10),
Vector(20,10),
Vector(10,10)]],
strokes_sensitive=False,
orientation_sensitive=False,
permute=False)
self.gdb.add_gesture('Rectangle', [[Vector(10,10),
Vector(10,15),
Vector(10,20),
Vector(10,20),
Vector(15,20),
Vector(20,20),
Vector(20,20),
Vector(20,15),
Vector(20,10),
Vector(20,10),
Vector(15,10),
Vector(10,10)]],
strokes_sensitive=False,
orientation_sensitive=False,
permute=False)
self.logger.info('Templates created')
self.found_gesture = False
self.gesture = None
self._data = data
self._parent = parent
self.ran = False
self.gdb.bind(on_search_complete=self.search_stop)
self.dist_thres = 0
self.time_thres = 2
self.skel_sub = mfilters.Subscriber(
"skeleton", Image)
self.clas_sub = mfilters.Subscriber(
"class", TimeReference)
self.image_ts = mfilters.TimeSynchronizer(
[self.skel_sub, self.clas_sub], 30)
self.image_ts.registerCallback(
self.callback)
self.bridge = CvBridge()
def callback(self, skel, class_name):
if self._parent.initialized and not self._parent.write_mode:
try:
skel = self.bridge.imgmsg_to_cv2(skel,
desired_encoding=
'passthrough')
action = class_name.source
if action == 'Index':
self.ran = False
self.add_stroke_vector(skel[-1, -1, 1],
skel[-1, -1, 0])
self.time = time.time()
elif action == 'Palm':
self.add_stroke()
if not self.ran and time.time() - self.time > self.time_thres:
self.ran = True
if len(self.strokes[0])>0:
self.progress = self.gdb.recognize(self.strokes[:-1])
#removing last empty sublist ^
clock.tick()
self._data.add(gesture=self.gesture,
found_gesture=self.found_gesture,
strokes=self.strokes)
self.strokes = [[]]
evt = CreateEvent(EVT_STRK_TYPE, -1)
wx.PostEvent(self._parent, evt)
except Exception as e:
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type,
exc_value,
exc_traceback, limit=2, file=sys.stdout)
print e
else:
self.strokes = [[]]
def search_stop(self, gdb, pt):
best = pt.best
dist = best['dist']
self.gesture = best['name']
if dist > self.dist_thres and self.gesture is not None:
self.found_gesture = True
self.logger.debug('Gesture found as ' + str(self.gesture) +
' having cos distance ' + str(dist))
else:
self.found_gesture = False
self.logger.debug('Gesture not found. \n\tBest candidate was '+
str(self.gesture) +' with cos distance:' + str(dist))
self.logger.debug('\tThe number of strokes was ' +
str(len(self.strokes)-1))
self.logger.debug('\tStrokes:')
for stroke in self.strokes[:-1]:
self.logger.debug('\t\t'+str(stroke))
def add_stroke(self):
if len(self.strokes[-1])>0: #add stroke only if last stroke is not empty
self.strokes.append([])
def add_stroke_vector(self, xpoint, ypoint):
if len(self.strokes[-1])>0:
dist_check = norm(np.diff([np.array(self.strokes[-1][-1]),
np.array([xpoint,ypoint])],axis=0))<10
else:
dist_check = True
if dist_check:
self.strokes[-1].append(Vector(xpoint,ypoint))
class CalculatorApp(App):
def handle_gesture_cleanup(self, surface, g, *l):
if hasattr(g, '_result_label'):
surface.remove_widget(g._result_label)
def handle_gesture_discard(self, surface, g, *l):
if surface.draw_timeout == 0:
return
text = '[b]Discarded:[/b] Not enough input'
g._result_label = Label(text=text,
markup=True,
size_hint=(None, None),
center=(g.bbox['minx'], g.bbox['miny']))
self.surface.add_widget(g._result_label)
def handle_gesture_complete(self, surface, g, *l):
result = self.recognizer.recognize(g.get_vectors())
result._gesture_obj = g
result.bind(on_complete=self.handle_recognize_complete)
def handle_recognize_complete(self, result, *l):
if self.surface.draw_timeout == 0:
return
best = result.best
if best['name'] is None:
text = '[b]No match[/b]'
else:
text = 'Name: [b]%s[/b]\nScore: [b]%f[/b]\nDistance: [b]%f[/b]' % (
best['name'], best['score'], best['dist'])
self.calc_bar.update_display(best['name'])
g = result._gesture_obj
g._result_label = Label(text=text,
markup=True,
size_hint=(None, None),
center=(g.bbox['minx'], g.bbox['miny']))
self.surface.add_widget(g._result_label)
def build(self):
self.manager = ScreenManager(transition=SlideTransition(duration=.15))
self.recognizer = Recognizer()
self.recognizer.import_gesture(filename='../res/calc_symbols.kg')
self.calc_bar = CalcBar()
# Gesture screen
surface = GestureSurface(line_width=2,
draw_bbox=True,
use_random_color=True)
surface_screen = Screen(name='surface')
surface_screen.add_widget(surface)
self.manager.add_widget(surface_screen)
surface.bind(on_gesture_discard=self.handle_gesture_discard)
surface.bind(on_gesture_complete=self.handle_gesture_complete)
surface.bind(on_gesture_cleanup=self.handle_gesture_cleanup)
self.surface = surface
# NumPad screen
numpad = Numpad(self.calc_bar)
numpad_screen = Screen(name='numpad')
numpad_screen.add_widget(numpad)
self.manager.add_widget(numpad_screen)
# Settings screen
app_settings = CalculatorAppSettings()
ids = app_settings.ids
ids.max_strokes.bind(value=surface.setter('max_strokes'))
ids.temporal_win.bind(value=surface.setter('temporal_window'))
ids.timeout.bind(value=surface.setter('draw_timeout'))
ids.line_width.bind(value=surface.setter('line_width'))
ids.draw_bbox.bind(value=surface.setter('draw_bbox'))
ids.use_random_color.bind(value=surface.setter('use_random_color'))
settings_screen = Screen(name='settings')
settings_screen.add_widget(app_settings)
self.manager.add_widget(settings_screen)
# Wrap in a gridlayout so the main menu is always visible
layout = GridLayout(cols=1)
layout.add_widget(self.calc_bar)
layout.add_widget(MainMenu())
layout.add_widget(self.manager)
return layout
def test_priority_filter(self):
gdb = Recognizer(db=[self.Ninvar, self.Nbound])
n = gdb.filter(priority=50)
self.assertEqual(len(n), 0)
gdb.add_gesture('T', [TGesture], priority=51)
n = gdb.filter(priority=50)
self.assertEqual(len(n), 0)
n = gdb.filter(priority=51)
self.assertEqual(len(n), 1)
gdb.add_gesture('T', [TGesture], priority=52)
n = gdb.filter(priority=[0, 51])
self.assertEqual(len(n), 1)
n = gdb.filter(priority=[0, 52])
self.assertEqual(len(n), 2)
n = gdb.filter(priority=[51, 52])
self.assertEqual(len(n), 2)
n = gdb.filter(priority=[52, 53])
self.assertEqual(len(n), 1)
n = gdb.filter(priority=[53, 54])
self.assertEqual(len(n), 0)
def test_name_filter(self):
gdb = Recognizer(db=[self.Ninvar, self.Nbound])
n = gdb.filter()
self.assertEqual(len(n), 2)
n = gdb.filter(name='X')
self.assertEqual(len(n), 0)
def test_priority_filter(self):
gdb = Recognizer(db=[self.Ninvar, self.Nbound])
n = gdb.filter(priority=50)
self.assertEqual(len(n), 0)
gdb.add_gesture('T', [TGesture], priority=51)
n = gdb.filter(priority=50)
self.assertEqual(len(n), 0)
n = gdb.filter(priority=51)
self.assertEqual(len(n), 1)
gdb.add_gesture('T', [TGesture], priority=52)
n = gdb.filter(priority=[0, 51])
self.assertEqual(len(n), 1)
n = gdb.filter(priority=[0, 52])
self.assertEqual(len(n), 2)
n = gdb.filter(priority=[51, 52])
self.assertEqual(len(n), 2)
n = gdb.filter(priority=[52, 53])
self.assertEqual(len(n), 1)
n = gdb.filter(priority=[53, 54])
self.assertEqual(len(n), 0)
