Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
244 lines (216 sloc) 8.81 KB
/**
* LeapMotionP5
*
* LeapMotionP5 library for Processing. Copyright (c) 2012-2013 held jointly by the individual
* authors.
*
* LeapMotionP5 library for Processing is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free Software Foundation,
* either version 3 of the License, or (at your option) any later version.
*
* LeapMotionP5 for Processing is distributed in the hope that it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with LeapMotionP5 library
* for Processing. If not, see http://www.gnu.org/licenses/.
*
* Leap Developer SDK. Copyright (C) 2012-2013 Leap Motion, Inc. All rights reserved.
*/
import java.util.Date;
import java.util.LinkedList;
import java.util.concurrent.ConcurrentSkipListMap;
import java.util.concurrent.CopyOnWriteArrayList;
import processing.core.PApplet;
import com.leapmotion.leap.CircleGesture;
import com.leapmotion.leap.Controller;
import com.leapmotion.leap.Frame;
import com.leapmotion.leap.Gesture;
import com.leapmotion.leap.Gesture.State;
import com.leapmotion.leap.GestureList;
import com.leapmotion.leap.KeyTapGesture;
import com.leapmotion.leap.Listener;
import com.leapmotion.leap.ScreenTapGesture;
import com.leapmotion.leap.SwipeGesture;
/**
* LeapMotionListener.java
*
* @author Marcel Schwittlick
* @modified 04.02.2013
*
* this listener is listening for the events of the offical leap motion sdk
*/
class LeapMotionListener extends Listener {
private LeapMotionP5 leap;
protected int maxFramesToRecord = 1000;
private String callbackMethodNameCircle;
private String callbackMethodNameSwipe;
private String callbackMethodNameScreenTap;
private String callbackMethodNameKeyTap;
/**
*
* @param p PApplet the processing applet
* @param leap LeapMotionP5 an instance of the LeapMotionP5 class
*/
public LeapMotionListener(LeapMotionP5 leap) {
this.leap = leap;
this.leap.currentFrame = new Frame();
this.leap.lastFrames = new LinkedList<Frame>();
this.leap.lastFramesInclProperTimestamps = new ConcurrentSkipListMap<Date, Frame>();
this.leap.oldFrames = new CopyOnWriteArrayList<Frame>();
this.leap.oldControllers = new LinkedList<Controller>();
this.callbackMethodNameCircle = "circleGestureRecognized";
this.callbackMethodNameSwipe = "swipeGestureRecognized";
this.callbackMethodNameScreenTap = "screenTapGestureRecognized";
this.callbackMethodNameKeyTap = "keyTapGestureRecognized";
}
public void onInit(Controller controller) {
System.out.println("Leap Motion Initialized");
}
public void onConnect(Controller controller) {
leapConnection = true;
System.out.println("Leap Motion Connected");
}
public void onDisconnect(Controller controller) {
leapConnection=false;
System.out.println("Leap Motion Disconnected");
}
public void onExit(Controller controller) {
System.out.println("Leap Motion Exited");
}
private void invokeCallback(Gesture gesture) {
PApplet parent = this.leap.getParent();
if (parent != null) {
switch (gesture.type()) {
case TYPE_CIRCLE:
CircleGesture circleGesture = new CircleGesture(gesture);
String clockwiseness;
if (circleGesture.pointable().direction().angleTo(circleGesture.normal()) <= Math.PI / 4) {
// Clockwise if angle is less than 90 degrees
clockwiseness = "clockwise";
} else {
clockwiseness = "counterclockwise";
}
try {
parent.getClass()
.getMethod(this.callbackMethodNameCircle, CircleGesture.class, String.class)
.invoke(parent, circleGesture, clockwiseness);
} catch (Exception e) {
PApplet.println(e.getMessage() + " CALLBACK ERROR");
}
break;
case TYPE_SWIPE:
SwipeGesture swipeGesture = new SwipeGesture(gesture);
try {
parent.getClass().getMethod(this.callbackMethodNameSwipe, SwipeGesture.class)
.invoke(parent, swipeGesture);
} catch (Exception e) {
PApplet.println(e.getMessage() + " CALLBACK ERROR");
}
break;
case TYPE_SCREEN_TAP:
ScreenTapGesture screenTapGesture = new ScreenTapGesture(gesture);
try {
parent.getClass().getMethod(this.callbackMethodNameScreenTap, ScreenTapGesture.class)
.invoke(parent, screenTapGesture);
} catch (Exception e) {
PApplet.println(e.getMessage() + " CALLBACK ERROR");
}
break;
case TYPE_KEY_TAP:
KeyTapGesture keyTapGesture = new KeyTapGesture(gesture);
try {
parent.getClass().getMethod(this.callbackMethodNameKeyTap, KeyTapGesture.class)
.invoke(parent, keyTapGesture);
} catch (Exception e) {
PApplet.println(e.getMessage() + " CALLBACK ERROR");
}
break;
default:
break;
}
}
}
private void printGestureDetails(Gesture gesture, Controller controller) {
switch (gesture.type()) {
case TYPE_CIRCLE:
CircleGesture circle = new CircleGesture(gesture);
// Calculate clock direction using the angle between circle normal and pointable
String clockwiseness;
if (circle.pointable().direction().angleTo(circle.normal()) <= Math.PI / 4) {
// Clockwise if angle is less than 90 degrees
clockwiseness = "clockwise";
} else {
clockwiseness = "counterclockwise";
}
// Calculate angle swept since last frame
double sweptAngle = 0;
if (circle.state() != State.STATE_START) {
CircleGesture previousUpdate =
new CircleGesture(controller.frame(1).gesture(circle.id()));
sweptAngle = (circle.progress() - previousUpdate.progress()) * 2 * Math.PI;
}
System.out.println("Circle id: " + circle.id() + ", " + circle.state() + ", progress: "
+ circle.progress() + ", radius: " + circle.radius() + ", angle: "
+ Math.toDegrees(sweptAngle) + ", " + clockwiseness);
break;
case TYPE_SWIPE:
SwipeGesture swipe = new SwipeGesture(gesture);
System.out.println("Swipe id: " + swipe.id() + ", " + swipe.state() + ", position: "
+ swipe.position() + ", direction: " + swipe.direction() + ", speed: " + swipe.speed());
break;
case TYPE_SCREEN_TAP:
ScreenTapGesture screenTap = new ScreenTapGesture(gesture);
System.out.println("Screen Tap id: " + screenTap.id() + ", " + screenTap.state()
+ ", position: " + screenTap.position() + ", direction: " + screenTap.direction());
break;
case TYPE_KEY_TAP:
KeyTapGesture keyTap = new KeyTapGesture(gesture);
System.out.println("Key Tap id: " + keyTap.id() + ", " + keyTap.state() + ", position: "
+ keyTap.position() + ", direction: " + keyTap.direction());
break;
default:
System.out.println("Unknown gesture type.");
break;
}
}
private void processGestures(Controller controller) {
GestureList list = controller.frame().gestures();
if (list.isEmpty()) {
for (int i = 0; i < list.count(); i++) {
Gesture gesture = list.get(i);
invokeCallback(gesture);
// printGestureDetails(gesture, controller);
}
}
}
/**
* this is called about 100-120 times a second delevering a new frame with information from the
* leap tracking everything in its viewport. This is where most of the data which is accessible in
* processing is coming from
*/
public void onFrame(Controller controller) {
Frame frame = controller.frame();
this.leap.currentFrame = frame;
processGestures(controller);
// adding frames the list. making sure that only the newest frames are saved in order
if (leap.lastFrames.size() >= maxFramesToRecord) {
leap.lastFrames.removeFirst();
}
leap.lastFrames.add(frame);
// adding frames to the list. adding a proper timestamp to each frame object
if (leap.lastFramesInclProperTimestamps.size() >= maxFramesToRecord) {
leap.lastFramesInclProperTimestamps.remove(leap.lastFramesInclProperTimestamps.firstKey());
}
leap.lastFramesInclProperTimestamps.put(new Date(), frame);
// adding old frames to different object
if (leap.oldFrames.size() >= maxFramesToRecord) {
leap.oldFrames.remove(0);
}
leap.oldFrames.add(frame);
if (leap.oldControllers.size() >= maxFramesToRecord) {
leap.oldControllers.removeLast();
}
leap.oldControllers.add(controller);
}
}
You can’t perform that action at this time.