/*
void LeapActions::onScreenTap( Leap::Gesture gesture )
{
// screen tap gesture
qDebug() << "ScreenTapGesture";
}
*/
void Leap::LeapActions::rotateGraph( Leap::Gesture gesture )
{
// swipe gesture
SwipeGesture swipe = gesture;
Vector direction = swipe.direction();
// >= instead of > to avoid edge case, no rotation would happen with abs direction[0] equal to abs direction[1]
if ( abs( direction[0] ) >= abs( direction[1] ) ) { // horizontal movement
if ( direction[0] > 0 ) {
cameraManipulator->rotateCamera( 0, 0, 1, 0, 0.05f );
}
else if ( direction[0] < 0 ) {
cameraManipulator->rotateCamera( 0, 0, 1, 0, -0.05f );
}
}
else { // vertical movement
if ( direction[1] > 0 ) {
cameraManipulator->rotateCamera( 0, 0 ,1, 0.05f, 0 );
}
else if ( direction[1] < 0 ) {
cameraManipulator->rotateCamera( 0, 0, 1, -0.05f, 0 );
}
}
}
void QLeapEventListener::onSwipe(const SwipeGesture &gesture)
{
QLeapGesture *listener = qobject_cast<QLeapGesture*>(m_listener);
float angle = (gesture.direction()).angleTo(Vector(1.0, 0.0, 0.0));
if(listener){
emit listener->swipe(angle, gesture.speed());
}
}
void Leap::LeapActions::moveCamera( Leap::Gesture gesture )
{
// swipe gesture
SwipeGesture swipe = gesture;
Vector direction = swipe.direction();
float gestureDuration = static_cast<float>( gesture.duration() )/1000.0f;
//skip zero movement gesture
if ( direction[0] == 0.0f && direction[1] == 0.0f && direction[2] == 0.0f ) {
return;
}
float absDir0 = abs( direction[0] );
float absDir1 = abs( direction[1] );
// compare direction[0] and direction[1] to find out what kind of movement are we working with
// >= instead of > to avoid edge case, no camera movement would happen with absDir0 equal to absDir1
if ( absDir0 >= absDir1 ) { // horizontal movement
if ( direction[0] > 0 ) {
qDebug() << "SwipeGesture - right";
cameraManipulator->enableCameraMovement( Leap::LeapCameraManipulator::Movement::RIGHT );
}
else if ( direction[0] < 0 ) {
qDebug() << "SwipeGesture - left";
cameraManipulator->enableCameraMovement( Leap::LeapCameraManipulator::Movement::LEFT );
}
}
else if ( absDir0 < absDir1 ) { // vertical movement
if ( direction[1] > 0 ) {
qDebug() << "SwipeGesture - down";
cameraManipulator->enableCameraMovement( Leap::LeapCameraManipulator::Movement::DOWN );
}
else if ( direction[1] < 0 ) {
qDebug() << "SwipeGesture - up";
cameraManipulator->enableCameraMovement( Leap::LeapCameraManipulator::Movement::UP );
}
}
else {
if ( direction[2] > 0 ) {
qDebug() << "SwipeGesture - backward";
cameraManipulator->enableCameraMovement( Leap::LeapCameraManipulator::Movement::BACKWARD );
}
else if ( direction[2] < 0 ) {
qDebug() << "SwipeGesture - forward";
cameraManipulator->enableCameraMovement( Leap::LeapCameraManipulator::Movement::FORWARD );
}
}
//if we get here, the camera is moving
// Sleep( ( DWORD )gestureDuration );
LeapSleeper::sleep(gestureDuration);
cameraManipulator->disableCameraMovement();
}
void SampleListener::onFrame(const Controller& controller) {
// Get the most recent frame and report some basic information
const Frame frame = controller.frame();
std::cout << "Frame id: " << frame.id()
<< ", timestamp: " << frame.timestamp()
<< ", hands: " << frame.hands().count()
<< ", fingers: " << frame.fingers().count()
<< ", tools: " << frame.tools().count()
<< ", gestures: " << frame.gestures().count() << std::endl;
if (!frame.hands().isEmpty()) {
// Get the first hand
const Hand hand = frame.hands()[0];
// Check if the hand has any fingers
const FingerList fingers = hand.fingers();
if (!fingers.isEmpty()) {
// Calculate the hand's average finger tip position
Vector avgPos;
for (int i = 0; i < fingers.count(); ++i) {
avgPos += fingers[i].tipPosition();
}
avgPos /= (float)fingers.count();
std::cout << "Hand has " << fingers.count()
<< " fingers, average finger tip position" << avgPos << std::endl;
}
// Get the hand's sphere radius and palm position
std::cout << "Hand sphere radius: " << hand.sphereRadius()
<< " mm, palm position: " << hand.palmPosition() << std::endl;
// Get the hand's normal vector and direction
const Vector normal = hand.palmNormal();
const Vector direction = hand.direction();
// Calculate the hand's pitch, roll, and yaw angles
std::cout << "Hand pitch: " << direction.pitch() * RAD_TO_DEG << " degrees, "
<< "roll: " << normal.roll() * RAD_TO_DEG << " degrees, "
<< "yaw: " << direction.yaw() * RAD_TO_DEG << " degrees" << std::endl;
}
// Get gestures
const GestureList gestures = frame.gestures();
for (int g = 0; g < gestures.count(); ++g) {
Gesture gesture = gestures[g];
switch (gesture.type()) {
case Gesture::TYPE_CIRCLE:
{
CircleGesture circle = gesture;
std::string clockwiseness;
if (circle.pointable().direction().angleTo(circle.normal()) <= PI/4) {
clockwiseness = "clockwise";
} else {
clockwiseness = "counterclockwise";
}
// Calculate angle swept since last frame
float sweptAngle = 0;
if (circle.state() != Gesture::STATE_START) {
CircleGesture previousUpdate = CircleGesture(controller.frame(1).gesture(circle.id()));
sweptAngle = (circle.progress() - previousUpdate.progress()) * 2 * PI;
}
std::cout << "Circle id: " << gesture.id()
<< ", state: " << gesture.state()
<< ", progress: " << circle.progress()
<< ", radius: " << circle.radius()
<< ", angle " << sweptAngle * RAD_TO_DEG
<< ", " << clockwiseness << std::endl;
break;
}
case Gesture::TYPE_SWIPE:
{
SwipeGesture swipe = gesture;
std::cout << "Swipe id: " << gesture.id()
<< ", state: " << gesture.state()
<< ", direction: " << swipe.direction()
<< ", speed: " << swipe.speed() << std::endl;
break;
}
case Gesture::TYPE_KEY_TAP:
{
KeyTapGesture tap = gesture;
std::cout << "Key Tap id: " << gesture.id()
<< ", state: " << gesture.state()
<< ", position: " << tap.position()
<< ", direction: " << tap.direction()<< std::endl;
break;
}
case Gesture::TYPE_SCREEN_TAP:
{
ScreenTapGesture screentap = gesture;
std::cout << "Screen Tap id: " << gesture.id()
<< ", state: " << gesture.state()
<< ", position: " << screentap.position()
<< ", direction: " << screentap.direction()<< std::endl;
break;
}
default:
std::cout << "Unknown gesture type." << std::endl;
break;
}
}
if (!frame.hands().isEmpty() || !gestures.isEmpty()) {
std::cout << std::endl;
}
}
void LeapListener::onFrame(const Controller & controller) {
// Get the most recent frame and report some basic information
const Frame frame = controller.frame();
std::cout << "Frame id: " << frame.id()
<< ", timestamp: " << frame.timestamp()
<< ", hands: " << frame.hands().count()
<< ", extended fingers: " << frame.fingers().extended().count()
<< ", tools: " << frame.tools().count()
<< ", gestures: " << frame.gestures().count() << std::endl;
HandList hands = frame.hands();
for (HandList::const_iterator hl = hands.begin(); hl != hands.end(); ++hl) {
// Get the first hand
const Hand hand = *hl;
std::string handType = hand.isLeft() ? "Left hand" : "Right hand";
std::cout << std::string(2, ' ') << handType << ", id: " << hand.id()
<< ", palm position: " << hand.palmPosition() << std::endl;
// Get the hand's normal vector and direction
const Vector normal = hand.palmNormal();
const Vector direction = hand.direction();
// Calculate the hand's pitch, roll, and yaw angles
std::cout << std::string(2, ' ') << "pitch: " << direction.pitch() * RAD_TO_DEG << " degrees, "
<< "roll: " << normal.roll() * RAD_TO_DEG << " degrees, "
<< "yaw: " << direction.yaw() * RAD_TO_DEG << " degrees" << std::endl;
// Get the Arm bone
Arm arm = hand.arm();
std::cout << std::string(2, ' ') << "Arm direction: " << arm.direction()
<< " wrist position: " << arm.wristPosition()
<< " elbow position: " << arm.elbowPosition() << std::endl;
// Get fingers
const FingerList fingers = hand.fingers();
for (FingerList::const_iterator fl = fingers.begin(); fl != fingers.end(); ++fl) {
const Finger finger = *fl;
std::cout << std::string(4, ' ') << fingerNames[finger.type()]
<< " finger, id: " << finger.id()
<< ", length: " << finger.length()
<< "mm, width: " << finger.width() << std::endl;
// Get finger bones
for (int b = 0; b < 4; ++b) {
Bone::Type boneType = static_cast<Bone::Type>(b);
Bone bone = finger.bone(boneType);
std::cout << std::string(6, ' ') << boneNames[boneType]
<< " bone, start: " << bone.prevJoint()
<< ", end: " << bone.nextJoint()
<< ", direction: " << bone.direction() << std::endl;
}
}
}
// Get tools
const ToolList tools = frame.tools();
for (ToolList::const_iterator tl = tools.begin(); tl != tools.end(); ++tl) {
const Tool tool = *tl;
std::cout << std::string(2, ' ') << "Tool, id: " << tool.id()
<< ", position: " << tool.tipPosition()
<< ", direction: " << tool.direction() << std::endl;
}
// Get gestures
const GestureList gestures = frame.gestures();
for (int g = 0; g < gestures.count(); ++g) {
Gesture gesture = gestures[g];
switch (gesture.type()) {
case Gesture::TYPE_CIRCLE: {
CircleGesture circle = gesture;
std::string clockwiseness;
if (circle.pointable().direction().angleTo(circle.normal()) <= PI/2) {
clockwiseness = "clockwise";
} else {
clockwiseness = "counterclockwise";
}
// Calculate angle swept since last frame
float sweptAngle = 0;
if (circle.state() != Gesture::STATE_START) {
CircleGesture previousUpdate = CircleGesture(controller.frame(1).gesture(circle.id()));
sweptAngle = (circle.progress() - previousUpdate.progress()) * 2 * PI;
}
std::cout << std::string(2, ' ')
<< "Circle id: " << gesture.id()
<< ", state: " << stateNames[gesture.state()]
<< ", progress: " << circle.progress()
<< ", radius: " << circle.radius()
<< ", angle " << sweptAngle * RAD_TO_DEG
<< ", " << clockwiseness << std::endl;
break;
}
case Gesture::TYPE_SWIPE: {
SwipeGesture swipe = gesture;
std::cout << std::string(2, ' ')
<< "Swipe id: " << gesture.id()
<< ", state: " << stateNames[gesture.state()]
<< ", direction: " << swipe.direction()
<< ", speed: " << swipe.speed() << std::endl;
break;
}
case Gesture::TYPE_KEY_TAP: {
KeyTapGesture tap = gesture;
std::cout << std::string(2, ' ')
<< "Key Tap id: " << gesture.id()
<< ", state: " << stateNames[gesture.state()]
<< ", position: " << tap.position()
<< ", direction: " << tap.direction()<< std::endl;
break;
}
case Gesture::TYPE_SCREEN_TAP: {
ScreenTapGesture screentap = gesture;
std::cout << std::string(2, ' ')
<< "Screen Tap id: " << gesture.id()
<< ", state: " << stateNames[gesture.state()]
<< ", position: " << screentap.position()
<< ", direction: " << screentap.direction() << std::endl;
break;
}
default:
std::cout << std::string(2, ' ') << "Unknown gesture type." << std::endl;
break;
}
}
if (!frame.hands().isEmpty() || !gestures.isEmpty())
std::cout << std::endl;
}
void SampleListener::onFrame(const Controller& controller)
{
// This function needs to be broken up, it's way too long
const Frame frame = controller.frame();
//int currid = 1;
//check if we already processed this frame
if (frame.id() == this->lastFrameID)
return;
this->lastFrameID = frame.id();
//stop activity if we've not been used for ACTIVETIMEOUT
if ((ACTIVETIMEOUT + this->lastEvent) < time(0) && this->active)
{
std::cout << "auto deactivated" << std::endl;
this->active = false;
}
if (frame.fingers().count() == 2)
{
GestureList gestures = frame.gestures();
for (int it = 0; it < gestures.count(); ++it)
{
if (gestures[it].type() != Gesture::TYPE_KEY_TAP)
continue;
if ((this->lastToggle + TOGGLE_FRAME_LIMIT) > frame.id()) //avoid detecting the same tap twice
continue;
KeyTapGesture gesture = gestures[it];
Vector v = gesture.direction();
this->active = !this->active;
this->lastToggle = frame.id();
this->lastEvent = time(0);
std::cout << (this->active ? "activated" : "deactivated") << std::endl;
break; //make sure we don't accidentally use the same list twice
}
}
if (!this->active)
return;
if (frame.fingers().count() == 1 & side != 2)
{
PointableList pointables = frame.pointables();
InteractionBox iBox = frame.interactionBox();
for (int p = 0; p < pointables.count(); ++p)
{
Pointable pointable = pointables[p];
Vector normalizedPosition = iBox.normalizePoint(pointable.stabilizedTipPosition());
float distance = pointable.touchDistance();
float x = normalizedPosition.x * (Mouse->w_width+250);
float y = (Mouse->w_height + 250) - normalizedPosition.y * (Mouse->w_height + 250);
if (side == 0)
{
Mouse->move((int)x, (int)y);
pressedDelay = 0;
}
if (distance < 0)
{
clickcount++;
side = 1;
if (clickcount > sensibility)
{
if (pressstate == 0)
{
Mouse->leftPress();
pressstate = 1;
}
else
{
if (clickcount >= 30)
{
if (rclick == 0)
Mouse->move((int)x,(int)y);
std::cout << "move side: "<< side << std::endl;
clickcount = 20;
}
}
}
}
else if (side == 1)
{
Mouse->leftRelease();
std::cout << "released side: " << side << std::endl;
side = 0;
pressstate = 0;
pressedDelay = 0;
clickcount = 0;
rclick = 0;
}
}
this->lastEvent = time(0);
}
else if (frame.fingers().count() > 1 & side != 1)
{
clickcount = 0;
std::cout << "active side: " << side << std::endl;
// Get gestures
const GestureList gestures = frame.gestures();
for (int g = 0; g < gestures.count(); ++g)
{
Gesture gesture = gestures[g];
switch (gesture.type())
{
case Gesture::TYPE_CIRCLE :
{
CircleGesture circle = gesture;
if (gesture.state() == 3 & circle.progress() > 1)
{
side = 0;
rclick = 1;
Mouse->rightPress();
Mouse->rightRelease();
}
break;
}
case Gesture::TYPE_SWIPE :
{
side = 2;
SwipeGesture swipe = gesture;
Vector d = swipe.direction();
// std::cout << "Swipe id: " << d(1) << std::endl;
if (d[1] > 0.8)
{
this->mystate = 1; //up
// std::cout << "wheel up " <<std::endl;
}
else if (d[1] < -0.8)
{
this->mystate = 2; //down
//std::cout << "wheel down " <<std::endl;
}
if (swipe.state() == 3)
{
if (this->mystate == 1)
{
side = 0;
this->mystate = 0;
Mouse->wheelUp();
}
else if (this->mystate == 2)
{
side = 0;
this->mystate = 0;
Mouse->wheelDown();
}
}
break;
}
default:
//std::cout << "Unknown gesture type." << std::endl;
break;
}
}
this->lastEvent = time(0);
}
}
/*----------------------------------------------------------------------------------------------------*/
void Gestures::sendGesture(const Gesture& pGesture) {
if ( !pGesture.isValid() ) {
return;
}
Gesture::Type type = pGesture.type();
Gesture::State state = pGesture.state();
int64_t duration = pGesture.duration();
Leap::Vector position;
Leap::Vector direction;
float progress = 0;
float speed = 0;
float radius = 0;
std::string typeKey;
std::string stateName;
////
if ( type == Gesture::TYPE_CIRCLE ) {
CircleGesture circle = (CircleGesture)pGesture;
position = circle.center();
progress = circle.progress();
radius = circle.radius();
typeKey = GestureKey::Circle;
}
else if ( type == Gesture::TYPE_SWIPE ) {
SwipeGesture swipe = (SwipeGesture)pGesture;
position = swipe.startPosition();
direction = swipe.direction();
speed = swipe.speed();
typeKey = GestureKey::Swipe;
}
else if ( type == Gesture::TYPE_KEY_TAP ) {
KeyTapGesture keyTap = (KeyTapGesture)pGesture;
position = keyTap.position();
direction = keyTap.direction();
progress = keyTap.progress();
typeKey = GestureKey::KeyTap;
}
else if ( type == Gesture::TYPE_SCREEN_TAP ) {
ScreenTapGesture screenTap = (ScreenTapGesture)pGesture;
position = screenTap.position();
direction = screenTap.direction();
progress = screenTap.progress();
typeKey = GestureKey::ScreenTap;
}
else {
std::cout << "[LEAP] Unsupported gesture type: " << type << std::endl;
return;
}
////
switch ( state ) {
case Gesture::STATE_INVALID:
stateName = "Invalid";
break;
case Gesture::STATE_START:
stateName = "Start";
break;
case Gesture::STATE_UPDATE:
stateName = "Update";
break;
case Gesture::STATE_STOP:
stateName = "Stop";
break;
default:
std::cout << "[LEAP] Unsupported state type: " << state << std::endl;
return;
}
////
std::cout << "GESTURE MESSAGE" <<
"\n - type: " << type << " (" << typeKey << ")" <<
"\n - stat: " << state << " (" << stateName << ")" <<
"\n - dura: " << duration <<
"\n - pos: " << position <<
"\n - dir: " << direction <<
"\n - prog: " << progress <<
"\n - radi: " << radius <<
"\n - spd: " << speed <<
"\n" << std::endl;
}
void QLeapEventListener::onFrame(const Controller & controller)
{
const Frame frame = controller.frame();
// Get gestures
const GestureList gestures = frame.gestures();
for (int g = 0; g < gestures.count(); ++g) {
Gesture gesture = gestures[g];
switch (gesture.type()) {
case Gesture::TYPE_CIRCLE:
{
CircleGesture circle = gesture;
std::string clockwiseness;
if (circle.pointable().direction().angleTo(circle.normal()) <= PI/4) {
clockwiseness = "clockwise";
} else {
clockwiseness = "counterclockwise";
}
// Calculate angle swept since last frame
float sweptAngle = 0;
if (circle.state() != Gesture::STATE_START) {
CircleGesture previousUpdate = CircleGesture(controller.frame(1).gesture(circle.id()));
sweptAngle = (circle.progress() - previousUpdate.progress()) * 2 * PI;
}
std::cout << "Circle id: " << gesture.id()
<< ", state: " << gesture.state()
<< ", progress: " << circle.progress()
<< ", radius: " << circle.radius()
<< ", angle " << sweptAngle * RAD_TO_DEG
<< ", " << clockwiseness << std::endl;
break;
}
case Gesture::TYPE_SWIPE:
{
SwipeGesture swipe = gesture;
std::cout << "Swipe id: " << gesture.id()
<< ", state: " << gesture.state()
<< ", direction: " << swipe.direction()
<< ", speed: " << swipe.speed() << std::endl;
onSwipe(swipe);
break;
}
case Gesture::TYPE_KEY_TAP:
{
KeyTapGesture tap = gesture;
std::cout << "Key Tap id: " << gesture.id()
<< ", state: " << gesture.state()
<< ", position: " << tap.position()
<< ", direction: " << tap.direction()<< std::endl;
break;
}
case Gesture::TYPE_SCREEN_TAP:
{
ScreenTapGesture screentap = gesture;
std::cout << "Screen Tap id: " << gesture.id()
<< ", state: " << gesture.state()
<< ", position: " << screentap.position()
<< ", direction: " << screentap.direction()<< std::endl;
break;
}
default:
std::cout << "Unknown gesture type." << std::endl;
break;
}
}
}
void AppListener::onFrame(const Controller& controller) {
// Get the most recent frame and report some basic information
const Frame frame = controller.frame();
::Sleep(1);
const HandList& hands = frame.hands();
const FingerList& fingers = frame.fingers();
const ToolList& tools = frame.tools();
const GestureList& gestures = frame.gestures();
if (hands.empty() && fingers.empty() && tools.empty() && gestures.empty())
return;
#if 0
std::cout
<< "Frame id: " << frame.id()
<< ", timestamp: " << frame.timestamp()
<< " hands: " << hands.count()
<< " fingers: " << fingers.count()
<< " tools: " << tools.count()
<< " gestures: " << gestures.count()
<< std::endl;
#endif
ofxOscBundle bundle;
ofxOscMessage alive;
{
alive.setAddress("/tuio/2Dcur");
alive.addStringArg("alive");
}
ofxOscMessage fseq;
{
fseq.setAddress( "/tuio/2Dcur" );
fseq.addStringArg( "fseq" );
fseq.addIntArg(frame.id());
}
if (!hands.empty()) {
// Get the first hand
const Hand& hand = hands[0];
// Check if the hand has any fingers
const FingerList& fingers = hand.fingers();
if (!fingers.empty()) {
for (int i = 0; i < fingers.count(); ++i) {
const Vector& tipPos = fingers[i].tipPosition();
const Vector& tipVel = fingers[i].tipVelocity();
{
#ifdef INIT_BBOX
// max/min bbox
bboxMax.x = std::max<float>(bboxMax.x, tipPos.x);
bboxMax.y = std::max<float>(bboxMax.y, tipPos.y);
bboxMax.z = std::max<float>(bboxMax.z, tipPos.z);
bboxMin.x = std::min<float>(bboxMin.x, tipPos.x);
bboxMin.y = std::min<float>(bboxMin.y, tipPos.y);
bboxMin.z = std::min<float>(bboxMin.z, tipPos.z);
#endif
Vector tuioPos;
tuioPos.x = normalize(tipPos.x, bboxMin.x, bboxMax.x);
tuioPos.y = normalize(tipPos.y, bboxMax.y, bboxMin.y);
tuioPos.z = normalize(tipPos.z, bboxMin.z, bboxMax.z);
// tuio
{
ofxOscMessage m;
m.setAddress( "/tuio/2Dcur" );
m.addStringArg("set");
m.addIntArg(fingers[i].id()); // id
m.addFloatArg(tuioPos.x); // x
m.addFloatArg(tuioPos.y); // y
// TOTO
m.addFloatArg(tipVel.x / 400); // dX
m.addFloatArg(tipVel.y / 400); // dY
m.addFloatArg(0); // maccel
bundle.addMessage(m);
alive.addIntArg(fingers[i].id()); // add blob to list of ALL active IDs
}
}
}
#ifdef INIT_BBOX
std::cout << "min: " << bboxMin << std::endl;
std::cout << "max: " << bboxMax << std::endl;
#endif
}
#if 0
// Get the hand's sphere radius and palm position
std::cout << "Hand sphere radius: " << hand.sphereRadius()
<< " mm, palm position: " << hand.palmPosition() << std::endl;
#endif
// Get the hand's normal vector and direction
const Vector normal = hand.palmNormal();
const Vector direction = hand.direction();
#if 0
// Calculate the hand's pitch, roll, and yaw angles
std::cout << "Hand pitch: " << direction.pitch() * RAD_TO_DEG << " degrees, "
<< "roll: " << normal.roll() * RAD_TO_DEG << " degrees, "
<< "yaw: " << direction.yaw() * RAD_TO_DEG << " degrees" << std::endl;
#endif
}
bundle.addMessage(alive);
bundle.addMessage(fseq);
tuioSender.sendBundle(bundle);
// Get gestures
for (int g = 0; g < gestures.count(); ++g) {
Gesture gesture = gestures[g];
switch (gesture.type()) {
case Gesture::TYPE_CIRCLE:
{
CircleGesture circle = gesture;
std::string clockwiseness;
if (circle.pointable().direction().angleTo(circle.normal()) <= PI/4) {
clockwiseness = "clockwise";
} else {
clockwiseness = "counterclockwise";
}
// Calculate angle swept since last frame
float sweptAngle = 0;
if (circle.state() != Gesture::STATE_START) {
CircleGesture previousUpdate = CircleGesture(controller.frame(1).gesture(circle.id()));
sweptAngle = (circle.progress() - previousUpdate.progress()) * 2 * PI;
}
std::cout << "Circle id: " << gesture.id()
<< ", state: " << gesture.state()
<< ", progress: " << circle.progress()
<< ", radius: " << circle.radius()
<< ", angle " << sweptAngle * RAD_TO_DEG
<< ", " << clockwiseness << std::endl;
break;
}
case Gesture::TYPE_SWIPE:
{
SwipeGesture swipe = gesture;
std::cout << "Swipe id: " << gesture.id()
<< ", state: " << gesture.state()
<< ", direction: " << swipe.direction()
<< ", speed: " << swipe.speed() << std::endl;
break;
}
case Gesture::TYPE_KEY_TAP:
{
KeyTapGesture tap = gesture;
std::cout << "Key Tap id: " << gesture.id()
<< ", state: " << gesture.state()
<< ", position: " << tap.position()
<< ", direction: " << tap.direction()<< std::endl;
break;
}
case Gesture::TYPE_SCREEN_TAP:
{
ScreenTapGesture screentap = gesture;
std::cout << "Screen Tap id: " << gesture.id()
<< ", state: " << gesture.state()
<< ", position: " << screentap.position()
<< ", direction: " << screentap.direction()<< std::endl;
break;
}
default:
std::cout << "Unknown gesture type." << std::endl;
break;
}
}
#if 0
if (!hands.empty() || !gestures.empty()) {
std::cout << std::endl;
}
#endif
}
FREObject LNLeapDevice::getFrame() {
Frame frame = controller->frame();
// TODO: Only continue with valid Frame?
FREObject freCurrentFrame;
FRENewObject( (const uint8_t*) "com.leapmotion.leap.Frame", 0, NULL, &freCurrentFrame, NULL);
FREObject freFrameId;
FRENewObjectFromInt32((int32_t) frame.id(), &freFrameId);
FRESetObjectProperty(freCurrentFrame, (const uint8_t*) "id", freFrameId, NULL);
const Vector frameTranslation = frame.translation(lastFrame);
FRESetObjectProperty(freCurrentFrame, (const uint8_t*) "translationVector", createVector3(frameTranslation.x, frameTranslation.y, frameTranslation.z), NULL);
const Matrix frameRotation = frame.rotationMatrix(lastFrame);
FRESetObjectProperty(freCurrentFrame, (const uint8_t*) "rotation", createMatrix(
createVector3(frameRotation.xBasis[0], frameRotation.xBasis[1], frameRotation.xBasis[2]),
createVector3(frameRotation.yBasis[0], frameRotation.yBasis[1], frameRotation.yBasis[2]),
createVector3(frameRotation.zBasis[0], frameRotation.zBasis[1], frameRotation.zBasis[2]),
createVector3(frameRotation.origin[0], frameRotation.origin[1], frameRotation.origin[2])
), NULL);
FREObject freFrameScaleFactor;
FRENewObjectFromDouble(frame.scaleFactor(lastFrame), &freFrameScaleFactor);
FRESetObjectProperty(freCurrentFrame, (const uint8_t*) "scaleFactorNumber", freFrameScaleFactor, NULL);
FREObject freTimestamp;
FRENewObjectFromInt32((int32_t) frame.timestamp(), &freTimestamp);
FRESetObjectProperty(freCurrentFrame, (const uint8_t*) "timestamp", freTimestamp, NULL);
std::map<int, FREObject> freHandsMap;
if (!frame.hands().empty()) {
FREObject freHands;
FREGetObjectProperty(freCurrentFrame, (const uint8_t*) "hands", &freHands, NULL);
for(int i = 0; i < frame.hands().count(); i++) {
const Hand hand = frame.hands()[i];
FREObject freHand;
FRENewObject( (const uint8_t*) "com.leapmotion.leap.Hand", 0, NULL, &freHand, NULL);
FRESetObjectProperty(freHand, (const uint8_t*) "frame", freCurrentFrame, NULL);
FRESetObjectProperty(freHand, (const uint8_t*) "direction", createVector3(hand.direction()[0], hand.direction()[1], hand.direction()[2]), NULL);
FREObject freHandId;
FRENewObjectFromInt32(hand.id(), &freHandId);
FRESetObjectProperty(freHand, (const uint8_t*) "id", freHandId, NULL);
FRESetObjectProperty(freHand, (const uint8_t*) "palmNormal", createVector3(hand.palmNormal()[0], hand.palmNormal()[1], hand.palmNormal()[2]), NULL);
FRESetObjectProperty(freHand, (const uint8_t*) "palmPosition", createVector3(hand.palmPosition()[0], hand.palmPosition()[1], hand.palmPosition()[2]), NULL);
FRESetObjectProperty(freHand, (const uint8_t*) "palmVelocity", createVector3(hand.palmVelocity()[0], hand.palmVelocity()[1], hand.palmVelocity()[2]), NULL);
const Matrix rotation = hand.rotationMatrix(lastFrame);
FRESetObjectProperty(freHand, (const uint8_t*) "rotation", createMatrix(
createVector3(rotation.xBasis[0], rotation.xBasis[1], rotation.xBasis[2]),
createVector3(rotation.yBasis[0], rotation.yBasis[1], rotation.yBasis[2]),
createVector3(rotation.zBasis[0], rotation.zBasis[1], rotation.zBasis[2]),
createVector3(rotation.origin[0], rotation.origin[1], rotation.origin[2])
), NULL);
FREObject freScaleFactor;
FRENewObjectFromDouble(hand.scaleFactor(lastFrame), &freScaleFactor);
FRESetObjectProperty(freHand, (const uint8_t*) "scaleFactorNumber", freScaleFactor, NULL);
FRESetObjectProperty(freHand, (const uint8_t*) "sphereCenter", createVector3(hand.sphereCenter()[0], hand.sphereCenter()[1], hand.sphereCenter()[2]), NULL);
FREObject freSphereRadius;
FRENewObjectFromDouble(hand.sphereRadius(), &freSphereRadius);
FRESetObjectProperty(freHand, (const uint8_t*) "sphereRadius", freSphereRadius, NULL);
const Vector translation = hand.translation(lastFrame);
FRESetObjectProperty(freHand, (const uint8_t*) "translationVector", createVector3(translation.x, translation.y, translation.z), NULL);
FRESetArrayElementAt(freHands, i, freHand);
freHandsMap[hand.id()] = freHand;
}
}
std::map<int, FREObject> frePointablesMap;
if(!frame.pointables().empty()) {
FREObject frePointables;
FREGetObjectProperty(freCurrentFrame, (const uint8_t*) "pointables", &frePointables, NULL);
for(int i = 0; i < frame.pointables().count(); i++) {
const Pointable pointable = frame.pointables()[i];
FREObject frePointable;
if(pointable.isTool()) {
FRENewObject( (const uint8_t*) "com.leapmotion.leap.Tool", 0, NULL, &frePointable, NULL);
} else {
FRENewObject( (const uint8_t*) "com.leapmotion.leap.Finger", 0, NULL, &frePointable, NULL);
}
FRESetObjectProperty(frePointable, (const uint8_t*) "frame", freCurrentFrame, NULL);
FREObject frePointableId;
FRENewObjectFromInt32(pointable.id(), &frePointableId);
FRESetObjectProperty(frePointable, (const uint8_t*) "id", frePointableId, NULL);
FREObject frePointableLength;
FRENewObjectFromDouble(pointable.length(), &frePointableLength);
FRESetObjectProperty(frePointable, (const uint8_t*) "length", frePointableLength, NULL);
FREObject frePointableWidth;
FRENewObjectFromDouble(pointable.width(), &frePointableWidth);
FRESetObjectProperty(frePointable, (const uint8_t*) "width", frePointableWidth, NULL);
FRESetObjectProperty(frePointable, (const uint8_t*) "direction", createVector3(pointable.direction().x, pointable.direction().y, pointable.direction().z), NULL);
FRESetObjectProperty(frePointable, (const uint8_t*) "tipPosition", createVector3(pointable.tipPosition().x, pointable.tipPosition().y, pointable.tipPosition().z), NULL);
FRESetObjectProperty(frePointable, (const uint8_t*) "tipVelocity", createVector3(pointable.tipVelocity().x, pointable.tipVelocity().y, pointable.tipVelocity().z), NULL);
//map to hand & back
if(pointable.hand().isValid()) {
FREObject freHand = freHandsMap[pointable.hand().id()];
FRESetObjectProperty(frePointable, (const uint8_t*) "hand", freHand, NULL);
FREObject frePointables;
FREGetObjectProperty(freHand, (const uint8_t*) "pointables", &frePointables, NULL);
uint32_t numPointables;
FREGetArrayLength(frePointables, &numPointables);
FRESetArrayElementAt(frePointables, numPointables, frePointable);
FREObject freSpecificHandPointables;
if(pointable.isTool()) {
FREGetObjectProperty(freHand, (const uint8_t*) "tools", &freSpecificHandPointables, NULL);
} else {
FREGetObjectProperty(freHand, (const uint8_t*) "fingers", &freSpecificHandPointables, NULL);
}
uint32_t numSpecificHandTools;
FREGetArrayLength(freSpecificHandPointables, &numSpecificHandTools);
FRESetArrayElementAt(freSpecificHandPointables, numSpecificHandTools, frePointable);
}
//push it in current frame
FRESetArrayElementAt(frePointables, i, frePointable);
//specific
FREObject freSpecificPointables;
if(pointable.isTool()) {
FREGetObjectProperty(freCurrentFrame, (const uint8_t*) "tools", &freSpecificPointables, NULL);
} else {
FREGetObjectProperty(freCurrentFrame, (const uint8_t*) "fingers", &freSpecificPointables, NULL);
}
uint32_t numSpecificTools;
FREGetArrayLength(freSpecificPointables, &numSpecificTools);
FRESetArrayElementAt(freSpecificPointables, numSpecificTools, frePointable);
frePointablesMap[pointable.id()] = frePointable;
}
}
if(!frame.gestures().empty()) {
FREObject freGestures;
FREGetObjectProperty(freCurrentFrame, (const uint8_t*) "gesturesVector", &freGestures, NULL);
for(int i = 0; i < frame.gestures().count(); i++) {
const Gesture gesture = frame.gestures()[i];
int state;
switch (gesture.state()) {
case Gesture::STATE_INVALID:
state = 0;
break;
case Gesture::STATE_START:
state = 1;
break;
case Gesture::STATE_UPDATE:
state = 2;
break;
case Gesture::STATE_STOP:
state = 3;
break;
default:
break;
}
int type;
FREObject freGesture;
switch (gesture.type()) {
case Gesture::TYPE_SWIPE:
{
type = 5;
SwipeGesture swipe = gesture;
FRENewObject( (const uint8_t*) "com.leapmotion.leap.SwipeGesture", 0, NULL, &freGesture, NULL);
FRESetObjectProperty(freGesture, (const uint8_t*) "direction", createVector3(swipe.direction().x, swipe.direction().y, swipe.direction().z), NULL);
FRESetObjectProperty(freGesture, (const uint8_t*) "position", createVector3(swipe.position().x, swipe.position().y, swipe.position().z), NULL);
FRESetObjectProperty(freGesture, (const uint8_t*) "startPosition", createVector3(swipe.startPosition().x, swipe.startPosition().y, swipe.startPosition().z), NULL);
FREObject freSwipeGestureSpeed;
FRENewObjectFromDouble(swipe.speed(), &freSwipeGestureSpeed);
FRESetObjectProperty(freGesture, (const uint8_t*) "speed", freSwipeGestureSpeed, NULL);
break;
}
case Gesture::TYPE_CIRCLE:
{
type = 6;
CircleGesture circle = gesture;
FRENewObject( (const uint8_t*) "com.leapmotion.leap.CircleGesture", 0, NULL, &freGesture, NULL);
FRESetObjectProperty(freGesture, (const uint8_t*) "center", createVector3(circle.center().x, circle.center().y, circle.center().z), NULL);
FRESetObjectProperty(freGesture, (const uint8_t*) "normal", createVector3(circle.normal().x, circle.normal().y, circle.normal().z), NULL);
FREObject freCircleGestureProgress;
FRENewObjectFromDouble(circle.progress(), &freCircleGestureProgress);
FRESetObjectProperty(freGesture, (const uint8_t*) "progress", freCircleGestureProgress, NULL);
FREObject freCircleGestureRadius;
FRENewObjectFromDouble(circle.radius(), &freCircleGestureRadius);
FRESetObjectProperty(freGesture, (const uint8_t*) "radius", freCircleGestureRadius, NULL);
FREObject frePointable = frePointablesMap[circle.pointable().id()];
if(frePointable != NULL)
{
FRESetObjectProperty(freGesture, (const uint8_t*) "pointable", frePointable, NULL);
}
break;
}
case Gesture::TYPE_SCREEN_TAP:
{
type = 7;
ScreenTapGesture screentap = gesture;
FRENewObject( (const uint8_t*) "com.leapmotion.leap.ScreenTapGesture", 0, NULL, &freGesture, NULL);
FRESetObjectProperty(freGesture, (const uint8_t*) "direction", createVector3(screentap.direction().x, screentap.direction().y, screentap.direction().z), NULL);
FRESetObjectProperty(freGesture, (const uint8_t*) "position", createVector3(screentap.position().x, screentap.position().y, screentap.position().z), NULL);
break;
}
case Gesture::TYPE_KEY_TAP:
{
type = 8;
KeyTapGesture tap = gesture;
FRENewObject( (const uint8_t*) "com.leapmotion.leap.KeyTapGesture", 0, NULL, &freGesture, NULL);
FRESetObjectProperty(freGesture, (const uint8_t*) "direction", createVector3(tap.direction().x, tap.direction().y, tap.direction().z), NULL);
FRESetObjectProperty(freGesture, (const uint8_t*) "position", createVector3(tap.position().x, tap.position().y, tap.position().z), NULL);
break;
}
default:
{
type = 4;
FRENewObject( (const uint8_t*) "com.leapmotion.leap.Gesture", 0, NULL, &freGesture, NULL);
break;
}
}
FREObject freGestureState;
FRENewObjectFromInt32(state, &freGestureState);
FRESetObjectProperty(freGesture, (const uint8_t*) "state", freGestureState, NULL);
FREObject freGestureType;
FRENewObjectFromInt32(type, &freGestureType);
FRESetObjectProperty(freGesture, (const uint8_t*) "type", freGestureType, NULL);
FREObject freGestureDuration;
FRENewObjectFromInt32((int32_t) gesture.duration(), &freGestureDuration);
FRESetObjectProperty(freGesture, (const uint8_t*) "duration", freGestureDuration, NULL);
FREObject freGestureDurationSeconds;
FRENewObjectFromDouble(gesture.durationSeconds(), &freGestureDurationSeconds);
FRESetObjectProperty(freGesture, (const uint8_t*) "durationSeconds", freGestureDurationSeconds, NULL);
FRESetObjectProperty(freGesture, (const uint8_t*) "frame", freCurrentFrame, NULL);
FREObject freGestureId;
FRENewObjectFromInt32(gesture.id(), &freGestureId);
FRESetObjectProperty(freGesture, (const uint8_t*) "id", freGestureId, NULL);
if (!gesture.hands().empty()) {
FREObject freGestureHands;
FREGetObjectProperty(freGesture, (const uint8_t*) "hands", &freGestureHands, NULL);
for(int i = 0; i < gesture.hands().count(); i++) {
const Hand hand = gesture.hands()[i];
FREObject freHand = freHandsMap[hand.id()];
FRESetArrayElementAt(freGestureHands, i, freHand);
}
}
if (!gesture.pointables().empty()) {
FREObject freGesturePointables;
FREGetObjectProperty(freGesture, (const uint8_t*) "pointables", &freGesturePointables, NULL);
for(int i = 0; i < gesture.pointables().count(); i++) {
const Pointable pointable = gesture.pointables()[i];
FREObject frePointable = frePointablesMap[pointable.id()];
FRESetArrayElementAt(freGesturePointables, i, frePointable);
}
}
//push it in current gesture vector
FRESetArrayElementAt(freGestures, i, freGesture);
}
}
lastFrame = frame;
return freCurrentFrame;
}
void DefaultSwipeListener::onLeftSwipe(const SwipeGesture& swipe) {
std::cout
<< "Left swipe event has occured with id = "
<< swipe.id()
<< std::endl;
}
void LeapController::update() {
hands = leap.getLeapHands();
if(leap.isFrameNew() && hands.size()){
for(int i = 0; i < hands.size(); i++){
Hand hand = hands[i];
if (handsPrevious.size() == hands.size() && hand.fingers().count() == 3){
float dx = hand.palmPosition().x - handsPrevious[i].palmPosition().x;
float dy = hand.palmPosition().z - handsPrevious[i].palmPosition().z;
float dz = -hand.palmPosition().y + handsPrevious[i].palmPosition().y;
int numFingers = hands[i].fingers().count();
// horizontalPan = (numFingers == 2);
horizontalPan = false;
verticalPan = true;
pan(dx,dy,dz);
}
}
}
Frame frame = controller.frame();
GestureList gestures = framePrevious.isValid() ?
frame.gestures(framePrevious) :
frame.gestures();
framePrevious = frame;
for (size_t i=0; i < gestures.count(); i++) {
if (gestures[i].type() == Gesture::TYPE_SCREEN_TAP) {
ScreenTapGesture tap = gestures[i];
static GestureEventArgs args;
args.pos = ofVec3f(tap.position().x, tap.position().y, tap.position().z);
ofNotifyEvent(onTapScreen, args, this);
} else if (gestures[i].type() == Gesture::TYPE_KEY_TAP) {
KeyTapGesture tap = gestures[i];
static GestureEventArgs args;
args.pos = ofVec3f(tap.position().x, tap.position().y, tap.position().z);
ofNotifyEvent(onTapDown, args, this);
//cout << "LEAP TAP GESTURE AT: " << pos << endl;
} else if (gestures[i].type() == Gesture::TYPE_SWIPE) {
SwipeGesture swipe = gestures[i];
Vector diff = 0.004f*(swipe.position() - swipe.startPosition());
static GestureEventArgs args;
args.pos = ofVec3f(swipe.position().x, swipe.position().y, swipe.position().z);
args.startPos = ofVec3f(swipe.startPosition().x, swipe.startPosition().y, swipe.startPosition().z);
args.state = swipe.state();
ofNotifyEvent(onSwipe, args, this);
//cout << "LEAP SWIPE GESTURE" << endl;
} else if (gestures[i].type() == Gesture::TYPE_CIRCLE) {
CircleGesture circle = gestures[i];
float progress = circle.progress();
if (progress >= 1.0f) {
double curAngle = 6.5;
//cout << "LEAP CIRCLE GESTURE" << endl;
}
static GestureEventArgs args;
args.pos = ofVec3f(circle.center().x, circle.center().y, circle.center().z);
args.normal = ofVec3f(circle.normal().x, circle.normal().y, circle.normal().z);
args.progress = circle.progress();
ofNotifyEvent(onCircle, args, this);
}
}
handsPrevious = hands;
leap.markFrameAsOld();
SceneController::update();
}
void QTVS_Leap::LeapGestureLogic()
{
for (int g = 0; g < gestures.count(); ++g) {
Gesture gesture = gestures[g];
switch (gesture.type()) {
case Gesture::TYPE_CIRCLE:
{
// emit Listener_Gesture(gesture, gesture.type());
CircleGesture circle = gesture;
std::string clockwiseness;
if (circle.pointable().direction().angleTo(circle.normal()) <= PI / 2) {
clockwiseness = "clockwise";
// MouseKeyboardEmulation::MouseWheelDown(5);
} else {
clockwiseness = "counterclockwise";
// MouseKeyboardEmulation::MouseWheelUp(5);
}
// Calculate angle swept since last frame
float sweptAngle = 0;
if (circle.state() != Gesture::STATE_START) {
CircleGesture previousUpdate = CircleGesture(controller.frame(1).gesture(circle.id()));
sweptAngle = (circle.progress() - previousUpdate.progress()) * 2 * PI;
}
std::cout << std::string(2, ' ')
<< "Circle id: " << gesture.id()
<< ", state: " << stateNames[gesture.state()]
<< ", progress: " << circle.progress()
<< ", radius: " << circle.radius()
<< ", angle " << sweptAngle * RAD_TO_DEG
<< ", " << clockwiseness << std::endl;
break;
}
case Gesture::TYPE_SWIPE:
{
SwipeGesture swipe = gesture;
// debugDisplayString = "";
// debugDisplayString.append("Swipe id: " + QString::number(gesture.id()));
// debugDisplayString.append( ", state: " + QString(stateNames[gesture.state()].data()));
// debugDisplayString.append( ", direction: " + QString(swipe.direction().toString().data()));
// debugDisplayString.append( ", speed: " + QString::number(swipe.speed()));
std::cout << std::string(2, ' ')
<< "Swipe id: " << gesture.id()
<< ", state: " << stateNames[gesture.state()]
<< ", direction: " << swipe.direction()
<< ", speed: " << swipe.speed() << std::endl;
break;
}
case Gesture::TYPE_KEY_TAP:
{
KeyTapGesture tap = gesture;
// std::cout << std::string(2, ' ')
//debugDisplayString = "";
// debugDisplayString.append("Key Tap id: " + QString::number(gesture.id()));
// debugDisplayString.append( ", state: " + QString(stateNames[gesture.state()].data()));
//debugDisplayString.append( ", position: " + QString(tap.position().toString().data()));
// debugDisplayString.append( ", direction: " + QString(tap.direction().toString().data()));
break;
}
case Gesture::TYPE_SCREEN_TAP:
{
ScreenTapGesture screentap = gesture;
std::cout << std::string(2, ' ')
<< "Screen Tap id: " << gesture.id()
<< ", state: " << stateNames[gesture.state()]
<< ", position: " << screentap.position()
<< ", direction: " << screentap.direction() << std::endl;
break;
}
default:
std::cout << std::string(2, ' ') << "Unknown gesture type." << std::endl;
break;
}
}
if (!frame.hands().isEmpty() || !gestures.isEmpty()) {
std::cout << std::endl;
}
}