def on_init(self, controller):
### Step 1: create max interface ###
self.max_interface = Max_Interface()
### Step 2: notify of initialization ###
print_status("Controller Listener", "controller initialized")
def __init__(self):
print_welcome()
### Step 1: create the listener, controller and connect the two ###
self.listener = Synth_Listener()
self.controller = Leap.Controller()
self.controller.add_listener(self.listener)
### Step 2: create controller and gesture recognizer ###
self.max_interface = Max_Interface()
self.gesture_recognizer = Gesture_Recognizer()
def on_init(self, controller):
### Step 1: create max interface ###
self.max_interface = Max_Interface ()
### Step 2: notify of initialization ###
print_status ("Controller Listener", "controller initialized")
def __init__ (self):
print_welcome ()
### Step 1: create the listener, controller and connect the two ###
self.listener = Synth_Listener ()
self.controller = Leap.Controller ()
self.controller.add_listener (self.listener)
### Step 2: create controller and gesture recognizer ###
self.max_interface = Max_Interface ()
self.gesture_recognizer = Gesture_Recognizer ()
class Leap_Synth:
#--- Member Objects ---
listener = None
controller = None
max_interface = None
gesture_recognizer = None
# Function: Constructor
# ---------------------
# initializes member objects
def __init__(self):
print_welcome()
### Step 1: create the listener, controller and connect the two ###
self.listener = Synth_Listener()
self.controller = Leap.Controller()
self.controller.add_listener(self.listener)
### Step 2: create controller and gesture recognizer ###
self.max_interface = Max_Interface()
self.gesture_recognizer = Gesture_Recognizer()
# Function: Destructor
# --------------------
# removes the listener from the controller
def __del__(self):
### Step 1: turn off the max patch ###
self.max_interface.send_gesture('Stop')
### Step 2: remove leap listener ###
self.controller.remove_listener(self.listener)
# Function: get_frame
# -------------------
# blocks until it gets a new frame from the listener
def get_frame(self):
while (self.listener.new_frame_available == False):
pass
frame = self.listener.most_recent_frame
self.listener.new_frame_available = False
return frame
########################################################################################################################
##############################[ --- User Interface --- ]################################################################
########################################################################################################################
# Function: interface_main
# ------------------------
# main function for all interface
def interface_main(self):
viable_options = ['r', 't', 's']
### Step 1: get their requested mode ###
print_message("What mode would you like to enter?")
print " - R: record mode"
print " - T: train mode"
print " - S: synth mode"
response = raw_input("---> ")
response = response.lower()
if response == 'r':
while (True):
self.record_main()
elif response == 't':
self.train_main()
elif response == 's':
while (True):
self.synth_main()
else:
print_message("Error: did not recognize that option")
self.interface_main()
# Function: record_main
# ---------------------
# interface for recording gestures
def record_main(self):
while (True):
print_message("What would you like to do?")
print " - R: record a new gesture"
print " - Q: quit"
response = raw_input("---> ")
response = response.lower()
if response == 'q':
exit()
else:
self.record_gesture()
# Function: record_countdown
# --------------------------
# prints out a countdown
def record_countdown(self):
print "3"
time.sleep(0.5)
print "2"
time.sleep(0.5)
print "1"
time.sleep(0.5)
print "--- record ---"
# Function: record_gesture
# ------------------------
# record a single gesture
def record_gesture(self):
num_examples_recorded = 0
max_examples = 10
### Step 1: have them name the gesture ###
print_message("What is this gesture called?")
gesture_name = raw_input("---> ")
print_message("Now we will begin recording " + str(max_examples) +
" examples of this gesture, " + str(gesture_name) +
". Press Enter when ready.")
sys.stdin.readline()
record_gesture = Gesture(gesture_name)
#--- initialize parameters ---
is_recording = False
num_frames_recorded = 0
while (num_examples_recorded < max_examples):
frame = self.get_frame()
record_gesture.add_frame(frame)
if record_gesture.is_full():
### --- Notify of recording status --- ###
if is_recording:
print "."
num_frames_recorded += 1
else:
print "x"
### --- Check if we should end the recording --- ###
if num_frames_recorded >= record_gesture.gesture_length:
print_message("### Recording Complete ###")
is_recording = False
num_frames_recorded = 0
num_examples_recorded += 1
self.gesture_recognizer.save_gesture(record_gesture)
### --- Check if we should start the recording --- ###
while sys.stdin in select.select([sys.stdin], [], [], 0)[0]:
line = sys.stdin.readline()
if line:
print_message("### Started Recording ###")
is_recording = True
# Function: train_main
# --------------------
# train the classifier
def train_main(self):
### Step 1: load in the data and print out stats about it ###
print_status("Gesture_Recognizer", "Loading Data")
self.gesture_recognizer.load_data()
# self.gesture_recognizer.eliminate_second_hand ()
self.gesture_recognizer.print_data_stats()
### Step 2: cluster the poses ###
print_status("Gesture_Recognizer", "Training Model")
self.gesture_recognizer.train_model()
########################################################################################################################
##############################[ --- Synth Main --- ]####################################################################
########################################################################################################################
# Function: synth_main_disrcete
# --------------------
# records discrete gestures and classifies them for you.
def synth_main_discrete(self):
self.gesture_recognizer.load_model()
print_message("Recording Discrete events")
while (True):
### Step 1: initialize the gesture ###
observed_gesture = Gesture()
### Step 2: start the recording ###
self.record_countdown()
### Step 3: fill it with frames ###
while not observed_gesture.is_full():
frame = self.get_frame()
observed_gesture.add_frame(frame)
### Step 4: stop the recording and classify ###
print_message("### Recording Complete ###")
self.gesture_recognizer.classify_gesture(observed_gesture)
print_message("enter to continue")
sys.stdin.readline()
# Function: get_gesture
# ---------------------
# function to wait on gestures
def get_gesture(self, observed_gesture):
### --- add the current frame --- ###
frame = self.get_frame()
observed_gesture.add_frame(frame)
if observed_gesture.is_full():
### --- get classification results --- ###
classification_results = self.gesture_recognizer.classify_gesture(
observed_gesture)
### --- interpret them --- ###
return self.classification_results
# Function: get_coords
# --------------------
# returns (x,y,z) of the hand
def get_continuous_coords(self):
### --- add the current frame --- ###
frame = self.get_frame()
if len(frame.hands) == 0:
return None
else:
position = hands[0].palm_position
return (position[0], position[1], posiiton[2])
# Function: get_position_and_orientation
# --------------------------------------
# given a frame, this returns the (palm_position, palm_orientation) if we observe
# a fist (0 fingers visible); (None, None) otherwise
def get_position_and_orientation(self, frame):
### Step 1: peace out if there are no hands ###
hands = frame.hands
if len(hands) == 0:
return (None, None)
### Step 2: peace out if there are any fingers (not a fist) ###
fingers = hands[0].fingers
if len(fingers) > 0:
return (None, None)
### Step 3: get position and orientation ###
hand = hands[0]
palm_position = hands[0].palm_position
position = (palm_position[0], palm_position[1], palm_position[2])
palm_normal = hands[0].palm_normal
orientation = (palm_normal[0], palm_normal[1], palm_normal[2])
return (position, orientation)
# Function: synth_main
# --------------------
# maintains a 70-frame gesture and tries to classify it
def synth_main(self):
### Step 1: start the max patch ###
self.max_interface.send_gesture('Start')
### Step 2: initialize local data ###
print_message("Entering Main Loop: Continuous Gesture Recognition")
self.gesture_recognizer.load_model()
observed_gesture = Gesture()
### Step 3: enter main loop ###
while (True):
### Step 1: add the current frame to observed_gesture ###
frame = self.get_frame()
observed_gesture.add_frame(frame)
### Step 2: get position and orientation (returns (None, None) if not a fist) ###
(palm_position,
palm_orientation) = self.get_position_and_orientation(frame)
### Step 3: Get the gesture, if appropriate ###
send_gesture = None
if observed_gesture.is_full():
classification_results = self.gesture_recognizer.classify_gesture(
observed_gesture)
if classification_results:
prediction = classification_results[0]
prediction_prob = classification_results[1]
print_message("Prediction: " + str(prediction) +
" | Probability: " + str(prediction_prob))
send_gesture = prediction
observed_gesture.clear()
### Step 4: send a gesture to max if one was observed ###
if send_gesture:
self.max_interface.send_gesture(send_gesture)
### Step 5: Send hand state to max if one was observed ###
if len(frame.hands) > 0:
self.max_interface.send_hand_state(frame.hands[0])
class Leap_Synth:
#--- Member Objects ---
listener = None
controller = None
max_interface = None
gesture_recognizer = None
# Function: Constructor
# ---------------------
# initializes member objects
def __init__ (self):
print_welcome ()
### Step 1: create the listener, controller and connect the two ###
self.listener = Synth_Listener ()
self.controller = Leap.Controller ()
self.controller.add_listener (self.listener)
### Step 2: create controller and gesture recognizer ###
self.max_interface = Max_Interface ()
self.gesture_recognizer = Gesture_Recognizer ()
### Step 3: determine what the fps is ###
self.determine_fps ()
# Function: Destructor
# --------------------
# removes the listener from the controller
def __del__ (self):
### Step 1: turn off the max patch ###
self.max_interface.send_gesture ('Stop')
### Step 2: remove leap listener ###
self.controller.remove_listener(self.listener)
# Function: get_frame
# -------------------
# blocks until it gets a new frame from the listener
def get_frame (self):
while (self.listener.new_frame_available == False):
pass
frame = self.listener.most_recent_frame
self.listener.new_frame_available = False
return frame
# Function: determine_fps
# -----------------------
# gets 30 frames in order to determine the fps
def determine_fps (self):
start = timeit.timeit()
for i in range(30):
print i
frame = self.get_frame ()
stop = timeit.timeit()
self.fps = stop - start
print "fps: ", self.fps
########################################################################################################################
##############################[ --- User Interface --- ]################################################################
########################################################################################################################
# Function: interface_main
# ------------------------
# main function for all interface
def interface_main (self):
viable_options =['r', 't', 's']
### Step 1: get their requested mode ###
print_message ("What mode would you like to enter?")
print " - R: record mode"
print " - T: train mode"
print " - S: synth mode"
response = raw_input ("---> ")
response = response.lower ()
if response == 'r':
while (True):
self.record_main ()
elif response == 't':
self.train_main ()
elif response == 's':
while (True):
self.synth_main ()
else:
print_message("Error: did not recognize that option")
self.interface_main ()
# Function: record_main
# ---------------------
# interface for recording gestures
def record_main (self):
while (True):
print_message ("What would you like to do?")
print " - R: record a new gesture"
print " - Q: quit"
response = raw_input ("---> ")
response = response.lower ()
if response == 'q':
exit ()
else:
self.record_gesture ()
# Function: record_countdown
# --------------------------
# prints out a countdown
def record_countdown (self):
print "3"
time.sleep (0.5)
print "2"
time.sleep (0.5)
print "1"
time.sleep (0.5)
print "--- record ---"
# Function: record_gesture
# ------------------------
# record a single gesture
def record_gesture (self):
num_examples_recorded = 0
max_examples = 10
### Step 1: have them name the gesture ###
print_message ("What is this gesture called?")
gesture_name = raw_input("---> ")
print_message ("Now we will begin recording " + str(max_examples) + " examples of this gesture, " + str(gesture_name) + ". Press Enter when ready.")
sys.stdin.readline ()
record_gesture = Gesture (gesture_name)
#--- initialize parameters ---
is_recording = False
num_frames_recorded = 0
while (num_examples_recorded < max_examples):
frame = self.get_frame ()
record_gesture.add_frame (frame)
if record_gesture.is_full ():
### --- Notify of recording status --- ###
if is_recording:
print "."
num_frames_recorded += 1
else:
print "x"
### --- Check if we should end the recording --- ###
if num_frames_recorded >= record_gesture.gesture_length:
print_message ("### Recording Complete ###")
is_recording = False
num_frames_recorded = 0
num_examples_recorded += 1
self.gesture_recognizer.save_gesture(record_gesture)
### --- Check if we should start the recording --- ###
while sys.stdin in select.select([sys.stdin], [], [], 0)[0]:
line = sys.stdin.readline()
if line:
print_message ("### Started Recording ###")
is_recording = True
# Function: train_main
# --------------------
# train the classifier
def train_main (self):
### Step 1: load in all the gestures ###
print_message ("Loading gestures")
self.gesture_recognizer.load_gestures ()
self.gesture_recognizer.print_gestures_stats ()
### Step 2: train the HMMs ###
print_message ("Getting hmms")
self.gesture_recognizer.get_hmms ()
### Step 3: get examples ###
print_message ("Getting examples for training/testing")
self.gesture_recognizer.get_all_examples ()
self.gesture_recognizer.split_training_testing_examples ()
### Step 4: train the classifier and save the entire model ###
self.gesture_recognizer.train_classifier ()
self.gesture_recognizer.save_model ()
### Step 5: evaluate the classifier ###
self.gesture_recognizer.evaluate_classifier ()
########################################################################################################################
##############################[ --- Synth Main --- ]####################################################################
########################################################################################################################
# Function: synth_main_disrcete
# --------------------
# records discrete gestures and classifies them for you.
def synth_main_discrete (self):
self.gesture_recognizer.load_model ()
print_message ("Recording Discrete events")
while (True):
### Step 1: initialize the gesture ###
observed_gesture = Gesture ()
### Step 2: start the recording ###
self.record_countdown ()
### Step 3: fill it with frames ###
while not observed_gesture.is_full ():
frame = self.get_frame ()
observed_gesture.add_frame (frame)
### Step 4: stop the recording and classify ###
print_message ("### Recording Complete ###")
self.gesture_recognizer.classify_gesture (observed_gesture)
print_message("enter to continue")
sys.stdin.readline ()
# Function: get_gesture
# ---------------------
# function to wait on gestures
def get_gesture (self, observed_gesture):
### --- add the current frame --- ###
frame = self.get_frame ()
observed_gesture.add_frame (frame)
if observed_gesture.is_full ():
### --- get classification results --- ###
classification_results = self.gesture_recognizer.classify_gesture (observed_gesture)
### --- interpret them --- ###
return self.classification_results
# Function: get_coords
# --------------------
# returns (x,y,z) of the hand
def get_continuous_coords (self):
### --- add the current frame --- ###
frame = self.get_frame ()
if len(frame.hands) == 0:
return None
else:
position = hands[0].palm_position
return (position[0], position[1], posiiton[2])
# Function: get_position_and_orientation
# --------------------------------------
# given a frame, this returns the (palm_position, palm_orientation) if we observe
# a fist (0 fingers visible); (None, None) otherwise
def get_position_and_orientation (self, frame):
### Step 1: peace out if there are no hands ###
hands = frame.hands
if len(hands) == 0:
return (None, None)
### Step 2: peace out if there are any fingers (not a fist) ###
fingers = hands[0].fingers
if len (fingers) > 0:
return (None, None)
### Step 3: get position and orientation ###
hand = hands[0]
palm_position = hands[0].palm_position
position = (palm_position[0], palm_position[1], palm_position[2])
palm_normal = hands[0].palm_normal
orientation = (palm_normal[0], palm_normal[1], palm_normal[2])
return (position, orientation)
# Function: synth_main
# --------------------
# maintains a 70-frame gesture and tries to classify it
def synth_main (self):
### Step 1: start the max patch ###
self.max_interface.send_gesture ('Start')
### Step 2: initialize local data ###
print_message ("Entering Main Loop: Continuous Gesture Recognition")
self.gesture_recognizer.load_model ()
observed_gesture = Gesture ()
### Step 3: enter main loop ###
while (True):
### Step 1: add the current frame to observed_gesture ###
frame = self.get_frame ()
observed_gesture.add_frame (frame)
### Step 2: get position and orientation (returns (None, None) if not a fist) ###
(palm_position, palm_orientation) = self.get_position_and_orientation (frame)
### Step 3: Get the gesture, if appropriate ###
send_gesture = None
if observed_gesture.is_full ():
classification_results = self.gesture_recognizer.classify_gesture (observed_gesture)
if classification_results:
prediction = classification_results [0]
prediction_prob = classification_results [1]
print_message("Prediction: " + str(prediction) + " | Probability: " + str(prediction_prob))
send_gesture = prediction
observed_gesture.clear ()
### Step 4: send a gesture to max if one was observed ###
if send_gesture:
self.max_interface.send_gesture (send_gesture)
### Step 5: Send hand state to max if one was observed ###
if len(frame.hands) > 0:
self.max_interface.send_hand_state (frame.hands[0])
class Controller_Listener(Leap.Listener):
#--- Member Objects ---
max_interface = None # Interface w/ max
leap_gesture = None # Recognition of gestures
#--- Gestures ---
available_gestures = ["no_hands", "one_hand", "two_hands"] # list of available gestures
# Function: Constructor
# ---------------------
# creates max_interface and leap_gesture
def on_init(self, controller):
### Step 1: create max interface ###
self.max_interface = Max_Interface ()
### Step 2: notify of initialization ###
print_status ("Controller Listener", "controller initialized")
########################################################################################################################
##############################[ --- Initialization/Finalization --- ]###################################################
########################################################################################################################
# Function: on_connect
# --------------------
# callback function for when the controller is connected
def on_connect(self, controller):
print_status ("Controller Listener", "controller connected")
# Enable gestures
controller.enable_gesture(Leap.Gesture.TYPE_CIRCLE);
controller.enable_gesture(Leap.Gesture.TYPE_KEY_TAP);
controller.enable_gesture(Leap.Gesture.TYPE_SCREEN_TAP);
controller.enable_gesture(Leap.Gesture.TYPE_SWIPE);
# Function: on_disconnect
# -----------------------
# callback function for when the controller is disconnected
def on_disconnect(self, controller):
print_status ("Controller Listener", "Controller disconnected")
# Function: on_exit
# -----------------
# callback function for exit of the program
def on_exit(self, controller):
print_status ("Controller Listener", "Exiting")
########################################################################################################################
##############################[ --- Frame Processing --- ]##############################################################
########################################################################################################################
# Function: print_frame
# ---------------------
# prints a user-readable format of the current frame
def print_frame (self, frame):
print "Frame id: %d, timestamp: %d, hands: %d, fingers: %d, tools: %d, gestures: %d" % (
frame.id, frame.timestamp, len(frame.hands), len(frame.fingers), len(frame.tools), len(frame.gestures()))
# Function: on_frame
# ------------------
# this function is called for every frame that is observed from the leap.
def on_frame(self, controller):
frame = controller.frame()
if len(frame.hands) == 0:
self.max_interface.send_gesture ("no_hands")
elif len(frame.hands) == 1:
self.max_interface.send_gesture ("one_hand")
elif len(frame.hands) == 2:
self.max_interface.send_gesture ("two_hands")
self.print_frame (frame)
if not frame.hands.is_empty:
# Get the first hand
hand = frame.hands[0]
# Check if the hand has any fingers
fingers = hand.fingers
if not fingers.is_empty:
# Calculate the hand's average finger tip position
avg_pos = Leap.Vector()
for finger in fingers:
avg_pos += finger.tip_position
avg_pos /= len(fingers)
print "Hand has %d fingers, average finger tip position: %s" % (
len(fingers), avg_pos)
# Get the hand's sphere radius and palm position
print "Hand sphere radius: %f mm, palm position: %s" % (
hand.sphere_radius, hand.palm_position)
# Get the hand's normal vector and direction
normal = hand.palm_normal
direction = hand.direction
# Calculate the hand's pitch, roll, and yaw angles
print "Hand pitch: %f degrees, roll: %f degrees, yaw: %f degrees" % (
direction.pitch * Leap.RAD_TO_DEG,
normal.roll * Leap.RAD_TO_DEG,
direction.yaw * Leap.RAD_TO_DEG)
# Gestures
for gesture in frame.gestures():
if gesture.type == Leap.Gesture.TYPE_CIRCLE:
circle = CircleGesture(gesture)
# Determine clock direction using the angle between the pointable and the circle normal
if circle.pointable.direction.angle_to(circle.normal) <= Leap.PI/4:
clockwiseness = "clockwise"
else:
clockwiseness = "counterclockwise"
# Calculate the angle swept since the last frame
swept_angle = 0
if circle.state != Leap.Gesture.STATE_START:
previous_update = CircleGesture(controller.frame(1).gesture(circle.id))
swept_angle = (circle.progress - previous_update.progress) * 2 * Leap.PI
print "Circle id: %d, %s, progress: %f, radius: %f, angle: %f degrees, %s" % (
gesture.id, self.state_string(gesture.state),
circle.progress, circle.radius, swept_angle * Leap.RAD_TO_DEG, clockwiseness)
if gesture.type == Leap.Gesture.TYPE_SWIPE:
swipe = SwipeGesture(gesture)
print "Swipe id: %d, state: %s, position: %s, direction: %s, speed: %f" % (
gesture.id, self.state_string(gesture.state),
swipe.position, swipe.direction, swipe.speed)
if gesture.type == Leap.Gesture.TYPE_KEY_TAP:
keytap = KeyTapGesture(gesture)
print "Key Tap id: %d, %s, position: %s, direction: %s" % (
gesture.id, self.state_string(gesture.state),
keytap.position, keytap.direction )
if gesture.type == Leap.Gesture.TYPE_SCREEN_TAP:
screentap = ScreenTapGesture(gesture)
print "Screen Tap id: %d, %s, position: %s, direction: %s" % (
gesture.id, self.state_string(gesture.state),
screentap.position, screentap.direction )
if not (frame.hands.is_empty and frame.gestures().is_empty):
print ""
def state_string(self, state):
if state == Leap.Gesture.STATE_START:
return "STATE_START"
if state == Leap.Gesture.STATE_UPDATE:
return "STATE_UPDATE"
if state == Leap.Gesture.STATE_STOP:
return "STATE_STOP"
if state == Leap.Gesture.STATE_INVALID:
return "STATE_INVALID"
class Controller_Listener(Leap.Listener):
#--- Member Objects ---
max_interface = None # Interface w/ max
leap_gesture = None # Recognition of gestures
#--- Gestures ---
available_gestures = ["no_hands", "one_hand",
"two_hands"] # list of available gestures
# Function: Constructor
# ---------------------
# creates max_interface and leap_gesture
def on_init(self, controller):
### Step 1: create max interface ###
self.max_interface = Max_Interface()
### Step 2: notify of initialization ###
print_status("Controller Listener", "controller initialized")
########################################################################################################################
##############################[ --- Initialization/Finalization --- ]###################################################
########################################################################################################################
# Function: on_connect
# --------------------
# callback function for when the controller is connected
def on_connect(self, controller):
print_status("Controller Listener", "controller connected")
# Enable gestures
controller.enable_gesture(Leap.Gesture.TYPE_CIRCLE)
controller.enable_gesture(Leap.Gesture.TYPE_KEY_TAP)
controller.enable_gesture(Leap.Gesture.TYPE_SCREEN_TAP)
controller.enable_gesture(Leap.Gesture.TYPE_SWIPE)
# Function: on_disconnect
# -----------------------
# callback function for when the controller is disconnected
def on_disconnect(self, controller):
print_status("Controller Listener", "Controller disconnected")
# Function: on_exit
# -----------------
# callback function for exit of the program
def on_exit(self, controller):
print_status("Controller Listener", "Exiting")
########################################################################################################################
##############################[ --- Frame Processing --- ]##############################################################
########################################################################################################################
# Function: print_frame
# ---------------------
# prints a user-readable format of the current frame
def print_frame(self, frame):
print "Frame id: %d, timestamp: %d, hands: %d, fingers: %d, tools: %d, gestures: %d" % (
frame.id, frame.timestamp, len(frame.hands), len(
frame.fingers), len(frame.tools), len(frame.gestures()))
# Function: on_frame
# ------------------
# this function is called for every frame that is observed from the leap.
def on_frame(self, controller):
frame = controller.frame()
if len(frame.hands) == 0:
self.max_interface.send_gesture("no_hands")
elif len(frame.hands) == 1:
self.max_interface.send_gesture("one_hand")
elif len(frame.hands) == 2:
self.max_interface.send_gesture("two_hands")
self.print_frame(frame)
if not frame.hands.is_empty:
# Get the first hand
hand = frame.hands[0]
# Check if the hand has any fingers
fingers = hand.fingers
if not fingers.is_empty:
# Calculate the hand's average finger tip position
avg_pos = Leap.Vector()
for finger in fingers:
avg_pos += finger.tip_position
avg_pos /= len(fingers)
print "Hand has %d fingers, average finger tip position: %s" % (
len(fingers), avg_pos)
# Get the hand's sphere radius and palm position
print "Hand sphere radius: %f mm, palm position: %s" % (
hand.sphere_radius, hand.palm_position)
# Get the hand's normal vector and direction
normal = hand.palm_normal
direction = hand.direction
# Calculate the hand's pitch, roll, and yaw angles
print "Hand pitch: %f degrees, roll: %f degrees, yaw: %f degrees" % (
direction.pitch * Leap.RAD_TO_DEG,
normal.roll * Leap.RAD_TO_DEG, direction.yaw * Leap.RAD_TO_DEG)
# Gestures
for gesture in frame.gestures():
if gesture.type == Leap.Gesture.TYPE_CIRCLE:
circle = CircleGesture(gesture)
# Determine clock direction using the angle between the pointable and the circle normal
if circle.pointable.direction.angle_to(
circle.normal) <= Leap.PI / 4:
clockwiseness = "clockwise"
else:
clockwiseness = "counterclockwise"
# Calculate the angle swept since the last frame
swept_angle = 0
if circle.state != Leap.Gesture.STATE_START:
previous_update = CircleGesture(
controller.frame(1).gesture(circle.id))
swept_angle = (circle.progress -
previous_update.progress) * 2 * Leap.PI
print "Circle id: %d, %s, progress: %f, radius: %f, angle: %f degrees, %s" % (
gesture.id, self.state_string(
gesture.state), circle.progress, circle.radius,
swept_angle * Leap.RAD_TO_DEG, clockwiseness)
if gesture.type == Leap.Gesture.TYPE_SWIPE:
swipe = SwipeGesture(gesture)
print "Swipe id: %d, state: %s, position: %s, direction: %s, speed: %f" % (
gesture.id, self.state_string(gesture.state),
swipe.position, swipe.direction, swipe.speed)
if gesture.type == Leap.Gesture.TYPE_KEY_TAP:
keytap = KeyTapGesture(gesture)
print "Key Tap id: %d, %s, position: %s, direction: %s" % (
gesture.id, self.state_string(
gesture.state), keytap.position, keytap.direction)
if gesture.type == Leap.Gesture.TYPE_SCREEN_TAP:
screentap = ScreenTapGesture(gesture)
print "Screen Tap id: %d, %s, position: %s, direction: %s" % (
gesture.id, self.state_string(gesture.state),
screentap.position, screentap.direction)
if not (frame.hands.is_empty and frame.gestures().is_empty):
print ""
def state_string(self, state):
if state == Leap.Gesture.STATE_START:
return "STATE_START"
if state == Leap.Gesture.STATE_UPDATE:
return "STATE_UPDATE"
if state == Leap.Gesture.STATE_STOP:
return "STATE_STOP"
if state == Leap.Gesture.STATE_INVALID:
return "STATE_INVALID"
