First attempts to adding linux support. It's broken.

Author: grimborg

FingerControl.py

@@ -4,12 +4,7 @@
 
 
 import math
-import sys
-if sys.platform == "darwin":
-    import OSX.Leap as Leap
-else:
-    import Windows.Leap as Leap
-import Geometry
+from leap import Leap, Mouse
 from MiscFunctions import *
 
 

Geometry.py

@@ -3,11 +3,7 @@
 
 
 import math
-import sys
-if sys.platform == "darwin":
-    import OSX.Leap as Leap
-else:
-    import Windows.Leap as Leap
+from leap import Leap
 
 
 def to_vector(leap_vector):

Linux/Leap.py

@@ -0,0 +1,122 @@
+from pymouse import PyMouse
+mouse = PyMouse()
+
+def AbsoluteMouseMove(posx,posy):
+    print 'move to', posx, posy
+    mouse.move(int(posx), int(posy))
+
+def AbsoluteMouseClick(posx,posy):
+    print 'click on ', posx, posy
+    mouse.click(posx, posy)
+
+def AbsoluteMouseClickDown(posx, posy):
+    pass
+
+def AbsoluteMouseClickUp(posx, posy):
+    pass
+
+def AbsoluteMouseDrag(posx, posy):  #Only relevant in OS X(?)
+    mouse.move(posx, posy)
+
+def AbsoluteMouseRightClick(posx,posy):
+    mouse.click(posx, posy, button=2)
+
+def RelativeMouseScroll(x_movement, y_movement):  #Movements should be no larger than +- 10
+    mouse.click(x_movement, y_movement, button=3)
+
+def GetDisplayWidth():
+    return mouse.screen_size()[0]
+
+def GetDisplayHeight():
+    return mouse.screen_size()[1]
+
+
+#A cursor that does commands based on absolute position (good for finger pointing)
+class absolute_cursor(object):
+    def __init__(self):
+        self.x_max = GetDisplayWidth() - 1
+        self.y_max = GetDisplayHeight() - 1
+        self.left_button_pressed = False
+        self.x = 0
+        self.y = 0
+
+    def move(self, posx, posy):  #Move to coordinates
+        self.x = posx
+        self.y = posy
+        if self.x > self.x_max:
+            self.x = self.x_max
+        if self.y > self.y_max:
+            self.y = self.y_max
+        if self.x < 0.0:
+            self.x = 0.0
+        if self.y < 0.0:
+            self.y = 0.0
+        if self.left_button_pressed:  #We are dragging
+            AbsoluteMouseDrag(self.x, self.y)
+        else:  #We are not dragging
+            AbsoluteMouseMove(self.x, self.y)
+
+    def click(self, posx=None, posy=None):  #Click at coordinates (current coordinates by default)
+        if posx == None:
+            posx = self.x
+        if posy == None:
+            posy = self.y
+        AbsoluteMouseClick(posx, posy)
+
+    def set_left_button_pressed(self, boolean_button):  #Set the state of the left button
+        if boolean_button == True:  #Pressed
+            self.click_down()
+        else:  #Not pressed
+            self.click_up()
+
+    def click_down(self, posx=None, posy=None):
+        if posx == None:
+            posx = self.x
+        if posy == None:
+            posy = self.y
+        AbsoluteMouseClickDown(posx, posy)
+        self.left_button_pressed = True
+
+    def click_up(self, posx=None, posy=None):
+        if posx == None:
+            posx = self.x
+        if posy == None:
+            posy = self.y
+        AbsoluteMouseClickUp(posx, posy)
+        self.left_button_pressed = False
+
+    def rightClick(self, posx=None, posy=None):
+        if posx == None:
+            posx = self.x
+        if posy == None:
+            posy = self.y
+        AbsoluteMouseRightClick(posx, posy)
+
+    def scroll(self, x_movement, y_movement):
+        RelativeMouseScroll(x_movement, y_movement)
+
+
+#Allows for relative movement instead of absolute movement. This implementation is not a "true" relative mouse,
+#but is really just a relative wrapper for an absolute mouse. Not the best way to do it, but I need to
+#figure out how to send raw "mouse moved _this amount_" events. This class is (as of writing) untested.
+#It's only here in case someone else wants to figure out how to do this properly on OS X.
+#I will be "actually" implementing this on Windows shortly. OSX TBD.
+class relative_cursor(absolute_cursor):
+    def __init__(self):
+        absolute_cursor.__init__(self)
+
+    def move(self, x_amt, y_amt):
+        self.x = self.x + x_amt
+        self.y = self.y + y_amt
+        if self.x > self.x_max:
+            self.x = self.x_max
+        if self.y > self.y_max:
+            self.y = self.y_max
+        if self.x < 0.0:
+            self.x = 0.0
+        if self.y < 0.0:
+            self.y = 0.0
+        if self.left_button_pressed:  #We are dragging
+            AbsoluteMouseDrag(self.x, self.y)
+        else:  #We are not dragging
+            AbsoluteMouseMove(self.x, self.y)

Linux/LeapPython.so

@@ -4,15 +4,11 @@
 
 
 import math
-import sys
-if sys.platform == "darwin":
-    import OSX.Leap as Leap
-else:
-    import Windows.Leap as Leap
+from leap import Leap
 import Geometry
 
 #Smooths the mouse's position
-class mouse_position_smoother(object): 
+class mouse_position_smoother(object):
     def __init__(self, smooth_aggressiveness, smooth_falloff):
         #Input validation
         if smooth_aggressiveness < 1:
@@ -80,7 +76,7 @@ def signal(self, signal_value):
             if self.state_counters[i] < 0: self.state_counters[i] = 0
             if self.state_counters[i] >= self.debounce_time:  #Confirmed new state at index i
                 self.state_counters[i] = self.debounce_time
-                for x in range(0,len(self.state_counters)): 
+                for x in range(0,len(self.state_counters)):
                     if x is not i: self.state_counters[x] = 0  #Zero out all other state counters
                 self.state = i  #Save the new state
         return self.state

Linux/Mouse.py

@@ -4,11 +4,7 @@
 
 
 import math
-import sys
-if sys.platform == "darwin":
-    import OSX.Leap as Leap
-else:
-    import Windows.Leap as Leap
+from leap import Leap, Mouse
 import Geometry
 from MiscFunctions import *
 
@@ -42,7 +38,7 @@ def on_frame(self, controller):
                 rightmost_hand = max(frame.hands, key=lambda hand: hand.palm_position.x)  #Get rightmost hand
                 leftmost_hand = min(frame.hands, key=lambda hand: hand.palm_position.x)  #Get leftmost hand
                 self.do_gesture_recognition(leftmost_hand, rightmost_hand)  #This will run with >1 hands in frame
-                                  
+
     def do_mouse_stuff(self, hand):  #Take a hand and use it as a mouse
          hand_normal_direction = Geometry.to_vector(hand.palm_normal)
          hand_direction = Geometry.to_vector(hand.direction)
@@ -58,7 +54,7 @@ def do_gesture_recognition(self, gesture_hand, mouse_hand):
         if len(gesture_hand.fingers) == 2:  #Two open fingers on gesture hand (scroll mode)
             self.gesture_debouncer.signal(2)  #Tell the debouncer we've seen this gesture
         elif len(gesture_hand.fingers) == 1:  #One open finger on gesture hand (click down)
-            self.gesture_debouncer.signal(1) 
+            self.gesture_debouncer.signal(1)
         else:  #No open fingers or 3+ open fingers (click up/no action)
             self.gesture_debouncer.signal(0)
         #Now that we've told the debouncer what we *think* the current gesture is, we must act
@@ -72,7 +68,7 @@ def do_gesture_recognition(self, gesture_hand, mouse_hand):
             self.do_mouse_stuff(mouse_hand)  #We may want to click and drag
         elif self.gesture_debouncer.state == 0:  #Move cursor mode
             if self.cursor.left_button_pressed: self.cursor.click_up()  #Click up (if needed)
-            self.do_mouse_stuff(mouse_hand)   
+            self.do_mouse_stuff(mouse_hand)
 
     def velocity_to_scroll_amount(self, velocity):  #Converts a finger velocity to a scroll velocity
         #The following algorithm was designed to reflect what I think is a comfortable

Linux/__init__.py

@@ -1,14 +1,7 @@
 #William Yager
 #Leap Python mouse controller POC
-
-
 import sys
-if sys.platform == "darwin":
-    import OSX.Leap as Leap
-    import OSX.Mouse as Mouse
-else:
-    import Windows.Leap as Leap
-    import Windows.Mouse as Mouse
+from leap import Leap, Mouse
 from PalmControl import Palm_Control_Listener  #For palm-tilt based control
 from FingerControl import Finger_Control_Listener  #For finger-pointing control
 
@@ -63,4 +56,4 @@ def main():
     #Remove the sample listener when done
     controller.remove_listener(listener)
 
-main()
+main()

Linux/libLeap.so

@@ -0,0 +1,10 @@
+import sys
+if sys.platform == "darwin":
+    import OSX.Leap as Leap
+    import OSX.Mouse as Mouse
+elif 'linux' in sys.platform:
+    import Linux.Leap as Leap
+    import Linux.Mouse as Mouse
+else:
+    import Windows.Leap as Leap
+    import Windows.Mouse as Mouse