int main(int argc, const char *argv[]) {
if (argc < 2) {
cout << "Usage: leap_high_five /path/to/serial\n";
return 1;
}
LynxSSC lynx(argv[1], 115200);
// lynx.move(3, 1500, -1, -1);
lynx.move(3, 1500, -1, -1);
sleep(2);
lynx.move(4, 500, -1, 1000);
sleep(2);
lynx.move(
LynxMoveGroup().move(3,1000,-1,500)
.move(4,1500,-1,1000));
return 0;
cout << "Initializing controller";
static Leap::Controller s_controller;
FrameListener listener;
cout << "Adding listener to controller";
s_controller.addListener(listener);
// while (running) {
//
// while (inMotion) {
// Jacobian3 J(armCurrent.q, armLengths);
// }
// }
cin.get();
return 0;
}
int main(int argc, char **argv)
{
EffectRunner r;
// Create a sample listener and controller
SampleListener listener;
Leap::Controller controller;
// Have the sample listener receive events from the controller
controller.addListener(listener);
if (argc > 1 && strcmp(argv[1], "--bg") == 0)
controller.setPolicy(Leap::Controller::POLICY_BACKGROUND_FRAMES);
// Keep this process running until Enter is pressed
//std::cout << "Press Enter to quit..." << std::endl;
//std::cin.get();
// Remove the sample listener when done
//controller.removeListener(listener);
//return 0;
MyEffect e;
r.setEffect(&e);
// Defaults, overridable with command line options
r.setMaxFrameRate(100);
r.setLayout("../layouts/grid32x16z.json");
return r.main(argc, argv);
}
void LeapController::Setup()
{
resetInitParams();
if (leapDevice && leapDevice->isConnected()) return;
leapDevice = Device::create();
leapDevice->connectEventHandler( &LeapController::onFrame, this );
// Enable all gesture types
Leap::Controller* controller = leapDevice->getController();
controller->enableGesture( Leap::Gesture::Type::TYPE_SWIPE );
controller->enableGesture( Leap::Gesture::Type::TYPE_CIRCLE );
// Write gesture config to console
Leap::Config config = controller->config();
// Update config to make gestures easier
config.setFloat( "Gesture.Swipe.MinLength", 30.0f );
config.setFloat( "Gesture.Swipe.MinVelocity", 100.0f );
config.save();
App::get()->getSignalShutdown().connect(bind(&LeapController::Shutdown, this));
App::get()->getSignalUpdate().connect(bind(&LeapController::Update, this));
}
void LeapListener::onConnect(const Leap::Controller& controller) {
std::cout << "Connected";
controller.enableGesture(Leap::Gesture::TYPE_CIRCLE);
controller.enableGesture(Leap::Gesture::TYPE_KEY_TAP);
controller.enableGesture(Leap::Gesture::TYPE_SCREEN_TAP);
controller.enableGesture(Leap::Gesture::TYPE_SWIPE);
}
void MouseController::onFrame(const Leap::Controller &controller) {
// get list of detected screens
const Leap::ScreenList screens = controller.calibratedScreens();
// make sure we have a detected screen
if (screens.empty()) return;
const Leap::Screen screen = screens[0];
// find the first finger or tool
const Leap::Frame frame = controller.frame();
const Leap::HandList hands = frame.hands();
if (hands.empty()) return;
const Leap::PointableList pointables = hands[0].pointables();
if (pointables.empty()) return;
const Leap::Pointable firstPointable = pointables[0];
// get x, y coordinates on the first screen
const Leap::Vector intersection = screen.intersect(
firstPointable,
true, // normalize
1.0f // clampRatio
);
// if the user is not pointing at the screen all components of
// the returned vector will be Not A Number (NaN)
// isValid() returns true only if all components are finite
if (! intersection.isValid()) return;
unsigned int x = screen.widthPixels() * intersection.x;
// flip y coordinate to standard top-left origin
unsigned int y = screen.heightPixels() * (1.0f - intersection.y);
CGPoint destPoint = CGPointMake(x, y);
CGDisplayMoveCursorToPoint(kCGDirectMainDisplay, destPoint);
}
void LeapMotionHandler::enableGest(Leap::Controller controller)
{
controller.enableGesture(Leap::Gesture::TYPE_SWIPE);
controller.enableGesture(Leap::Gesture::TYPE_CIRCLE);
controller.enableGesture(Leap::Gesture::TYPE_SCREEN_TAP);
controller.enableGesture(Leap::Gesture::TYPE_KEY_TAP);
}
//LeapControllerPrivate
void LeapControllerPrivate::SetPolicyStatus(Leap::Controller::PolicyFlag flag, bool status)
{
if (status)
leap.setPolicy(flag);
else
leap.clearPolicy(flag);
}
void LeapMotionListener::onConnect(const Leap::Controller & controller)
{
qDebug()<<"Connected Leap Motion";
controller.enableGesture(Leap::Gesture::TYPE_CIRCLE);
controller.enableGesture(Leap::Gesture::TYPE_KEY_TAP);
controller.enableGesture(Leap::Gesture::TYPE_SCREEN_TAP);
controller.enableGesture(Leap::Gesture::TYPE_SWIPE);
}
int main(int argc, const char * argv[]) {
MouseController listener;
Leap::Controller controller;
controller.addListener(listener);
std::cout << "Press any key to exit" << std::endl;
std::cin.get();
controller.removeListener(listener);
return 0;
}
int main(int argc, char **argv){
ros::init(argc, argv, "leap_tool_control");
RosListener listener;
Leap::Controller controller;
controller.addListener(listener);
std::cout <<"Press Enter to quit..."<<std::endl;
std::cin.get();
controller.removeListener(listener);
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
int width = 500;
int height = 500;
unsigned int displayMode = GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH | GLUT_STENCIL;
displayMode = defaults(displayMode, width, height);
glutInitDisplayMode (displayMode);
glutInitContextVersion (3, 3);
glutInitContextFlags(GLUT_FORWARD_COMPATIBLE);
glutInitContextProfile(GLUT_CORE_PROFILE);
#ifdef DEBUG
glutInitContextFlags(GLUT_DEBUG);
#endif
glutInitWindowSize (width, height);
glutInitWindowPosition (300, 200);
int window = glutCreateWindow (argv[0]);
glload::LoadFunctions();
glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION);
if(!glload::IsVersionGEQ(3, 3))
{
printf("Your OpenGL version is %i, %i. You must have at least OpenGL 3.3 to run this tutorial.\n",
glload::GetMajorVersion(), glload::GetMinorVersion());
glutDestroyWindow(window);
return 0;
}
if(glext_ARB_debug_output)
{
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
glDebugMessageCallbackARB(DebugFunc, (void*)15);
}
init();
UserListener listener;
Leap::Controller controller;
controller.addListener(listener);
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();
controller.removeListener(listener);
return 0;
}
/*----------------------------------------------------------------------------------------------------*/
OSVR_ReturnCode HardwareDetection::operator()(OSVR_PluginRegContext pContext) {
Leap::Controller controller;
if ( !controller.isConnected() ) {
mFound = false;
return OSVR_RETURN_FAILURE;
}
if ( !mFound ) {
mFound = true;
osvr::pluginkit::registerObjectForDeletion(pContext, new ControllerDevice(pContext));
}
return OSVR_RETURN_SUCCESS;
}
void main()
{
// リスナーを登録する
// リスナーとのやり取りは別スレッドにて行われる
SampleListener listener;
Leap::Controller leap;
leap.addListener( listener );
leap.setPolicyFlags( Leap::Controller::PolicyFlag::POLICY_BACKGROUND_FRAMES );
std::cout << "終了するには何かキーを押してください" << std::endl;
std::cin.get();
leap.removeListener( listener );
}
void Quickstart::onFrame(const Leap::Controller &controller) {
// returns the most recent frame. older frames can be accessed by passing in
// a "history" parameter to retrieve an older frame, up to about 60
// (exact number subject to change)
const Leap::Frame frame = controller.frame();
// do nothing unless hands are detected
if (frame.hands().empty())
return;
// first detected hand
const Leap::Hand firstHand = frame.hands()[0];
// first pointable object (finger or tool)
const Leap::PointableList pointables = firstHand.pointables();
if (pointables.empty()) return;
const Leap::Pointable firstPointable = pointables[0];
// print velocity on the X axis
cout << "Pointable X velocity: " << firstPointable.tipVelocity()[0] << endl;
const Leap::FingerList fingers = firstHand.fingers();
if (fingers.empty()) return;
for (int i = 0; i < fingers.count(); i++) {
const Leap::Finger finger = fingers[i];
std::cout << "Detected finger " << i << " at position (" <<
finger.tipPosition().x << ", " <<
finger.tipPosition().y << ", " <<
finger.tipPosition().z << ")" << std::endl;
}
}
void Quickstart::onInit(const Leap::Controller &controller) {
if (! controller.isConnected()) {
// controller is not connected or the driver software is not started.
// give the user a friendly reminder that we can't do anything yet
cout << "Please connect your Leap Motion and run the Leap application" << endl;
}
}
void Listener::onControlUpdated(const Leap::Controller &controller, GesturePtr gesture, ControlPtr control) {
midi_control_index ctrlIdx = control->controlIndex();
midi_control_value ctrlVal = control->mappedValue();
//
// cout << "Recognized control index " << ctrlIdx
// << " (" << control->description() << ")"
// << ", raw value: "
// << control->rawValue() << " mapped value: " << ctrlVal << endl;
if (frameCount <= 10) return;
// control latency
struct timeval tv;
gettimeofday(&tv, NULL);
double elapsedTime = (tv.tv_sec - control->timestamp().tv_sec) * 1000.0; // sec to ms
elapsedTime += (tv.tv_usec - control->timestamp().tv_usec) / 1000.0; // us to ms
// frame latency
double absoluteTimeOffset = tv_to_usec(tv) - tv_to_usec(firstFrameAbs);
// cout << "absolute time offset: " << absoluteTimeOffset << endl;
int64_t curFrameTime = controller.frame().timestamp();
int64_t frameOffset = curFrameTime - firstFrameLeap;
int64_t frameLatency = absoluteTimeOffset - frameOffset;
// cout << "frame: " << curFrameTime << ", absolute offset: " << (absoluteTimeOffset / 1000) << ", frameOffset: " << (frameOffset / 1000) << ", diff: " << (frameLatency / 1000) << endl;
if (minLatency == 0 || frameLatency < minLatency)
minLatency = frameLatency;
if (frameLatency > maxLatency)
maxLatency = frameLatency;
controlCount++;
totalLatency += frameLatency;
if (elapsedTime > 3)
cout << "frame latency: " << (frameLatency / 1000) << ", control output latency: " << elapsedTime << endl;
}
void Listener::onFrame(const Leap::Controller &controller) {
Leap::Frame curFrame = controller.frame();
if (firstFrameLeap == 0 && ++frameCount > 10) {
gettimeofday(&firstFrameAbs, NULL);
firstFrameLeap = curFrame.timestamp();
cout << "First frame clock time: " << tv_to_usec(firstFrameAbs) << endl;
cout << "First frame leap time: " << firstFrameLeap << endl;
}
// use current active gesture recognizers to locate gestures
// and then trigger appropriate note/controls
// feed frames to recognizers
vector<GesturePtr> recognizers = gestureRecognizers();
for (vector<GesturePtr>::iterator it = recognizers.begin(); it != recognizers.end(); ++it) {
// get controls recognized from gestures
GesturePtr gesture = *it;
std::vector<ControlPtr> gestureControls; // controls from this gesture
gesture->recognizedControls(controller, gestureControls);
if (! gestureControls.size())
continue;
// call gesture recognized callback
onGestureRecognized(controller, gesture);
for (vector<ControlPtr>::iterator ctl = gestureControls.begin(); ctl != gestureControls.end(); ++ctl) {
ControlPtr control = *ctl;
onControlUpdated(controller, gesture, control);
}
}
}
void LeapFishyApp::processGesture()
{
Leap::Frame frame = m_LeapController.frame();
if( m_LastFrame == frame )
return;
Leap::GestureList gestures = m_LastFrame.isValid() ?
frame.gestures( m_LastFrame ) :
frame.gestures();
m_LastFrame = frame;
for( int i = 0; i < gestures.count(); i++ )
{
if( gestures[i].type() == Leap::Gesture::TYPE_SWIPE )
{
Leap::SwipeGesture swipe = gestures[i];
Leap::Vector diff = 0.006f*(swipe.position() - swipe.startPosition());
Vec2f curSwipe(diff.x, -diff.y);
m_pPlayer->AddVelocity( curSwipe );
}
else if( gestures[i].type() == Leap::Gesture::TYPE_KEY_TAP ||
gestures[i].type() == Leap::Gesture::TYPE_SCREEN_TAP )
{
m_pPlayer->KillVelocity();
}
}
}
void LeapMotionListener::onFrame( const Leap::Controller& controller )
{
// get least frame
frame = controller.frame( 0 );
}
int main()
{
control.setPolicyFlags(Leap::Controller::POLICY_BACKGROUND_FRAMES);
pipe = CreateFile(PNAME, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
atexit(fin);
//tenfingers = (float*)malloc(sizeof(float)*10*4);
printf("connected\n");
//get fist positions as well
DWORD word = 0;
while(1)
{
fdata ret = get_finger_positions();
WriteFile(pipe, (char*)&ret, sizeof(fdata), &word, NULL);
Sleep(1);
}
//CloseHandle(pipe);
}
void Listener::onFrame( const Leap::Controller& controller )
{
lock_guard<mutex> lock( *mMutex );
if ( !mNewFrame ) {
mFrame = controller.frame();
mNewFrame = true;
}
}
//Inherited from Cinder - post-graphics initalization setup steps. Loads our particle texture & sets up the Leap controller.
void GesturesDemo::setup() {
ci::gl::Texture* particleTexture = new ci::gl::Texture(ci::loadImage(ci::app::loadResource(RES_PARTICLE)));
ci::gl::disableVerticalSync(); //required for higher than 60fps
field.SetParticleTexture(particleTexture);
mouseIsDown = false;
lastMousePos.set(0, 0);
controller.addListener( listener );
}
int main() {
// create instance of our Listener subclass
Quickstart listener;
// create generic Controller to interface with the Leap device
Leap::Controller controller;
// tell the Controller to start sending events to our Listener
controller.addListener(listener);
// run until user presses a key
cin.get();
// clean up
controller.removeListener(listener);
return 0;
}
void LeapListener::onDeviceChange(const Leap::Controller& controller) {
std::cout << "Device Changed" << std::endl;
const Leap::DeviceList devices = controller.devices();
for (int i = 0; i < devices.count(); ++i) {
std::cout << "id: " << devices[i].toString() << std::endl;
std::cout << " isStreaming: " << (devices[i].isStreaming() ? "true" : "false") << std::endl;
}
}
void LeapFishyApp::shutdown()
{
m_LeapController.removeListener( m_LeapListener );
delete m_pPlayer;
killAllEnemyFish();
delete m_pEnemyFishes;
}
void onFrame(const Leap::Controller& ctrl) override
{
if(ctrl.isConnected())
{
Leap::GestureList gestures = ctrl.frame().gestures();
/*
if(gestures.count())
{
Gesture gesture = gestures[0];
if(gestures[0].isValid())
{
if(gestures[0].type() == Gesture::TYPE_CIRCLE)
{
ScreenTapGesture screentap = gestures[0];
t_atom data[4];
Leap::Vector vector = screentap.direction();
atom_setsym(data, gensym("direction"));
atom_setfloat(data+1, vector.yaw());
atom_setfloat(data+1, vector.roll());
atom_setfloat(data+1, vector.pitch());
outlet_anything(x->f_gesture, leap_sym_circle, 0, NULL);
}
else if(gesture.type() == Gesture::TYPE_SWIPE)
{
;
}
else if(gesture.type() == Gesture::TYPE_KEY_TAP)
{
;
}
else if(gesture.type() == Gesture::TYPE_SCREEN_TAP)
{
;
}
else
{
;
}
}
}*/
}
}
fdata get_finger_positions()
{
Leap::Frame frame = control.frame();
Leap::FingerList fingers = frame.fingers();
Leap::ToolList tools = frame.tools();
Leap::HandList hands = frame.hands();
//std::vector<std::pair<cl_float4, int>> positions;
fdata hand_data;
int p = 0;
for(int i=0; i<40; i++)
{
hand_data.fingers[i] = 0.0f;
}
///will explode if more than 2
for(int i=0; i<hands.count(); i++)
{
const Leap::Hand hand = hands[i];
Leap::FingerList h_fingers = hand.fingers();
float grab_strength = hand.grabStrength();
hand_data.grab_confidence[i] = grab_strength;
for(int j=0; j<h_fingers.count(); j++)
{
const Leap::Finger finger = h_fingers[j];
float mfingerposx = finger.tipPosition().x;
float mfingerposy = finger.tipPosition().y;
float mfingerposz = finger.tipPosition().z;
//cl_float4 ps = {mfingerposx, mfingerposy, mfingerposz, 0.0f};
//cl_float4 ps = {mfingerposx, mfingerposy, mfingerposz, 0.0f};
int id = finger.id();
hand_data.fingers[p++] = mfingerposx;
hand_data.fingers[p++] = mfingerposy;
hand_data.fingers[p++] = mfingerposz;
hand_data.fingers[p++] = 0.0f;
//positions.push_back(std::pair<cl_float4, int>(ps, id));
}
}
return hand_data;
}
void LeapCinderRainApp::processFingers()
{
Leap::Frame frame = m_LeapController.frame();
Leap::FingerList fingers = frame.fingers();
m_Rain->ClearPointTo();
for( int i = 0; i < fingers.count(); i++ )
{
m_Rain->CheckPointTo( normalizeCoords( fingers[i].tipPosition() ), 40.0f );
}
}
// This is called every SL viewer frame
void LLLMImpl::stepFrame()
{
if (mLMController
&& mFrameAvailable
&& mLMConnected)
{
mFrameAvailable = false;
// Get the most recent frame and report some basic information
const Leap::Frame frame = mLMController->frame();
Leap::HandList hands = frame.hands();
static LLCachedControl<S32> sControllerMode(gSavedSettings, "LeapMotionTestMode", 0);
if( !mTool || mTool->getId() != sControllerMode )
{
delete mTool;
mTool = nd::leap::constructTool( sControllerMode );
}
if( mTool )
mTool->onRenderFrame( frame );
else
{
switch (sControllerMode)
{
case 1:
modeFlyingControlTest(hands);
break;
case 2:
modeStreamDataToSL(hands);
break;
case 3:
modeGestureDetection1(hands);
break;
case 4:
modeMoveAndCamTest1(hands);
break;
// <FS:Zi> Leap Motion flycam
case 10:
modeFlycam(hands);
break;
// </FS:Zi>
case 411:
modeDumpDebugInfo(hands);
break;
default:
// Do nothing
break;
}
}
}
}
void eleap::eleap_t::impl_t::onFrame(const Leap::Controller& controller)
{
const Leap::Frame frame = controller.frame();
if (frame.isValid())
{
// send the known hands in this frame, this will handle hands coming and going
const Leap::HandList hands = frame.hands();
{
unsigned long long time_encoded = (0&0xffffffff)<<8 | (DATA_KNOWN_HANDS&0xff);
float *f;
unsigned char *dp;
piw::data_nb_t d = ctx_.allocate_host(time_encoded,INT32_MAX,INT32_MIN,0,BCTVTYPE_INT,sizeof(int32_t),&dp,hands.count(),&f);
memset(f,0,hands.count()*sizeof(int32_t));
*dp = 0;
for(int i = 0; i < hands.count(); ++i)
{
const Leap::Hand hand = hands[i];
if(hand.isValid() && hand.fingers().count() > 1)
{
((int32_t *)f)[i] = hand.id();
}
}
enqueue_fast(d,1);
}
// handle the actual data for the detected hands
for(int i = 0; i < hands.count(); ++i)
{
const Leap::Hand hand = hands[i];
if(hand.isValid() && hand.fingers().count() > 1)
{
unsigned long long time_encoded = (hand.id()&0xffffffff)<<8 | (DATA_PALM_POSITION&0xff);
const Leap::Vector palm_pos = hand.palmPosition();
float *f;
unsigned char *dp;
piw::data_nb_t d = ctx_.allocate_host(time_encoded,600,-600,0,BCTVTYPE_FLOAT,sizeof(float),&dp,3,&f);
memset(f,0,3*sizeof(float));
*dp = 0;
f[0] = piw::normalise(600,-600,0,palm_pos.x);
f[1] = piw::normalise(600,-600,0,palm_pos.y);
f[2] = piw::normalise(600,-600,0,palm_pos.z);
enqueue_fast(d,1);
}
}
}
}
