Version 3.2.0 Orion

  1. Leap Motion 3d Jam Future Dj Vj Virtual Fan Experiences Mac Os Operating System
  2. Leap Motion 3d Jam Future Dj Vj Virtual Fan Experiences Mac Os X
  3. Leap Motion 3d Jam Future Dj Vj Virtual Fan Experiences Mac Os X
  4. Leap Motion 3d Jam Future Dj Vj Virtual Fan Experiences Mac Os 11

What’s New¶

Download 2.3.1 ›. Get started with our quick setup guides and SDK downloads for the Leap Motion Controller, VR and desktop/laptop modes. Technology updates. APKPure Android latest 3.17.19 APK Download and Install. Discover new release, upcoming apps and games, follow favorite games, groups, members. All you need is APKPure Android App Store!

  • Improved initialization speed
  • Improved stability of tracking some poses
  • Better tracking and initialization in desktop mode
  • Updated Unity Visualizer to fix a latency issue
  • Official LeapC documentation in the SDK package
  • Various changes to LeapC including:
    • Added LeapPixelToRectilinear()
    • Added LeapRectilinearToPixel()
    • Added invalid and unknown device types
    • Renamed eLeapDeviceType to eLeapPID
    • Added record to file and playback from file
    • Added 3x3 Matrix struct
    • Added quaternion to LEAP_PALM to represent orientation
    • Added LeapInterpolateFrameFromTime() function

Known issues¶

  • Our software auto-updating feature will not work when updating from any release prior to 3.2.0. This will work again when going from 3.2.0 to any future updates. You will need to manually update via our developer portal.
  • Some legacy applications are no longer supported on Orion. These apps are Digit Duel, NY Times, Google Earth, Out of the Blocks, PWN9, and TVO Kids Caterpillar Count. These apps will still be available for V2 users.
  • Some poses are not currently tracked as well as V2; this can be seen in the form of occasional bad initialization/reinitialization, right/left misinterpretation, and wrong poses
  • The skeleton hand can shift slightly away from the hand as you move left or right; most noticeable in apps that use Image Hands and also display the skeletal hands
  • Tracking may not work as well with bracelets, watches, sleeves, etc
  • Although very much improved, occluded hands can still get killed at times
  • Devices embedded in HP laptops and keyboards are not supported on Orion
  • Hand confidence is currently always 1.0 and does not fluctuate; a new solution is on the horizon
  • Tools are not currently supported in Orion
  • Automatic controller orientation can in rare cases stop functioning. A Leap Motion service restart will fix this or you can manually orient the controller from the Leap Motion Control Panel.
  • Tracking along the x-axis may appear slightly skewed
  • Desktop mode initialization is not as reliable as HMD mode initialization
  • Pausing/Resuming Tracking can cause the FPS to drop. The workaround is to disconnect and then reconnect the device to bring the FPS back to normal
  • Avast! Antivirus can interfere with Leap Motion Service installation (disable shields to work around)
  • The latest version of the Oculus firmware limits bandwidth for the DK2’s built-in USB port, which harms the controller’s performance. For now, we recommend using the free cable extender bundled with the mount to connect the controller directly to the computer
  • Tracking performance may degrade when closely facing large reflective surfaces like white walls or infrared-reflective curtains.
  • Minimized or out-of-focus applications using the HMD policy flag can affect the service state. Close such programs before switching back to non-VR apps

SDK folder contents¶

  • docs — Leap Motion API reference documentation and sample application tutorials
  • samples — sample applications in C++, Objective-C (Mac only), C#, Java, JavaScript and Python, plus a Makefile for C++ and an Xcode project for Objective-C (Mac only) or Visual Studio project and solution files for C++ (Windows only)
  • include — Leap Motion API header and source files for including in C++ and Objective-C applications
  • lib — compile-time and runtime libraries for all supported programming languages
    • x86 — libraries for 32-bit architectures (Windows and Linux only)
    • x64 — libraries for 64-bit architectures (Windows and Linux only)
    • libstdc++ — the libLeap.dylib library compiled aganst libstdc++ instead of libc++ (Mac only)
    • UnityAssets — plug-in files for Unity Pro
  • util — Utility classes.

Supported operating systems¶

  1. Plenty of musicians and fans are sick of SoundCloud’s expensive hosting costs, haphazard content takedowns, and lagging user experience as the site’s status withers. Audius wants to be the opposite, and offer a new home for artists where they’ll eventually earn 90% of revenue earned and the startup itself can’t remove songs.
  2. At Leap Motion, we envision a future where the physical and virtual worlds blend together into a single magical experience. At the heart of this experience is hand tracking, which unlocks interactions uniquely suited to virtual and augmented reality.
  • Windows 7 and 8
  • Mac OS 10.7 and higher
  • Ubuntu Linux 12.04 LTS and higher

Supported compilers and runtimes¶

  • C++ on Windows: Visual Studio 2008, 2010, 2012, and 2013
  • C++ on Mac: Xcode 3.0+, clang 3.0+, and gcc
  • Objective-C: Mac OS 10.7+, Xcode 4.2+ and clang 3.0+
  • C# for .NET framework versions 3.5 and 4.0
  • Mono version 2.10
  • Unity Pro version 4.0
  • Java versions 6 and 7
  • Python version 2.7

API documentation¶

Leap Motion API reference documentation is located both online at Leap SDK documentation and in the docs folder of the SDK package.

Sample application¶

A working sample application is provided for your reference, with versions written in C++, Objective-C, C#, Java, JavaScript, and Python. Tutorials for these sample applications are provided in the SDK documentation. These tutorials are essentially the Leap Motion “Hello World” and should help you get your development environment set up for creating Leap-enabled applications. The sample code files are available in LeapSDK/samples. You can also find a Makefile, an Xcode project file, and Visual Studio project and solution files in the samples folder.

JavaScript client library¶

The Leap Motion JavaScript client library, leap.js, is open-source and distributed separately from the main Leap Motion SDK. You can download leap.js from https://github.com/leapmotion/leapjs. We encourage community contributions to this library.

Troubleshooting¶

If you have trouble getting reliable hand tracking data in your application, consider the following:

  • Check the Leap Motion icon in the notification area of the Windows Taskbar or Mac Finder bar. The icon will display green if the Leap Motion software is working properly and turn red if errors have occurred. Open the Leap Motion log window and check for errors

  • Run the diagnostic tests using the Leap Motion Control Panel Troubleshooting page

  • Check whether the Leap Motion Controller and software work outside of your application. Run the Leap Motion Visualizer or included sample application to see if other applications can receive motion tracking data

  • Make sure that all libraries required to receive Leap Motion tracking data are in the correct directories or library search paths. Refer to the project setup or “Hello world” articles for the language in which your application is written for details

  • Plug the Leap Motion USB cable directly into your computer (not a USB hub). Remove other USB devices. If another high-bandwidth device is running on the same USB bus, there may not be enough bandwidth for both devices

  • Rule out lighting issues by moving to an environment with standard indoor lighting conditions. That is, one with artificial light at a comfortable reading intensity

  • If the Leap Motion software does not appear to be producing data, stop the Leap Motion service or daemon and restart it. Unplug the Leap Motion Controller and plug it back in

    On Windows, run the following commands as Administrator:

    On Mac, run the following commands:

    sudolaunchctlunload/Library/LaunchDaemons/com.leapmotion.leapd.plist

    sudolaunchctlload/Library/LaunchDaemons/com.leapmotion.leapd.plist

    On Linux, run the following commands:

  • If the Leap Motion log reports repeated disconnects, switch to the Low Resource operating mode. This can indicate congestion on the USB bus.

  • When using Microsoft Visual Studio, if you do not get tracking data when you compile your application in debug mode, but do get tracking data when you compile in release mode, then make sure you are linking with Leapd.lib for the debug configuration of the project.

  • Ensure that ports 6437, 6438, and 6439 on the localhost domain are not blocked by a firewall or other program.

Change log¶

Versions

Leap Motion 3d Jam Future Dj Vj Virtual Fan Experiences Mac Os Operating System

  • Improved initialization speed and tracking of some poses
  • Better tracking and initialization in desktop mode
  • Updated Unity Visualizer to fix a latency issue
  • Official LeapC documentation in the SDK package
  • Various changes to LeapC including:
  • Added LeapPixelToRectilinear()
  • Added LeapRectilinearToPixel()
  • Added invalid and unknown device types
  • Renamed eLeapDeviceType to eLeapPID
  • Added record to file and playback from file
  • Added 3x3 Matrix struct
  • Added quaternion to LEAP_PALM to represent orientation
  • Added LeapInterpolateFrameFromTime() function
  • Significantly reduced the number of false hands appearing on background objects
  • Improved initialization in complex backgrounds and at longer distances
  • Addressed an issue where the hand can become detached at higher hand velocities
  • Addressed a rare service hang while idling for several hours
  • Addressed an issue with the VR Visualizer showing destop mode when using HMDs
  • Addressed a rare crash issue when restarting the service
  • Addressed a small memory leak after pausing/unpausing the service many times
  • Added in the LeapCSharp .NET 3.5, 4.0 and 4.5 DLLs
  • Addressed a judder issue in LeapC when application render FPS and tracking FPS were out of sync
  • Improved initialization when running at lower frame rates
  • Better tracking and higher FPS while in robust mode
  • Improved tracking on the edge of the field of view
  • Adjusted the gamma in the VR Visualizer when in Robust Mode
  • Added an FPS counter in the VR Visualizer
  • Updated the VR Visualizer to support Oculus 1.3
  • Also updated the VR Visualizer to support HTC Vive
  • Fixed a service crash when triggering device auto-orientation after disconnect/reconnect
  • Fixed a communication issue with the service and control panel after closing the Unity Editor
  • Fixed a Unity crash after editing scripts in Unity Editor while a Leap scene is running
  • Report Software Issue in the Troubleshooting section of the control panel functions properly again
  • Resolved an issue that caused device auto-orientation to stop working occasionally
  • Manual device orientation button from the control panel functions again
  • Software log reports device orientation and when HMD/Desktop mode is triggered
  • Rewrote the .NET API wrapper around LeapC
  • Better tracking when hands are occluded or touching
  • LeapC PinchAPI and GrabAPI values no longer return 0
  • Resolved the corrupt characters appearing in software log
  • Resolved the hitching issue seen when running apps
  • Resolved a crash when multiple clients were connected at service start
  • Resolved a crash related to calibration
  • Greater robustness to cluttered backgrounds and ambient light interference
  • Enhanced tracking range that extends to the full length of your arms
  • Faster and better initialization for all hands
  • Lower latency
  • Significantly improved grab-and-drop interactions
  • Lower overall CPU usage
  • Much better finger flexibility allowing for better poses
  • Better tracking on the edge of the field of view
  • Added a VR and PC visualizer to the tray menu
  • Various control panel updates
  • The Unity assets now use a C# binding to a C-language library rather than the SWIG-generated C++ bindings. The new C# API is slightly different then the previous one, especially for images. Currently this new C# API is only used in Unity
  • Deprecated Tools
  • Deprecated Gestures
  • Deprecated Motion APIs (Frame and Hand translation, rotation, scale and related probability estimates)
  • Tracking now automatically resumes after recalibration on Windows
  • Added the setPaused() API
  • Added the isLightingBad() API
  • Added the isSmudged() API
  • Added onLogMessage API to LeapListener
  • A new ‘start_paused’ config flag has been added
  • Fixed touch compatibility for Recalibrate
  • Fixed Recalibrate not being resizable
  • Improved behavior when detecting smudges
  • Apps should now always correctly detect reconnection
  • Updated the C++ sample with examples of the new APIs
  • Removed unneeded Windows DLLs from the SDK
  • Resolved issue that caused tracking latency within apps to increase over time
  • Fix for service crash after disconnecting/reconnecting in HMD mode
  • Fix for errant disk full message in App Home on Windows
  • Fix tracking hang in apps that use Image API
  • Tracking is more accurate while in Robust Mode
  • Slight decrease to current CPU usage
  • Fix for HP firmware updates not triggering
  • Brand new VR out of box experience
  • Added Controller.now() to the Objective-C API
  • Added a feature to avoid poor performance when tracking quality is degraded
  • Privacy policy update and control panel opt out: starting August 15, 2015 when our new privacy policy goes into effect, non-identifiable 32 pixel square infrared hand image data will report back to the server from beta software or tracking modes, and will be used to improve overall tracking quality in future releases. No device ID or other unique identifiers are collected or stored with the image data. May be turned off by unchecking “Send Usage Data” in the Leap Motion Control Panel
  • Images are now on by default
  • Fixed gesture parameters in C#/Unity
  • Fix for Software log and issue report windows preventing shut down on Mac
  • Fix for App Home crash on Mac when disk full message appears
  • Automatic power saving now appears in the software log when triggered
  • Added App Store button when searching App Home for apps not present
  • Added an image.data_pointer hook for faster image API access in Python
  • Fix for device.serial_number in Python
  • Finger.Type is now a property in C#
  • C++: Leap::FingerList and other list types now work with std::find_if()
  • Support for Unity 5 Editor (32-bit)
  • Fixed crash on libxs library
  • Improved error log reporting
  • Improvements to Image while in Robust mode
  • Added Device.baseline to report the distance between the Leap Motion cameras. (In current devices, this is always 40mm, but future devices might use a different value)
  • Invalid Arm objects now have an identity matrix as their basis rather than a zero matrix
  • Added support for Unity 5
  • Improved latency of the Image Api in C# by 2ms
  • Lowered CPU use when processing frames
  • Now code signing the .NET DLLs
  • Added an option to specify if the Leap Motion Control Panel launches on startup
  • Removed libstdc++ version of libLeap.dylib from the OS X SDK. Mac developers must update their projects to use libc++ if they used this library
  • Removed the debug library, Leapd.dll, from the Windows SDK. Windows developers who used Leapd.dll must update their projects to use Leap.dll for both debug and release configurations
  • Fixed an issue where tracking did not resume after sleep on Ubuntu 14.04 or higher
  • Fixed an issue where Tools appeared as hands
  • Added HMD Visualizer view mode
  • Various installation fixes
  • Added serialNumber to the Device and LeapDevice classes
  • In C# (and Unity), changed Controller.Images from a method to a property
  • In Python, changed Controller.images from a method to a property
  • Linux SDK samples now compile without error
  • Fixed an issue where the LEDs would stay on when Pausing Tracking
  • Fixed issue in which tool tracking stopped working after a computer resumed from sleep
  • Added APIs for all language bindings (except JavaScript):
    • Controller.images()
    • Listener.onImages()
    • Image.sequenceID()
  • Added LeapFrame serialize and deserialize functions for Objective-C language binding
  • Began compiling the language bindings for Python, Java and C# against libc++ by default rather than libstdc++
  • In the Mac SDK, the version of libLeap.dylib found in the SDK lib folder is compiled against libc++. A version compiled against libstdc++ is now available in the SDK lib/libstdc++ folder
  • Refactored the underlying communication mechanism between the Leap Motion hardware and the service/daemon
  • Optimized the amount of CPU used in apps that use image-passthrough
  • Various bug fixes and performance improvements
  • VR improvements
  • Screen and Key Taps function better in HMD mode
  • HMD mode now available in visualizer by cycling view mode once (V key)
  • Hand initialization improvements
  • Various bug fixes and performance improvements
  • Added setPolicy(), clearPolicy() and isPolicySet()
  • Deprecated setPolicyFlags() and policyFlags()
  • Fix for OS X 10.10 IPv6 localhost error
  • Fix for apps crashing on OS X 10.10 built with codesigned libLeapCSharp.dylib
  • Added support for the Image API to Objective-C
  • Newly rebranded App Store and App Home
  • Introducing 2 new apps created by the Leap Motion team: Shortcuts and Playground
  • Smoother hand movements with reduced jitter
  • Enhanced pose identification (e.g. finger positions)
  • Improved hand initialization (including orientation and left vs. right)
  • Better hand stability when the palm, or back of the hand, is facing towards the device
  • To improve the reliability of hand tracking, tool tracking is now turned off by default – to enable, check the box in the Tracking pane
  • Diagnostic Visualizer and API provides accurate currentFramesPerSecond() (old data FPS renamed to device FPS)
  • Automatic Power Saving option (reduces framerate when hands are stationary)
  • Playground now available for Linux
  • Fixed foreground/background focus detection on Windows (requires updating DLLs)
  • Fixed Linux defunct processes (requires updating DLLs)
  • Various bug fixes and performance improvements
  • Important: “Optimize for head-mounted tracking” is now controlled by the API policy flag (introduced in 2.1.2) rather than a user checkbox or configuration setting. Apps must be updated accordingly
  • Various bug fixes and performance improvements
  • V1 applications are now compatible with V2 tracking (beta)
  • Airspace Home renamed to App Home (beta)
  • New Playground app (in beta), which is a newer version of V1 Orientation
  • New out-of-the-box experience (beta)
  • V2 tracking now fully supports HP-embedded devices
  • Pre-bundled apps can be used without having an App Home account
  • LeapArm class added to Objective-C API
  • Various bug fixes and performance improvements
  • Greater stability and better initializations to top down tracking
  • Better finger bending to top down tracking
  • Hands disappear less often over complex backgrounds in top down tracking
  • Significantly reduced hand jitter in top down tracking
  • Consistent high frame rate for image passthrough
  • New Control Panel options to enable/disable robust mode, tool tracking, and hand tracking
  • Image API now available for Linux
  • Uninstall now cleans up WebSocket TLS private keys
  • Restored Visual C++ 2013 x64 runtime for Java and Python
  • Airspace Home now supports authenticated proxy connections
  • 64-bit Windows service added for latency/CPU reduction
  • Various bug fixes
  • New Image API allows for image pass-through (off by default; switch setting in Leap Motion Control Panel)
  • New Serialization API, Frame::serialize() and Frame::deserialize(), for recording and replaying tracking data
  • WebSockets TLS support for Chrome (Mac and Windows), Internet Explorer 11, and Safari
  • More robust tracking for different hand and finger sizes
  • arm.Center now available for C#, Java, and Python
  • arm.Basis corrected for right hand
  • Various bug fixes
  • Performance improvements
  • Reduced number of sockets used by client library
  • Fixed crash on OS X 10.10 Yosemite
  • Various bug fixes
  • Performance improvements
  • Arm property added to Hand class in JavaScript. The Arm is a type of Bone
  • Added Arm class to represent the arm to whch a hand is attached
  • Added Hand.arm
  • Added Hand.wristPosition
  • Various bug fixes
  • Stability and performance enhancements
  • Added LeapBone and related APIs to Objective-C
  • Improved initial hand recognition
  • LeapUtilGL.cpp provides a drawSkeletonHand() convenience function
  • Bone API sample code (C++, C#, Java, Python, JavaScript)
  • Fixed crash in Hand::invalid().pointables()
  • Fixed C# property for Bone.Center
  • Bone.width() and Bone.length() now return float
  • Minor stability improvements
  • Minor performance improvements
  • If tracking is paused, this state will be remembered on wake from sleep. This addresses the issue that the peripheral would always resume from sleep with tracking on

Build 15462 fixed the following issues:

  • Some problems with initial hand recognition and identification
  • Small tools occasionally recognized as hands
  • Thumbs sometimes read as not extended if the thumb is angled downwards
  • Repeatedly pinching can lead to minor tracking problems
  • Tap gesture not very sensitive

Build 15216

  • Added Bone API (not available in Objective-C in this release):
    • Bone objects describe the position and orientation of the bones in the hand model. You can use the Bone API for such purposes as detecting hand poses and displaying animated hand models with a good degree of fidelity
    • As part of the new Bone API, the metacarpal bone is tracked. Note, however, that this model for the thumb does not quite match the standard anatomical naming system. A real thumb has one less bone than the other fingers. However, for ease of programming, the Leap Motion thumb model includes a zero-length metacarpal bone so that the thumb has the same number of bones at the same indexes as the other fingers. As a result the thumb’s anatomical metacarpal bone is labeled as a proximal phalanx and the anatomical proximal phalanx is labeled as the intermediate phalanx in the Leap Motion finger model.
    • In C++, C#, Java, and Python, the new Bone API includes (see the API reference for each programming language for the exact function and property names):
      • Finger.bone
      • Bone class
      • Bone.basis
      • Bone.direction
      • Bone.length
      • Bone.prevJoint
      • Bone.nextJoint
      • Bone.type
      • Bone.width
      • Bone Type enumeration (for languages that support enumerations)
      • TYPE_METACARPAL
      • TYPE_PROXIMAL
      • TYPE_INTERMEDIATE
      • TYPE_DISTAL
    • In JavaScript, the Bone API includes:
      • Finger.bones
      • Finger.type (indexed 0-4: thumb-pinky)
      • Finger.metacarpal
      • Finger.proximal
      • Finger.intermediate
      • Finger.distal
      • Finger.btipPosition
      • Finger.dipPosition
      • Finger.pipPosition
      • Finger.mcpPosition
      • Finger.carpPosition
      • Bone class
      • Bone.basis
      • Bone.direction
      • Bone.length
      • Bone.prevJoint
      • Bone.nextJoint
      • Bone.type
      • Bone.width
  • Deprecated the Finger.jointPosition() function and the Finger.Joint enumeration. Get joint positions from a Bone object instead
  • Added Hand.width
  • Removed Examples folder and its contents from the SDK package

Build 3214

  • Added skeleton model APIs:

    • Hand.confidence
    • Hand.grabStrength
    • Hand.isLeft
    • Hand.isRight
    • Hand.pinchStrength
    • Finger.type
    • Finger.jointPosition
    • Finger.Joint enumeration
    • Finger.Type enumeration
    • FingerList.extended
    • FingerList.fingerType
    • Pointable.isExtended
    • PointableList.extended

  • The WebSocket subprotocol version increased to 0.6.0 and adds the data necessary to support the above APIs in WebSocket client libraries

  • Added width to Pointable objects representing fingers in the WebSocket subprotocol

  • Changed the way enumeration member names are formatted in C#. Previously, an enumeration member was formatted with out underscore characters, as in: BACKGROUNDPOLICYFLAG. Now the member name is separated by underscore characters: BACKGROUND_POLICY_FLAG

  • Added support for detecting whether a Leap Motion controller is a standalone USB peripheral or whether it is embedded in a laptop or keyboard
    • Device.isEmbedded
    • Device.isStreaming
    • Device.type
  • Added support for detecting whether the Leap Motion service/daemon is connected when the device is not plugged in
    • Controller.isServiceConnected
    • Listener.onServiceConnect
    • Listener.onServiceDisconnect
  • Added onDeviceChange event
  • WebSocket subprotocol version increased to 0.5.0
    • Added deviceEvent messages
    • Removed deviceConnect messages (use deviceEvent messages instead)
  • Deprecated Screen, ScreenList, LeapScreen, and the LeapScreenList category
  • Fixed crash that occurred when setting Config parameters and developing with Visual Studio
  • Better support for localization in the installer
  • General stability fixes
  • Status LED display consistency
  • Fixes to the annoying Leap Motion Control Panel warning text bubbles
  • Other minor bug fixes
  • The first version 1.0 release of the Leap Motion software development kit
  • Background applications no longer receive frames of tracking data when a Leap-enabled application has operating system focus. They do, however, still receive frames when a non-Leap-enabled application has focus, provided the user has enabled background applications in the Leap Motion Control Panel
  • Fixed a bug that caused instabilities when Hand::frame() or other methods that call it were called
  • Fixed a bug that calculated hand motion (translation, rotation, and scaling) probabilities incorrectly
  • Removed the following methods that had been deprecated since version 0.7.7:
    • Controller::calibratedScreens() — use Controller::locatedScreens() instead.
    • PointableList::empty() — use PointableList::isEmpty() instead.
    • FingerList::empty() — use FingerList::isEmpty() instead.
    • ToolList::empty() — use ToolList::isEmpty() instead.
    • HandList::empty() — use HandList::isEmpty() instead.
    • GestureList::empty() — use GestureList::isEmpty() instead.
    • ScreenList::empty() — use ScreenList::isEmpty() instead.
  • Separated the OS Interaction multitouch and mouse emulation feature into a separate application, downloadable from the Airspace Store
  • Reorganized the Leap Motion Control Panel to simplify and streamline the settings available to consumers
  • Added a diagnostic test facility, which can be initiated from the Troubleshooting page of the Leap Motion Control Panel
  • Changed the Visualizer application opened from the task/menu bar icon’s menu to a simplified, consumer-facing version. The original, developer-facing Diagnostic Visualizer can be opened from the Troubleshooting page of the Leap Motion Control Panel
  • Removed the Screen Locator tool. We are re-evaluating this feature due to the difficulty in performing the location procedure and confusion about its purpose. The Screen class still exists in the API, but should not be used in consumer-facing applications until the Screen Locator tool (or an equivalent utility) is available
  • Added the Airspace Home application, the desktop portion of the Airspace Store. (Launch from the Leap Motion task/menu bar icon’s menu)
  • Added OS Interaction controls providing multitouch and mouse emulation. (Enable on the OS Interaction page of the Leap Motion Settings dialog)
  • Added the Hand::stabilizedPalmPosition attribute, which reports a stabilized position analogous to the Pointable::stabilizedTipPosition attribute
  • Added the Hand::timeVisible and Pointable::timeVisible attributes, which report how long the associated hand, finger, or tool has been visible
  • Added the Frame::currentFrameRate attribute, which reports the current rate at which the Leap Motion software is generating frames of tracking data
  • Improved the stability of Pointable ID assignments
  • Added a protocol version string to the WebSocket endpoint URL. Use ws://localhost:6347/v1.json for the original JSON protocol. Use ws://localhost:6347/v2.json for the newer JSON protocol introduced in 0.8.0. Clients that do not request a specific protocol will get version 1
  • Added a “heartbeat” message to the WebSocket JSON protocol version 2 and JavaScript client library. The heartbeat tells the Leap Motion service/daemon that a Leap-enabled web application using the WebSocket protocol is active so that OS Interaction can be disabled to avoid interfering
  • Added logic to help prevent background objects like faces and shirts from appearing in the Leap Motion tracking data. (Enable Hand and Tool Isolation on the Advanced page of the Leap Motion Settings dialog)
  • Added an option to adaptively reduce the frame rate based on the amount of activity in the field of view. (Enable Automatic Power Saving on the Advanced page of the Leap Motion Settings dialog)
  • The Leap Motion installer for Windows now includes the Windows 7 multitouch drivers
  • The Leap Motion installer for Windows now includes the Visual C++ 2010 Redistributable so the related Microsoft libraries no longer need to be included with your applications
  • Separated the Leap Motion software into two components: a service (Windows) or daemon (Mac/Linux) process and a task bar (Windows) or menu bar (Mac/Linux) icon application
  • Added a .pkg installer (Mac only) that installs both components of the Leap Motion software
  • Added a touch emulation API to the Pointable class, including the touchZone, touchDistance, and stabilizedTipPosition methods
  • Added the InteractionBox class, which provides normalized coordinates for hand, finger, tool, and gesture positions within this box. Normalized coordinates can make it easier to map positions in the Leap Motion coordinate system to 2D or 3D coordinate systems used for application drawing
  • Added the Device and DeviceList classes, which provide information about the view angle and range of a Leap Motion Controller
  • Updated the Visualizer application to display device range and current interaction box. Press “L” to cycle between different modes
  • Added a drawing mode to the Visualizer application, which demonstrates the touch emulation API. Press “D” to turn drawing on and off. Press space bar to clear the drawing
  • Fixed an issue that required restarting the Leap Motion software when a device was unplugged and plugged into a different USB port
  • Fixed USB-related stability issues affecting first-generation Mac Pro and other legacy chipsets
  • Fixed problems that prevented the Leap Motion software from running on Windows XP
  • Added support for Ubuntu 13.04 Raring Ringtail

Note: The Leap Motion JavaScript library (available on the LeapJS CDN) does not currently support the Device and DeviceList classes.

  • Added support for background applications (Mac and Windows only):
    • Added the Controller::PolicyFlag enumeration.
    • Added the Controller::policyFlag() method to get policy flag status.
    • Added the asynchronous Controller::setPolicyFlag() method to request a change to policy flags.
    • Added the Allow Background Apps checkbox to the Leap Motion settings to globally override background app policy requests.
  • Improved tracking accuracy when hands are distant from the Leap Motion Controller (more than 1 foot / 30 cm).
  • Fixed a tracking reliability issue introduced in version 0.7.8.
  • Fixed a bug in which the Leap Motion Controller was sometimes not recognized when first connected to a computer.
  • Fixed a bug that disabled auto-check for updates on Linux.
  • Digitally signed all binaries authored by Leap Motion (Mac and Windows only).
  • Updated device firmware to version 17.
  • Applications no longer receive empty frames of data when they don’t have operating system focus (Mac and Windows only).
  • Added an Objective-C documentation set that can be installed in Xcode and provide context-sensitive help (Mac only).
  • Changed the Objective-C PointableOrHandList category’s leftmost, rightmost, and frontmost methods to work with empty lists by returning nil when the NSArray is empty (Mac only).
  • Fixed a bug with the Objective-C PointableOrHandList category’s leftmost method (Mac only).
  • Fixed a bug in the Leap Motion JavaScript library (available on the LeapJS CDN) that prevented apps using the library from running in browsers other than Google Chrome.
  • Disabled the Screen Locator tool in the Leap Motion application settings on Linux because it is not currently supported.
  • Updated device firmware to version 15.
  • Improved hand/palm tracking robustness and noise rejection.
  • Added methods to the Frame and Hand classes that report probabilities that a frame or hand’s motion is primarily translation, rotation, or scaling. You can use these probabilities to exclude or dampen unwanted transformations.
  • Added parameters for configuring gesture recognition:
    • SwipeGesture: minimum length and minimum velocity
    • CircleGesture: minimum radius and minimum traced arc
    • KeyTapGesture: minimum velocity, minimum distance and duration of recognition window
    • ScreenTapGesture: minimum velocity, minimum distance and duration of recognition window
  • Added setter methods to the Config class for changing gesture recognition parameters.
  • Added a save() method to the Config class for sending configuration changes to the Leap Motion application.
  • Added methods for getting the leftmost, rightmost, or frontmost entity to the PointableList, FingerList, ToolList, and HandList classes.
  • Added event callbacks to the Listener class that are dispatched by the Controller when an application gains or loses operating system focus (Mac and Windows only).
  • The Leap Motion application now only provides tracking data to the application which has the operating system’s input focus (Mac and Windows only).
  • Added automatic detection of poor calibration to the Leap Motion application.
  • Added automatic detection of lens cover smudges to the Leap Motion application.
  • Added automatic error reporting to the Leap Motion application.
  • In the Objective-C API, changed the name of the [LeapControllercalibratedScreens] selector to [LeapControllerlocatedScreens] (Mac only).
  • Deprecated the following methods:
    • Controller::calibratedScreens() — use Controller::locatedScreens() instead.
    • PointableList::empty() — use PointableList::isEmpty() instead.
    • FingerList::empty() — use FingerList::isEmpty() instead.
    • ToolList::empty() — use ToolList::isEmpty() instead.
    • HandList::empty() — use HandList::isEmpty() instead.
    • GestureList::empty() — use GestureList::isEmpty() instead.
    • ScreenList::empty() — use ScreenList::isEmpty() instead.

Note: The Leap Motion JavaScript library does not currently support focus events or configuration of gesture recognition parameters.

Virtual
  • New finger tracking technique that handles a greater variety of finger orientations, such as parallel to the Leap Motion Controller.
  • First Linux release of the Leap Motion software, SDK, and example applications.
  • Added a Screen::intersect() method to calculate the intersection point of a projected ray with the screen plane.
  • Added a Screen::project() method to calculate the location where a point is projected onto the screen plane.
  • Added a ScreenList::closestScreenHit() method to find the closest screen that a projected ray will intersect.
  • Added a ScreenList::closestScreen() method to find the closest screen to a point.
  • Added a new Screen projection mode to the Visualizer application. Press “B” to cycle between different modes.
  • Added a checkbox to enable/disable automatic device reorientation to the “Tracking” tab in the Leap Motion application settings.
  • Added a checkbox to enable/disable WebSocket connections in a new “WebSocket” tab in the Leap Motion application settings.
  • Added sliders to control framerate and range sensitivity in a new “Advanced” tab in the Leap Motion application settings.
  • Added a standby mode to the Leap Motion application, which reduces CPU usage and USB bandwidth to 10% after 5 minutes of inactivity.
  • Reduced the number of threads and sockets used by the Leap Motion application.
  • Added NSArray+LeapScreenList category to the Objective-C API providing functions for finding the closest screen (Mac only).
  • Removed all const qualifiers from Objective-C API return types (Mac only).
  • Removed unneccessary leapDelegate parameter from the Objective-C function: [LeapControllerremoveDelegate:(id<LeapDelegate>)leapDelegate] (Mac only).
  • Added a complete Objective-C API reference and other Objective-C guides (Mac only).
  • Added a complete Java API reference.
  • Added preliminary API references for Python and C# containing API signatures only.
  • Fixed a bug where NaN values were sent out WebSocket in JSON data frame motion values.
  • Fixed a bug where CircleGesture::duration() started at 0 but progress() was > 0.
  • Updated device firmware to version 14 to improve robustness of firmware updates.
  • Added gestures to the WebSocket JSON output and the JavaScript client library (available on the LeapJS CDN).
  • Added Mac retina display support for Leap Motion application windows.
  • Fixed very low framerate on certain computers when objects enter device field of view.
  • Updated device firmware to version 13.
  • Added an early-stage Gesture API supporting circle, swipe, and two tap gestures. (Not supported in the WebSocket JSON output or JavaScript client library in this version.)
  • Added Gesture visualization to the Visualizer application. Press “O” to turn gestures on and off.
  • Added a GesturesDemo particle field application with source code to the SDK examples.
  • Updated the C++, C#, Java, Python, and Objective-C sample applications to demonstrate the Gesture API.
  • Updated the JavaScript sample, Sample.html, to use the leap.js client library (available on the LeapJS CDN).
  • Updated the recalibration utility to work with revision 6.5 Leap Motion Controllers.
  • Combined the example applications with the SDK so there is only one download package.
  • Removed underscore characters from library names. Important: This is a breaking change. You will have to update your project configurations when updating to version 0.7.4 of the SDK.
  • Objective-C (Mac only): Added NSNotification support for Leap Motion events and changed some method signatures to better conform to language conventions.
  • Added the Leap Motion Device Recalibration utility to the Leap Motion application.
  • Updated device firmware to version 12.
  • Added a Report Bug command to the Leap Motion application menu. This command opens a Bug Report form that allows you to more easily record diagnostics and submit them with bug reports to Leap Motion.
  • Added an option to automatically send diagnostic information to Leap Motion when certain types of errors are encountered by the Leap. This option defaults to off, but we encourage you to turn it on to help us improve the Leap Motion software.
  • Renamed the “Screen Calibration” settings tool to “Screen Locator” to avoid confusion with Leap Motion Controller calibration. Screen Location is only needed to use the Screen class in the Leap Motion API. No other features of the Leap Motion system are affected.
  • Added support for Unity 3.5 (in addition to 4.0) in the UnitySandbox example.
  • Changed the Objective-C library to use automatic reference counting.
  • Improved stability of Leap Motion application.
  • Improved support for revision 5 and 6 Leap Motion developer devices.
  • Tuned processing and motion tracking for revison 6 devices.
  • Updated device firmware to version 10.
  • Added motion properties to Hand and Frame classes, which provide information about the translation, rotation, and scaling of a hand or all objects in a frame.
  • Added isConnected method to the to the Controller class, allowing polling-based applications to know when a controller is connected to the Leap Motion application and device.
  • Added Screen class to represent located screens and perform ray intersection.
  • Added ScreenList class to contain all located screens and find the closest screen intersection.
  • Added ability to establish screen locations to the Leap Motion application settings window.
  • Added ability to display screen information to the Visualizer.
  • Updated Objective-C wrapper for the complete API.
  • Changed format of JSON data sent through WebSocket to prepare for upcoming JavaScript client library.
  • Running a Leap-enabled application compiled with a Leap Motion library with a version greater than the Leap Motion application’s version will trigger the Leap Motion application to check for an update.

Note: The Leap Motion JavaScript library (available on the LeapJS CDN) does not currently support the Screen and ScreenList classes.

Important: Version 0.7.0 contains several changes to the Leap Motion API that are incompatible with previous versions. When updating from an earlier version, you will have to make code changes and recompile your applications. Applications compiled against earlier versions of the API will not work with version 0.7.0 of the Leap Motion application. See the 0.7.0 Migration Guide for tips on updating your application code to work with version 0.7.0 of the Leap Motion API.

  • Added LeapMath.h library containing Vector and Matrix struct definitions.
  • Added Pointable class to abstract characteristics common to fingers and tools.
  • Added Tool class which inherits from Pointable class.
  • Revised Finger class to inherit from Pointable class.
  • Replaced C++ STL vectors with HandList, FingerList, ToolList, and PointableList classes.
  • Replaced nearly all pointers with references (check for isValid() instead of a null pointer).
  • Added convenience methods for retrieving fingers, tools, and pointables directly from a frame or by ID.
  • Added addListener and removeListener methods to the Controller class, allowing multiple listeners to be added to a single controller instance.
  • Added onExit callback to the Listener class, allowing a listener to be notified when it has been removed from a controller.
  • Removed Ray and Ball classes, and flattened methods that returned these objects.
  • Removed hands with id = -1 (“phantom hands”), which were not visible in the frame but contained fingers.
  • Reversed direction vectors on Hand and Finger classes to point forward (this disagreed with documentation).
  • Fixed erroneous hand velocity reporting.
  • Changed the standard type for numeric values used in the API from double to float.
  • Changed member names in C# and Python to reflect the standard capitalization for each language.
  • Changed no-argument const methods to properties in C# and Python.
  • Updated C++, C#, Java, and Python sample applications to use the new API structure.
  • Fixed Java DLL issue for Eclipse on Windows.
  • Added libc++-compatible library on Mac.
  • Added preliminary Objective-C wrapper and sample project (Mac only).
  • Added support for Visual Studio 2008.
  • Added separate window to manage Leap Motion application settings.
  • Added ability for the Leap Motion application to automatically check for updates on startup.
  • Added ability for tracking direction to reorient when a full hand is seen.
  • Improved performance of devices that may have fallen out of calibration.
  • Updated device firmware to version 8.
  • Added preliminary JavaScript support: the Leap Motion application provides a WebSocket server that sends tracking data as JSON messages.
  • Added ability to save Leap Motion application settings between sessions.
  • Added pause to the Leap Motion Visualizer. Use the P key to freeze and unfreeze the display.
  • Improved stability of tracking data.
  • Added Leapd.lib and Leapd.dll for Visual Studio debug build configurations.
  • Added com.leapmotion.leap package to the Java library.
  • Added Leap namespace to the C# library.
  • Added support for Unity projects with C# and the UnityAssets plug-in.
  • Added finger velocity display to the Visualizer application. Use the L key to show finger velocities.
  • Improved transition to and from robust mode when bad lighting conditions are detected.
  • Updated device firmware to version 7.
  • Added the Leap::Ball class to represent the position and radius of a sphere.
  • Added the following member functions to the Leap::Hand class:
    • Hand::normal() — a unit direction vector perpendicular to a plane tangent to the palm
    • Hand::ball() — a sphere fit to the curvature of the hand, as if the hand were holding a ball
  • Added tool detection and tracking. (For backwards compatibility, tools are included in the array of Finger objects attached to a Hand object.)
  • Added the following member functions to the Leap::Finger class:
    • Finger::isTool() — whether or not a finger is likely a tool (e.g., pen, pencil, chopstick)
    • Finger::length() — the length of the finger or tool (as much as is visible)
    • Finger::width() — the width of the finger or tool
  • Added new visualization modes to the Visualizer application:
    • Use the N key to cycle through the new hand properties visualization modes.
    • Use the T key to switch to the new finger and tool visualization mode.
  • Updated C++, C#, Java, and Python sample applications to make use of new hand properties.
  • Finger trails are now cleared in the Visualizer after the Leap Motion disconnects.
  • Axes are now labeled correctly in the Visualizer after recentering the view.
  • Arms are no longer occasionally misclassified as fingers.
  • Added separate C# libraries for .NET 3.5 and .NET 4.0.
  • Combined 32- and 64-bit versions of C# class definition libraries.
  • Fixed issues when using the release Leap.dll in debug mode on Windows.
  • Updated device firmware to version 6.

Leap Motion 3d Jam Future Dj Vj Virtual Fan Experiences Mac Os X

  • Added robust lighting mode to permit operation in bright environments.
  • Added low resource mode to permit operation on slower computers.
  • Added ability to reverse tracking orientation manually.
  • Added support for 64-bit libraries on Windows.
  • Updated device firmware to version 5.
  • Improved stability of C# sample application.
  • Added support for C# development on Mac with Mono.
  • Added support for 64-bit libraries on Mac.
  • Improved stability when switching quality mode.
  • Initial developer beta release of Leap Motion software and SDK.

Leap Motion 3d Jam Future Dj Vj Virtual Fan Experiences Mac Os X

Copyright © 2012-2014 Leap Motion, Inc. All rights reserved.

Leap Motion 3d Jam Future Dj Vj Virtual Fan Experiences Mac Os 11

Use of the Leap Motion SDK is subject to the terms of the Leap Motion SDK Agreement available at https://developer.leapmotion.com/sdk_agreement, or another agreement between Leap Motion and you, your company or other organization.

⇐ ⇐ Speed Demon (Brendan A.) Mac OS
⇒ ⇒ Capture The Flag (One Use Arrow) Mac OS