Source upload

ml_lme_cvr/vendor/LeapCSharp/Device.cs

@@ -0,0 +1,316 @@
+/******************************************************************************
+ * Copyright (C) Ultraleap, Inc. 2011-2021.                                   *
+ *                                                                            *
+ * Use subject to the terms of the Apache License 2.0 available at            *
+ * http://www.apache.org/licenses/LICENSE-2.0, or another agreement           *
+ * between Ultraleap and you, your company or other organization.             *
+ ******************************************************************************/
+
+namespace Leap
+{
+    using LeapInternal;
+    using System;
+
+    /// <summary>
+    /// The Device class represents a physically connected device.
+    /// 
+    /// The Device class contains information related to a particular connected
+    /// device such as device id, field of view relative to the device,
+    /// and the position and orientation of the device in relative coordinates.
+    /// 
+    /// The position and orientation describe the alignment of the device relative to the user.
+    /// The alignment relative to the user is only descriptive. Aligning devices to users
+    /// provides consistency in the parameters that describe user interactions.
+    /// 
+    /// Note that Device objects can be invalid, which means that they do not contain
+    /// valid device information and do not correspond to a physical device.
+    /// @since 1.0
+    /// </summary>
+    public class Device :
+      IEquatable<Device>
+    {
+
+        /// <summary>
+        /// Constructs a default Device object.
+        /// 
+        /// Get valid Device objects from a DeviceList object obtained using the
+        /// Controller.Devices() method.
+        /// 
+        /// @since 1.0
+        /// </summary>
+        public Device() { }
+
+        public Device(IntPtr deviceHandle,
+                      IntPtr internalHandle,
+                      float horizontalViewAngle,
+                      float verticalViewAngle,
+                      float range,
+                      float baseline,
+                      DeviceType type,
+                      bool isStreaming,
+                      uint status,
+                      string serialNumber)
+        {
+            Handle = deviceHandle;
+            InternalHandle = internalHandle;
+            HorizontalViewAngle = horizontalViewAngle;
+            VerticalViewAngle = verticalViewAngle;
+            Range = range;
+            Baseline = baseline;
+            Type = type;
+            IsStreaming = isStreaming;
+            SerialNumber = serialNumber;
+            UpdateStatus((eLeapDeviceStatus)status);
+        }
+
+        /// <summary>
+        /// For internal use only.
+        /// </summary>
+        public void Update(
+            float horizontalViewAngle,
+            float verticalViewAngle,
+            float range,
+            float baseline,
+            uint status,
+            string serialNumber)
+        {
+            HorizontalViewAngle = horizontalViewAngle;
+            VerticalViewAngle = verticalViewAngle;
+            Range = range;
+            Baseline = baseline;
+            SerialNumber = serialNumber;
+            UpdateStatus((eLeapDeviceStatus)status);
+        }
+
+        /// <summary>
+        /// For internal use only.
+        /// </summary>
+        public void Update(Device updatedDevice)
+        {
+            HorizontalViewAngle = updatedDevice.HorizontalViewAngle;
+            VerticalViewAngle = updatedDevice.VerticalViewAngle;
+            Range = updatedDevice.Range;
+            Baseline = updatedDevice.Baseline;
+            IsStreaming = updatedDevice.IsStreaming;
+            SerialNumber = updatedDevice.SerialNumber;
+        }
+
+        /// <summary>
+        /// Updates the status fields by parsing the uint given by the event
+        /// </summary>
+        internal void UpdateStatus(eLeapDeviceStatus status)
+        {
+            if ((status & eLeapDeviceStatus.eLeapDeviceStatus_Streaming) == eLeapDeviceStatus.eLeapDeviceStatus_Streaming)
+                IsStreaming = true;
+            else
+                IsStreaming = false;
+            if ((status & eLeapDeviceStatus.eLeapDeviceStatus_Smudged) == eLeapDeviceStatus.eLeapDeviceStatus_Smudged)
+                IsSmudged = true;
+            else
+                IsSmudged = false;
+            if ((status & eLeapDeviceStatus.eLeapDeviceStatus_Robust) == eLeapDeviceStatus.eLeapDeviceStatus_Robust)
+                IsLightingBad = true;
+            else
+                IsLightingBad = false;
+            if ((status & eLeapDeviceStatus.eLeapDeviceStatus_LowResource) == eLeapDeviceStatus.eLeapDeviceStatus_LowResource)
+                IsLowResource = true;
+            else
+                IsLowResource = false;
+        }
+
+        /// <summary>
+        /// For internal use only.
+        /// </summary>
+        public IntPtr Handle { get; private set; }
+
+        private IntPtr InternalHandle;
+
+        public bool SetPaused(bool pause)
+        {
+            eLeapRS result = LeapC.LeapSetPause(Handle, pause);
+            return result == eLeapRS.eLeapRS_Success;
+        }
+
+        /// <summary>
+        /// Compare Device object equality. 
+        /// 
+        /// Two Device objects are equal if and only if both Device objects represent the 
+        /// exact same Device and both Devices are valid. 
+        /// 
+        /// @since 1.0 
+        /// </summary>
+        public bool Equals(Device other)
+        {
+            return SerialNumber == other.SerialNumber;
+        }
+
+        /// <summary>
+        /// A string containing a brief, human readable description of the Device object.
+        /// @since 1.0
+        /// </summary>
+        public override string ToString()
+        {
+            return "Device serial# " + this.SerialNumber;
+        }
+
+        /// <summary>
+        /// The angle in radians of view along the x axis of this device.
+        /// 
+        /// The Leap Motion controller scans a region in the shape of an inverted pyramid
+        /// centered at the device's center and extending upwards. The horizontalViewAngle
+        /// reports the view angle along the long dimension of the device.
+        /// 
+        /// @since 1.0
+        /// </summary>
+        public float HorizontalViewAngle { get; private set; }
+
+        /// <summary>
+        /// The angle in radians of view along the z axis of this device.
+        /// 
+        /// The Leap Motion controller scans a region in the shape of an inverted pyramid
+        /// centered at the device's center and extending upwards. The verticalViewAngle
+        /// reports the view angle along the short dimension of the device.
+        /// 
+        /// @since 1.0
+        /// </summary>
+        public float VerticalViewAngle { get; private set; }
+
+        /// <summary>
+        /// The maximum reliable tracking range from the center of this device.
+        /// 
+        /// The range reports the maximum recommended distance from the device center
+        /// for which tracking is expected to be reliable. This distance is not a hard limit.
+        /// Tracking may be still be functional above this distance or begin to degrade slightly
+        /// before this distance depending on calibration and extreme environmental conditions.
+        /// 
+        /// @since 1.0
+        /// </summary>
+        public float Range { get; private set; }
+
+        /// <summary>
+        /// The distance in mm between the center points of the stereo sensors.
+        /// 
+        /// The baseline value, together with the maximum resolution, influence the
+        /// maximum range.
+        /// 
+        /// @since 2.2.5
+        /// </summary>
+        public float Baseline { get; private set; }
+
+        /// <summary>
+        /// Reports whether this device is streaming data to your application.
+        /// 
+        /// Currently only one controller can provide data at a time.
+        /// @since 1.2
+        /// </summary>
+        public bool IsStreaming { get; internal set; }
+
+        /// <summary>
+        /// The device type.
+        /// 
+        /// Use the device type value in the (rare) circumstances that you
+        /// have an application feature which relies on a particular type of device.
+        /// Current types of device include the original Leap Motion peripheral,
+        /// keyboard-embedded controllers, and laptop-embedded controllers.
+        /// 
+        /// @since 1.2
+        /// </summary>
+        public DeviceType Type { get; private set; }
+
+        /// <summary>
+        /// An alphanumeric serial number unique to each device.
+        /// 
+        /// Consumer device serial numbers consist of 2 letters followed by 11 digits.
+        /// 
+        /// When using multiple devices, the serial number provides an unambiguous
+        /// identifier for each device.
+        /// @since 2.2.2
+        /// </summary>
+        public string SerialNumber { get; private set; }
+
+        /// <summary>
+        /// Returns the internal status field of the current device
+        /// </summary>
+        protected uint GetDeviceStatus()
+        {
+            eLeapRS result;
+
+            LEAP_DEVICE_INFO deviceInfo = new LEAP_DEVICE_INFO();
+            deviceInfo.serial = IntPtr.Zero;
+            deviceInfo.size = (uint)System.Runtime.InteropServices.Marshal.SizeOf(deviceInfo);
+            result = LeapC.GetDeviceInfo(InternalHandle, ref deviceInfo);
+
+            if (result != eLeapRS.eLeapRS_Success)
+                return 0;
+            uint status = deviceInfo.status;
+            System.Runtime.InteropServices.Marshal.FreeCoTaskMem(deviceInfo.serial);
+            return status;
+        }
+
+
+        /// <summary>
+        /// The software has detected a possible smudge on the translucent cover
+        /// over the Leap Motion cameras.
+        /// @since 3.0
+        /// </summary>
+        public bool IsSmudged { get; internal set; }
+
+        /// <summary>
+        /// The software has entered low-resource mode
+        /// @since 3.0
+        /// </summary>
+        public bool IsLowResource { get; internal set; }
+
+        /// <summary>
+        /// The software has detected excessive IR illumination, which may interfere 
+        /// with tracking. If robust mode is enabled, the system will enter robust mode when 
+        /// isLightingBad() is true. 
+        /// @since 3.0 
+        /// </summary>
+        public bool IsLightingBad { get; internal set; }
+
+        /// <summary>
+        /// The available types of Leap Motion controllers.
+        /// </summary>
+        public enum DeviceType
+        {
+            TYPE_INVALID = -1,
+
+            /// <summary>
+            /// A standalone USB peripheral. The original Leap Motion controller device.
+            /// @since 1.2
+            /// </summary>
+            TYPE_PERIPHERAL = (int)eLeapDeviceType.eLeapDeviceType_Peripheral,
+
+            /// <summary>
+            /// Internal research product codename "Dragonfly".
+            /// </summary>
+            TYPE_DRAGONFLY = (int)eLeapDeviceType.eLeapDeviceType_Dragonfly,
+
+            /// <summary>
+            /// Internal research product codename "Nightcrawler".
+            /// </summary>
+            TYPE_NIGHTCRAWLER = (int)eLeapDeviceType.eLeapDeviceType_Nightcrawler,
+
+            /// <summary>
+            /// Research product codename "Rigel".
+            /// </summary>
+            TYPE_RIGEL = (int)eLeapDeviceType.eLeapDevicePID_Rigel,
+
+            /// <summary>
+            /// The Ultraleap Stereo IR 170 (SIR170) hand tracking module.
+            /// </summary>
+            TYPE_SIR170 = (int)eLeapDeviceType.eLeapDevicePID_SIR170,
+
+            /// <summary>
+            /// The Ultraleap 3Di hand tracking camera.
+            /// </summary>
+            TYPE_3DI = (int)eLeapDeviceType.eLeapDevicePID_3Di,
+
+            [Obsolete]
+            TYPE_LAPTOP,
+            [Obsolete]
+            TYPE_KEYBOARD
+        }
+    }
+}