Updated command line options

Added two command line options (smooth aggressiveness and smooth
falloff) and updated the help option.

Author: wyager

FingerControl.py

@@ -14,13 +14,13 @@
 
 
 class Finger_Control_Listener(Leap.Listener):  #The Listener that we attach to the controller. This listener is for pointer finger movement
-    def __init__(self, mouse):
+    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 = mouse.absolute_cursor()  #The cursor object that lets us control mice cross-platform
-        self.mouse_position_smoother = mouse_position_smoother() #Keeps the cursor from fidgeting
+        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
 

MiscFunctions.py

@@ -13,10 +13,15 @@
 
 #Smooths the mouse's position
 class mouse_position_smoother(object): 
-    def __init__(self, smooth_aggressiveness=8, smooth_falloff=1.3):
+    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 = smooth_aggressiveness
+        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:

PyLeapMouse.py

@@ -12,25 +12,46 @@
 from PalmControl import Palm_Control_Listener  #For palm-tilt based control
 from FingerControl import Finger_Control_Listener  #For finger-pointing control
 
+def show_help():
+    print "----------------------------------PyLeapMouse----------------------------------"
+    print "Use --finger (or blank) for pointer finger control, and --palm for palm control."
+    print "Set smooth aggressiveness (# samples) with \"--smooth-aggressiveness [# samples]\""
+    print "Set smooth falloff with \"--smooth-falloff [% per sample]\""
+    print "Read README.md for even more info.\n"
 
 def main():
-    print "Use --finger (or no options) for pointer finger control,\nand --palm for palm control.\nRead README.md for more info."
+    if "-h" in sys.argv or "--help" in sys.argv:
+        show_help()
+        return
+
+    print "----------------------------------PyLeapMouse----------------------------------"
+    print "Use --finger (or blank) for pointer finger control, and --palm for palm control."
+    print "Use -h or --help for more info.\n"
+
+    #Default
+    finger_mode = True
+    smooth_aggressiveness = 8
+    smooth_falloff = 1.3
+
+    for i in range(0,len(sys.argv)):
+        arg = sys.argv[i].lower()
+        if "--palm" in arg:
+            finger_mode = False
+        if "--smooth-falloff" in arg:
+            smooth_falloff = float(sys.argv[i+1])
+        if "--smooth-aggressiveness" in arg:
+            smooth_aggressiveness = int(sys.argv[i+1])
 
     listener = None;  #I'm tired and can't think of a way to organize this segment nicely
 
     #Create a custom listener object which controls the mouse
-    if len(sys.argv) == 1:  #Finger pointer mode
-        listener = Finger_Control_Listener(Mouse)
+    if finger_mode:  #Finger pointer mode
+        listener = Finger_Control_Listener(Mouse, smooth_aggressiveness=smooth_aggressiveness, smooth_falloff=smooth_falloff)
         print "Using finger mode..."
-    elif sys.argv[1].lower() == "--finger":  #Also finger control mode
-        listener = Finger_Control_Listener(Mouse)
-        print "Using finger mode..."
-    elif sys.argv[1].lower() == "--palm":  #Palm control mode
+    else:  #Palm control mode
         listener = Palm_Control_Listener(Mouse)
         print "Using palm mode..."
-    else:
-        print "Error parsing input options"
-        exit(1)
+
 
     controller = Leap.Controller()  #Get a Leap controller
     print "Adding Listener."

README.md

@@ -25,6 +25,7 @@ Two hands in frame: Left hand controls action.
     Two fingers open: Scrolling. Scrolling with right hand movement.  
 This is a somewhat unintuitive method of operation, but I find that it gives exceptionally better control than the most obvious "point-at-screen" method of mouse control. With this two-handed tilt based mode, it is easy to hit and properly engage small buttons, scroll through webpages, etc.  
 
+
 NOTES:  
 This is a spare-time project, so it's not perfect quality. However, I tried to keep the code clean and readable. Let me know if you find any bugs (which there are certainly at least a few of). You can reach me at  will (dot) yager (at) gmail (dot) (what the gmail domain ends in).  
 The contents of the files are as follows:  
@@ -36,9 +37,15 @@ OSX/Windows:
     Mouse.py: A set of generic commands and classes to abstract away from OS-Specific mouse commands  
 Geometry.py: Geometric functions  
 MiscFunctions.py: Things that aren't strictly geometry and aren't specific to any interface style  
-README.md: You are here
+README.md: You are here  
+
+ADVANCED OPTIONS:  
+`--smooth-aggressiveness [value]` sets the number of samples to use for pointer finger mouse smoothing.  
+`--smooth-falloff [value]` sets the rate at which previous samples lose importance.  
+For every sample back in time, the previous location of the mouse is weighted with weight smooth_falloff^(-#sample).  
+So if smooth_falloff = 1.2, the current frame has weight 1/(1.2^0)=1, but the frame from 5 frames ago has weight 1/(1.2^5) = .4  
+By default, the smooth aggressiveness is 8 frames with a falloff of 1.3.  
 
 TODO:  
-Automatic library import for x86/x86_64 (libraries already import for proper OS automatically).  
 Add proper relative mouse movement. Should be pretty easy on Windows, not sure how to do so on OS X.  
 Add multiple monitor support for absolute mouse mode (and OS X's pseudo-relative mode).