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 -d -u gobot.io/x/gobot/...

How to Use

package main

import (
	"fmt"

	"gobot.io/x/gobot"
	"gobot.io/x/gobot/platforms/leap"
)

func main() {
	leapMotionAdaptor := leap.NewAdaptor("127.0.0.1:6437")
	l := leap.NewDriver(leapMotionAdaptor)

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

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

	robot.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 gobot.io/x/gobot/platforms/leap

Example:

package main

import (
	"fmt"

	"gobot.io/x/gobot"
	"gobot.io/x/gobot/platforms/leap"
)

func main() {
	leapMotionAdaptor := leap.NewAdaptor("127.0.0.1:6437")
	l := leap.NewDriver(leapMotionAdaptor)

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

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

	robot.Start()
}

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

Index

• Constants
• type Adaptor
  • func NewAdaptor(port string) *Adaptor
  • func (l *Adaptor) Connect() (err error)
  • func (l *Adaptor) Finalize() (err error)
  • func (l *Adaptor) Name() string
  • func (l *Adaptor) Port() string
  • func (l *Adaptor) SetName(n string)
• type Driver
  • func NewDriver(a *Adaptor) *Driver
  • func (l *Driver) Connection() gobot.Connection
  • func (l *Driver) Halt() (errs error)
  • func (l *Driver) Name() string
  • func (l *Driver) ParseFrame(data []byte) Frame
  • func (l *Driver) SetName(n string)
  • func (l *Driver) Start() (err error)
• type Frame
• type Gesture
• type Hand
  • func (h *Hand) X() float64
  • func (h *Hand) Y() float64
  • func (h *Hand) Z() float64
• type InteractionBox
• type Pointable

Constants

const (
	// MessageEvent event
	MessageEvent = "message"
	// HandEvent event
	HandEvent = "hand"
	// GestureEvent event
	GestureEvent = "gesture"
)

Types

type Adaptor

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

Adaptor is the Gobot Adaptor connection to the Leap Motion

func NewAdaptor

func NewAdaptor(port string) *Adaptor

NewAdaptor creates a new leap motion adaptor using specified port, which is this case is the host IP or name of the Leap Motion daemon

func (*Adaptor) Connect

func (l *Adaptor) Connect() (err error)

Connect returns true if connection to leap motion is established successfully

func (*Adaptor) Finalize

func (l *Adaptor) Finalize() (err error)

Finalize ends connection to leap motion

func (*Adaptor) Name

func (l *Adaptor) Name() string

Name returns the Adaptor Name

func (*Adaptor) Port

func (l *Adaptor) Port() string

Port returns the Adaptor Port which is this case is the host IP or name

func (*Adaptor) SetName

func (l *Adaptor) SetName(n string)

SetName sets the Adaptor Name

type Driver

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

Driver the Gobot software device to the Leap Motion

func NewDriver

func NewDriver(a *Adaptor) *Driver

NewDriver creates a new leap motion driver

Adds the following events:

"message" - Gets triggered when receiving a message from leap motion
"hand" - Gets triggered per-message when leap motion detects a hand
"gesture" - Gets triggered per-message when leap motion detects a gesture

func (*Driver) Connection

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

Connection returns the Driver's Connection

func (*Driver) Halt

func (l *Driver) Halt() (errs error)

Halt returns nil if driver is halted successfully

func (*Driver) Name

func (l *Driver) Name() string

Name returns the Driver Name

func (*Driver) ParseFrame

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

ParseFrame converts json data to a Frame

func (*Driver) SetName

func (l *Driver) SetName(n string)

SetName sets the Driver Name

func (*Driver) Start

func (l *Driver) Start() (err 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.
"hand" - Emits Hand when detected in message from Leap.
"gesture" - Emits Gesture when detected in message from Leap.

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        uint64         `json:"timestamp"`
}

Frame is the base representation returned that holds every other objects

type Gesture

type Gesture struct {
	Center        []float64 `json:"center"`
	Direction     []float64 `json:"direction"`
	Duration      int       `json:"duration"`
	HandIDs       []int     `json:"handIds"`
	ID            int       `json:"id"`
	Normal        []float64 `json:"normal"`
	PointableIDs  []int     `json:"pointableIds"`
	Position      []float64 `json:"position"`
	Progress      float64   `json:"progress"`
	Radius        float64   `json:"radius"`
	Speed         float64   `json:"speed"`
	StartPosition []float64 `json:"StartPosition"`
	State         string    `json:"state"`
	Type          string    `json:"type"`
}

Gesture is a Leap Motion gesture that has been detected

type Hand

type Hand struct {
	ArmBasis               [][]float64 `json:"armBasis"`
	ArmWidth               float64     `json:"armWidth"`
	Confidence             float64     `json:"confidence"`
	Direction              []float64   `json:"direction"`
	Elbow                  []float64   `json:"elbow"`
	GrabStrength           float64     `json:"grabStrength"`
	ID                     int         `json:"id"`
	PalmNormal             []float64   `json:"palmNormal"`
	PalmPosition           []float64   `json:"PalmPosition"`
	PalmVelocity           []float64   `json:"PalmVelocity"`
	PinchStrength          float64     `json:"PinchStrength"`
	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"`
	Type                   string      `json:"type"`
	Wrist                  []float64   `json:"wrist"`
}

Hand is a Leap Motion hand that has been detected

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 []float64 `json:"center"`
	Size   []float64 `json:"size"`
}

InteractionBox is the area within which the gestural interaction has been detected

type Pointable

type Pointable struct {
	Bases                 [][][]float64 `json:"bases"`
	BTipPosition          []float64     `json:"btipPosition"`
	CarpPosition          []float64     `json:"carpPosition"`
	DipPosition           []float64     `json:"dipPosition"`
	Direction             []float64     `json:"direction"`
	Extended              bool          `json:"extended"`
	HandID                int           `json:"handId"`
	ID                    int           `json:"id"`
	Length                float64       `json:"length"`
	MCPPosition           []float64     `json:"mcpPosition"`
	PIPPosition           []float64     `json:"pipPosition"`
	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"`
	Type                  int           `json:"type"`
	Width                 float64       `json:"width"`
}

Pointable is a Leap Motion pointing motion that has been detected