leap

README

Leap

The Leap Motion is a user-interface device that tracks the user's hand motions, and translates them into events that can control robots and physical computing hardware.

For more info about the Leap Motion platform click Leap Motion

How to Install

First install the Leap Motion Software

Now you can install the package with

go get github.com/hybridgroup/gobot && go install github.com/hybridgroup/gobot/platforms/leap

How to Use

package main

import (
	"fmt"

	"github.com/hybridgroup/gobot"
	"github.com/hybridgroup/gobot/platforms/leap"
)

func main() {
	gbot := gobot.NewGobot()

	leapMotionAdaptor := leap.NewLeapMotionAdaptor("leap", "127.0.0.1:6437")
	l := leap.NewLeapMotionDriver(leapMotionAdaptor, "leap")

	work := func() {
		gobot.On(l.Event("message"), func(data interface{}) {
			fmt.Println(data.(leap.Frame))
		})
	}

	robot := gobot.NewRobot("leapBot",
		[]gobot.Connection{leapMotionAdaptor},
		[]gobot.Device{l},
		work,
	)

	gbot.AddRobot(robot)

	gbot.Start()
}

How To Connect

###OSX

This driver works out of the box with the vanilla installation of the Leap Motion Software that you get in their Setup Guide.

The main steps are:

• Run Leap Motion.app to open a websocket connection in port 6437.
• Connect your Computer and Leap Motion Controller.
• Connect to the device via Gobot.

Ubuntu

The Linux download of the Leap Motion software can be obtained from Leap Motion Dev Center (requires free signup)

The main steps are:

• Run the leapd daemon, to open a websocket connection in port 6437.
• Connect your computer and the Leap Motion controller
• Connect to the device via Gobot

Documentation

Overview

Package leap provides the Gobot adaptor and driver for the Leap Motion.

Installing:

* First install the [Leap Motion Software](https://www.leapmotion.com/setup). * Then install the package:

go get github.com/hybridgroup/gobot/platforms/leap

Example:

package main

import (
	"fmt"

	"github.com/hybridgroup/gobot"
	"github.com/hybridgroup/gobot/platforms/leap"
)

func main() {
	gbot := gobot.NewGobot()

	leapMotionAdaptor := leap.NewLeapMotionAdaptor("leap", "127.0.0.1:6437")
	l := leap.NewLeapMotionDriver(leapMotionAdaptor, "leap")

	work := func() {
		gobot.On(l.Event("message"), func(data interface{}) {
			fmt.Println(data.(leap.Frame))
		})
	}

	robot := gobot.NewRobot("leapBot",
		[]gobot.Connection{leapMotionAdaptor},
		[]gobot.Device{l},
		work,
	)

	gbot.AddRobot(robot)

	gbot.Start()
}

For more information refer to the leap README: https://github.com/hybridgroup/gobot/blob/master/platforms/leap/README.md

Index

• type Frame
• type Gesture
• type Hand
  • func (h *Hand) X() float64
  • func (h *Hand) Y() float64
  • func (h *Hand) Z() float64
• type InteractionBox
• type LeapMotionAdaptor
  • func NewLeapMotionAdaptor(name string, port string) *LeapMotionAdaptor
  • func (l *LeapMotionAdaptor) Connect() (errs []error)
  • func (l *LeapMotionAdaptor) Finalize() (errs []error)
  • func (l *LeapMotionAdaptor) Name() string
  • func (l *LeapMotionAdaptor) Port() string
• type LeapMotionDriver
  • func NewLeapMotionDriver(a *LeapMotionAdaptor, name string) *LeapMotionDriver
  • func (l *LeapMotionDriver) Connection() gobot.Connection
  • func (l *LeapMotionDriver) Halt() (errs []error)
  • func (l *LeapMotionDriver) Name() string
  • func (l *LeapMotionDriver) ParseFrame(data []byte) Frame
  • func (l *LeapMotionDriver) Start() (errs []error)
• type Pointable

Types

type Frame

type Frame struct {
	CurrentFrameRate float64        `json:"currentFrameRate"`
	Gestures         []Gesture      `json:"gestures"`
	Hands            []Hand         `json:"hands"`
	ID               int            `json:"id"`
	InteractionBox   InteractionBox `json:"interactionBox"`
	Pointables       []Pointable    `json:"pointables"`
	R                [][]float64    `json:"r"`
	S                float64        `json:"s"`
	T                []float64      `json:"t"`
	Timestamp        int            `json:"timestamp"`
}

Base representation returned that holds every other objects

type Gesture

type Gesture struct {
	Direction     []float64   `json:"direction"`
	Duration      int         `json:"duration"`
	Hands         []Hand      `json:"hands"`
	ID            int         `json:"id"`
	Pointables    []Pointable `json:"pointables"`
	Position      []float64   `json:"position"`
	Speed         float64     `json:"speed"`
	StartPosition []float64   `json:"StartPosition"`
	State         string      `json:"state"`
	Type          string      `json:"type"`
}

type Hand

type Hand struct {
	Direction              []float64   `json:"direction"`
	ID                     int         `json:"id"`
	PalmNormal             []float64   `json:"palmNormal"`
	PalmPosition           []float64   `json:"PalmPosition"`
	PalmVelocity           []float64   `json:"PalmVelocity"`
	R                      [][]float64 `json:"r"`
	S                      float64     `json:"s"`
	SphereCenter           []float64   `json:"sphereCenter"`
	SphereRadius           float64     `json:"sphereRadius"`
	StabilizedPalmPosition []float64   `json:"stabilizedPalmPosition"`
	T                      []float64   `json:"t"`
	TimeVisible            float64     `json:"TimeVisible"`
}

func (*Hand) X

func (h *Hand) X() float64

X returns hand x value

func (*Hand) Y

func (h *Hand) Y() float64

Y returns hand y value

func (*Hand) Z

func (h *Hand) Z() float64

Z returns hand z value

type InteractionBox

type InteractionBox struct {
	Center []int     `json:"center"`
	Size   []float64 `json:"size"`
}

type LeapMotionAdaptor

type LeapMotionAdaptor struct {
	// contains filtered or unexported fields
}

func NewLeapMotionAdaptor

func NewLeapMotionAdaptor(name string, port string) *LeapMotionAdaptor

NewLeapMotionAdaptor creates a new leap motion adaptor using specified name and port

func (*LeapMotionAdaptor) Connect

func (l *LeapMotionAdaptor) Connect() (errs []error)

Connect returns true if connection to leap motion is established succesfully

func (*LeapMotionAdaptor) Finalize

func (l *LeapMotionAdaptor) Finalize() (errs []error)

Finalize ends connection to leap motion

func (*LeapMotionAdaptor) Name

func (l *LeapMotionAdaptor) Name() string

func (*LeapMotionAdaptor) Port

func (l *LeapMotionAdaptor) Port() string

type LeapMotionDriver

type LeapMotionDriver struct {
	gobot.Eventer
	// contains filtered or unexported fields
}

func NewLeapMotionDriver

func NewLeapMotionDriver(a *LeapMotionAdaptor, name string) *LeapMotionDriver

NewLeapMotionDriver creates a new leap motion driver with specified name

Adds the following events:

"message" - Gets triggered when receiving a message from leap motion

func (*LeapMotionDriver) Connection

func (l *LeapMotionDriver) Connection() gobot.Connection

func (*LeapMotionDriver) Halt

func (l *LeapMotionDriver) Halt() (errs []error)

Halt returns true if driver is halted succesfully

func (*LeapMotionDriver) Name

func (l *LeapMotionDriver) Name() string

func (*LeapMotionDriver) ParseFrame

func (l *LeapMotionDriver) ParseFrame(data []byte) Frame

ParseFrame converts json data to a Frame

func (*LeapMotionDriver) Start

func (l *LeapMotionDriver) Start() (errs []error)

Start inits leap motion driver by enabling gestures and listening from incoming messages.

Publishes the following events:

"message" - Emits Frame on new message received from Leap.

type Pointable

type Pointable struct {
	Direction             []float64 `json:"direction"`
	HandID                int       `json:"handId"`
	ID                    int       `json:"id"`
	Length                float64   `json:"length"`
	StabilizedTipPosition []float64 `json:"stabilizedTipPosition"`
	TimeVisible           float64   `json:"timeVisible"`
	TipPosition           []float64 `json:"tipPosition"`
	TipVelocity           []float64 `json:"tipVelocity"`
	Tool                  bool      `json:"tool"`
	TouchDistance         float64   `json:"touchDistance"`
	TouchZone             string    `json:"touchZone"`
}