Merge remote-tracking branch 'origin/master' into removelibs

Author: pythonian4000

.gitignore

@@ -6,27 +6,26 @@
 *.egg-info
 *.wpr
 *.wpu
-.DS_Store
-.gitignore~
-.gitignore
+*~
 
 #files
 Leap.py
 
-
 #directories
 .idea
-
-#other
-dist
+bin
 build
+develop-eggs
+dist
 eggs
+lib
+lib64
 parts
-bin
-var
 sdist
-develop-eggs
+var
+
+#other
+.DS_Store
+.cleanup.sh
 .installed.cfg
-lib
-lib64
 pip-log.txt

FingerControl.py

@@ -4,22 +4,18 @@
 
 
 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 *
 
 
 class Finger_Control_Listener(Leap.Listener):  #The Listener that we attach to the controller. This listener is for pointer finger movement
-    def __init__(self, cursor):
+    def __init__(self, mouse, smooth_aggressiveness=8, smooth_falloff=1.3):
         super(Finger_Control_Listener, self).__init__()  #Initialize like a normal listener
         #Initialize a bunch of stuff specific to this implementation
         self.screen = None
         self.screen_resolution = (0,0)
-        self.cursor = cursor  #The cursor object that lets us control mice cross-platform
+        self.cursor = mouse.absolute_cursor()  #The cursor object that lets us control mice cross-platform
+        self.mouse_position_smoother = mouse_position_smoother(smooth_aggressiveness, smooth_falloff) #Keeps the cursor from fidgeting
         self.mouse_button_debouncer = debouncer(5)  #A signal debouncer that ensures a reliable, non-jumpy click
         self.most_recent_pointer_finger_id = None  #This holds the ID of the most recently used pointing finger, to prevent annoying switching
 
@@ -77,6 +73,7 @@ def do_mouse_stuff(self, hand):  #Take a hand and use it as a mouse
             if not math.isnan(intersection.x) and not math.isnan(intersection.y):  #If the finger intersects with the screen
                 x_coord = intersection.x * self.screen_resolution[0]  #x pixel of intersection
                 y_coord = (1.0 - intersection.y) * self.screen_resolution[1]  #y pixel of intersection
+                x_coord,y_coord = self.mouse_position_smoother.update((x_coord,y_coord)) #Smooth movement
                 self.cursor.move(x_coord,y_coord)  #Move the cursor
                 if has_thumb(hand):  #We've found a thumb!
                     self.mouse_button_debouncer.signal(True)  #We have detected a possible click. The debouncer ensures that we don't have click jitter

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):

LICENSE.txt

@@ -0,0 +1,9 @@
+Copyright (c) 2012, William Yager
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+Redistribution of this software in binary form or as source code as part of a  software package that is non-free or closed-source is forbidden without express written consent of the author.
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Linux/Leap.py

@@ -0,0 +1,134 @@
+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):
+    print 'left button down'
+    mouse.press(posx, posy)
+
+def AbsoluteMouseClickUp(posx, posy):
+    print 'left button up'
+    mouse.release(posx, posy)
+
+def AbsoluteMouseDrag(posx, posy):  #Only relevant in OS X(?)
+    mouse.move(posx, posy)
+
+def AbsoluteMouseRightClick(posx,posy):
+    mouse.click(posx, posy, button=2)
+
+def AbsoluteMouseScroll(posx, posy, up=True):  #PyUserInput doesn't appear to support relative scrolling
+    if up is True:
+        mouse.click(posx, posy, button=4)
+    elif up is False:
+        mouse.click(posx, posy, button=5)
+    #When PyUserInput > 0.1.5 is released, the following will work:
+    #mouse.scroll(posx, posy, up)
+
+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):
+        posx = self.x
+        posy = self.y
+        up = False
+        if y_movement < 0:
+            up = True
+        AbsoluteMouseScroll(posx, posy, up)
+
+
+#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/Mouse.py

@@ -4,13 +4,38 @@
 
 
 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):
+    def __init__(self, smooth_aggressiveness, smooth_falloff):
+        #Input validation
+        if smooth_aggressiveness < 1:
+            raise Exception("Smooth aggressiveness must be greater than 1.")
+        if smooth_falloff < 1:
+            raise Exception("Smooth falloff must be greater than 1.0.")
+        self.previous_positions = []
+        self.smooth_falloff = smooth_falloff
+        self.smooth_aggressiveness = int(smooth_aggressiveness)
+    def update(self, (x,y)):
+        self.previous_positions.append((x,y))
+        if len(self.previous_positions) > self.smooth_aggressiveness:
+            del self.previous_positions[0]
+        return self.get_current_smooth_value()
+    def get_current_smooth_value(self):
+        smooth_x = 0
+        smooth_y = 0
+        total_weight = 0
+        num_positions = len(self.previous_positions)
+        for position in range(0, num_positions):
+            weight = 1 / (self.smooth_falloff ** (num_positions - position))
+            total_weight += weight
+            smooth_x += self.previous_positions[position][0] * weight
+            smooth_y += self.previous_positions[position][1] * weight
+        smooth_x /= total_weight
+        smooth_y /= total_weight
+        return smooth_x, smooth_y
 
 class debouncer(object):  #Takes a binary "signal" and debounces it.
     def __init__(self, debounce_time):  #Takes as an argument the number of opposite samples it needs to debounce.
@@ -51,30 +76,12 @@ 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
 
 
-class mouse_manager(object):  #The original intent of this object was to allow for smoother mouse movements. However, I hope to eliminate it soon.
-    def __init__(self):
-        self.xcounter = 0.0
-        self.ycounter = 0.0
-
-    #Returns the integer part of the mouse movement, stores the leftover float part for later
-    def add(self, (x, y)):
-        self.xcounter = self.xcounter + x
-        self.ycounter = self.ycounter + y
-        split_x = math.modf(self.xcounter)  #Saves the float part (remainder) into the counter
-        split_y = math.modf(self.ycounter)  #And the int part into the movement
-        self.xcounter = split_x[0]
-        xmovement = int(split_x[1])
-        self.ycounter = split_y[0]
-        ymovement = int(split_y[1])
-        return xmovement, ymovement  
-
-
 def sort_fingers_by_distance_from_screen(fingers):
     new_finger_list = [finger for finger in fingers]  #Copy the list of fingers
     new_finger_list.sort(key=lambda x: x.tip_position.z)  #Sort by increasing z