private void handleTrackingMessage(ref LEAP_TRACKING_EVENT trackingMsg) {
      Frames.Put(ref trackingMsg);

      if (LeapFrame != null) {
        LeapFrame.DispatchOnContext(this, EventContext, new FrameEventArgs(new Frame().CopyFrom(ref trackingMsg)));
      }
    }
Пример #2
0
        private void handleTrackingMessage(ref LEAP_TRACKING_EVENT trackingMsg)
        {
            Frame newFrame = frameFactory.makeFrame(ref trackingMsg);

            Frames.Put(newFrame);
            this.LeapFrame.Dispatch <FrameEventArgs>(this, new FrameEventArgs(newFrame));
        }
Пример #3
0
        private void handleTrackingMessage(ref LEAP_TRACKING_EVENT trackingMsg)
        {
            Frame newFrame = frameFactory.makeFrame(ref trackingMsg);

            if (_trackedQuadsAreEnabled)
            {
                newFrame.TrackedQuad = this.findTrackQuadForFrame(newFrame.Id);
            }
            Frames.Put(newFrame);
            this.LeapFrame.Dispatch <FrameEventArgs>(this, new FrameEventArgs(newFrame));
        }
Пример #4
0
    /**
     * Copies the data from an internal tracking message into a frame.
     *
     * @param trackingMsg The internal tracking message with the data to be copied into this frame.
     */
    public static Frame CopyFrom(this Frame frame, ref LEAP_TRACKING_EVENT trackingMsg) {
      frame.Id = (long)trackingMsg.info.frame_id;
      frame.Timestamp = (long)trackingMsg.info.timestamp;
      frame.CurrentFramesPerSecond = trackingMsg.framerate;

      frame.ResizeHandList((int)trackingMsg.nHands);

      for (int i = frame.Hands.Count; i-- != 0;) {
        LEAP_HAND hand;
        StructMarshal<LEAP_HAND>.ArrayElementToStruct(trackingMsg.pHands, i, out hand);
        frame.Hands[i].CopyFrom(ref hand, frame.Id);
      }

      return frame;
    }
    public Frame makeFrame(ref LEAP_TRACKING_EVENT trackingMsg)
    {
      Frame newFrame = new Leap.Frame((long)trackingMsg.info.frame_id,
                           (long)trackingMsg.info.timestamp,
                           trackingMsg.framerate,
                           new InteractionBox(trackingMsg.interaction_box_center.ToLeapVector(),
                               trackingMsg.interaction_box_size.ToLeapVector()),
                           new List<Hand>((int)trackingMsg.nHands)
            );

      for (int h = 0; h < trackingMsg.nHands; h++)
      {
        LEAP_HAND hand = StructMarshal<LEAP_HAND>.ArrayElementToStruct(trackingMsg.pHands, h);
        newFrame.Hands.Add(makeHand(ref hand, newFrame));
      }
      return newFrame;
    }
        public Frame makeFrame(ref LEAP_TRACKING_EVENT trackingMsg)
        {
            Frame newFrame = new Leap.Frame((long)trackingMsg.info.frame_id,
                                            (long)trackingMsg.info.timestamp,
                                            trackingMsg.framerate,
                                            new InteractionBox(trackingMsg.interaction_box_center.ToLeapVector(),
                                                               trackingMsg.interaction_box_size.ToLeapVector()),
                                            new List <Hand>((int)trackingMsg.nHands)
                                            );

            for (int h = 0; h < trackingMsg.nHands; h++)
            {
                LEAP_HAND hand = StructMarshal <LEAP_HAND> .ArrayElementToStruct(trackingMsg.pHands, h);

                newFrame.Hands.Add(makeHand(ref hand, newFrame));
            }
            return(newFrame);
        }
        public Frame GetInterpolatedFrame(Int64 time)
        {
            UInt64  size           = GetInterpolatedFrameSize(time);
            IntPtr  trackingBuffer = Marshal.AllocHGlobal((Int32)size);
            eLeapRS result         = LeapC.InterpolateFrame(_leapConnection, time, trackingBuffer, size);

            reportAbnormalResults("LeapC get interpolated frame call was ", result);
            Frame frame = null;

            if (result == eLeapRS.eLeapRS_Success)
            {
                LEAP_TRACKING_EVENT tracking_evt = StructMarshal <LEAP_TRACKING_EVENT> .PtrToStruct(trackingBuffer);

                frame = frameFactory.makeFrame(ref tracking_evt);
            }
            Marshal.FreeHGlobal(trackingBuffer);
            return(frame);
        }
    public Frame makeFrame(ref LEAP_TRACKING_EVENT trackingMsg)
    {
      Frame newFrame = new Leap.Frame((long)trackingMsg.info.frame_id,
                           (long)trackingMsg.info.timestamp,
                           trackingMsg.framerate,
                           new InteractionBox(trackingMsg.interaction_box_center.ToLeapVector(),
                               trackingMsg.interaction_box_size.ToLeapVector()),
                           new List<Hand>((int)trackingMsg.nHands)
            );

      int pHandArrayOffset = 0;
      for (int h = 0; h < trackingMsg.nHands; h++)
      {
        LEAP_HAND hand = LeapC.PtrToStruct<LEAP_HAND>(new IntPtr(trackingMsg.pHands.ToInt64() + pHandArrayOffset));
        pHandArrayOffset += handStructSize;
        newFrame.Hands.Add(makeHand(ref hand, newFrame));
      }
      return newFrame;
    }
Пример #9
0
        public Frame makeFrame(ref LEAP_TRACKING_EVENT trackingMsg)
        {
            Frame newFrame = new Leap.Frame((long)trackingMsg.info.frame_id,
                                            (long)trackingMsg.info.timestamp,
                                            trackingMsg.framerate,
                                            new InteractionBox(trackingMsg.interaction_box_center.ToLeapVector(),
                                                               trackingMsg.interaction_box_size.ToLeapVector()),
                                            new List <Hand>((int)trackingMsg.nHands)
                                            );

            int pHandArrayOffset = 0;

            for (int h = 0; h < trackingMsg.nHands; h++)
            {
                LEAP_HAND hand = LeapC.PtrToStruct <LEAP_HAND>(new IntPtr(trackingMsg.pHands.ToInt64() + pHandArrayOffset));
                pHandArrayOffset += handStructSize;
                newFrame.Hands.Add(makeHand(ref hand, newFrame));
            }
            return(newFrame);
        }
Пример #10
0
 public static extern eLeapRS RecordingWrite(IntPtr pRecording, ref LEAP_TRACKING_EVENT pEvent, ref UInt64 pnBytesWritten);
Пример #11
0
 public static extern eLeapRS RecordingRead(IntPtr pRecording, ref LEAP_TRACKING_EVENT pEvent, UInt64 ncbEvent);
Пример #12
0
        //Run in Polster thread, fills in object queues
        private void processMessages()
        {
            try
            {
                eLeapRS result;
                _leapInit.Dispatch <LeapEventArgs>(this, new LeapEventArgs(LeapEvent.EVENT_INIT));
                while (true)
                {
                    LEAP_CONNECTION_MESSAGE _msg = new LEAP_CONNECTION_MESSAGE();
                    lock (_connLocker) {
                        if (_leapConnection == IntPtr.Zero)
                        {
                            break;
                        }
                        uint timeout = 1000;
                        result = LeapC.PollConnection(_leapConnection, timeout, ref _msg);
                    }

                    if (result != eLeapRS.eLeapRS_Success)
                    {
                        reportAbnormalResults("LeapC PollConnection call was ", result);
                        continue;
                    }

                    switch (_msg.type)
                    {
                    case eLeapEventType.eLeapEventType_Connection:
                        LEAP_CONNECTION_EVENT connection_evt = StructMarshal <LEAP_CONNECTION_EVENT> .PtrToStruct(_msg.eventStructPtr);

                        handleConnection(ref connection_evt);
                        break;

                    case eLeapEventType.eLeapEventType_ConnectionLost:
                        LEAP_CONNECTION_LOST_EVENT connection_lost_evt = StructMarshal <LEAP_CONNECTION_LOST_EVENT> .PtrToStruct(_msg.eventStructPtr);

                        handleConnectionLost(ref connection_lost_evt);
                        break;

                    case eLeapEventType.eLeapEventType_Device:
                        LEAP_DEVICE_EVENT device_evt = StructMarshal <LEAP_DEVICE_EVENT> .PtrToStruct(_msg.eventStructPtr);

                        handleDevice(ref device_evt);
                        break;

                    case eLeapEventType.eLeapEventType_DeviceLost:
                        LEAP_DEVICE_EVENT device_lost_evt = StructMarshal <LEAP_DEVICE_EVENT> .PtrToStruct(_msg.eventStructPtr);

                        handleLostDevice(ref device_lost_evt);
                        break;

                    case eLeapEventType.eLeapEventType_DeviceFailure:
                        LEAP_DEVICE_FAILURE_EVENT device_failure_evt = StructMarshal <LEAP_DEVICE_FAILURE_EVENT> .PtrToStruct(_msg.eventStructPtr);

                        handleFailedDevice(ref device_failure_evt);
                        break;

                    case eLeapEventType.eLeapEventType_Tracking:
                        LEAP_TRACKING_EVENT tracking_evt = StructMarshal <LEAP_TRACKING_EVENT> .PtrToStruct(_msg.eventStructPtr);

                        handleTrackingMessage(ref tracking_evt);
                        break;

                    case eLeapEventType.eLeapEventType_ImageComplete:
                        completeCount++;
                        LEAP_IMAGE_COMPLETE_EVENT image_complete_evt = StructMarshal <LEAP_IMAGE_COMPLETE_EVENT> .PtrToStruct(_msg.eventStructPtr);

                        handleImageCompletion(ref image_complete_evt);
                        break;

                    case eLeapEventType.eLeapEventType_ImageRequestError:
                        failedCount++;
                        LEAP_IMAGE_FRAME_REQUEST_ERROR_EVENT failed_image_evt = StructMarshal <LEAP_IMAGE_FRAME_REQUEST_ERROR_EVENT> .PtrToStruct(_msg.eventStructPtr);

                        handleFailedImageRequest(ref failed_image_evt);
                        break;

                    case eLeapEventType.eLeapEventType_LogEvent:
                        LEAP_LOG_EVENT log_evt = StructMarshal <LEAP_LOG_EVENT> .PtrToStruct(_msg.eventStructPtr);

                        reportLogMessage(ref log_evt);
                        break;

                    case eLeapEventType.eLeapEventType_PolicyChange:
                        LEAP_POLICY_EVENT policy_evt = StructMarshal <LEAP_POLICY_EVENT> .PtrToStruct(_msg.eventStructPtr);

                        handlePolicyChange(ref policy_evt);
                        break;

                    case eLeapEventType.eLeapEventType_ConfigChange:
                        LEAP_CONFIG_CHANGE_EVENT config_change_evt = StructMarshal <LEAP_CONFIG_CHANGE_EVENT> .PtrToStruct(_msg.eventStructPtr);

                        handleConfigChange(ref config_change_evt);
                        break;

                    case eLeapEventType.eLeapEventType_ConfigResponse:
                        handleConfigResponse(ref _msg);
                        break;

                    default:
                        //discard unknown message types
                        Logger.Log("Unhandled message type " + Enum.GetName(typeof(eLeapEventType), _msg.type));
                        break;
                    } //switch on _msg.type
                }     //while running
            }
            catch (Exception e)
            {
                Logger.Log("Exception: " + e);
                this.Cleanup();
            }
        }
Пример #13
0
        //Run in Polster thread, fills in object queues
        private void processMessages()
        {
            try
            {
                eLeapRS result;
                LeapInit.Dispatch <LeapEventArgs>(this, new LeapEventArgs(LeapEvent.EVENT_INIT));
                while (_isRunning)
                {
                    if (_leapConnection != IntPtr.Zero)
                    {
                        LEAP_CONNECTION_MESSAGE _msg = new LEAP_CONNECTION_MESSAGE();
                        uint timeout = 1000;
                        result = LeapC.PollConnection(_leapConnection, timeout, ref _msg);
                        reportAbnormalResults("LeapC PollConnection call was ", result);
                        if (result == eLeapRS.eLeapRS_Success)
                        {
                            switch (_msg.type)
                            {
                            case eLeapEventType.eLeapEventType_Connection:
                                LEAP_CONNECTION_EVENT connection_evt = LeapC.PtrToStruct <LEAP_CONNECTION_EVENT>(_msg.eventStructPtr);
                                handleConnection(ref connection_evt);
                                break;

                            case eLeapEventType.eLeapEventType_ConnectionLost:
                                LEAP_CONNECTION_LOST_EVENT connection_lost_evt = LeapC.PtrToStruct <LEAP_CONNECTION_LOST_EVENT>(_msg.eventStructPtr);
                                handleConnectionLost(ref connection_lost_evt);
                                break;

                            case eLeapEventType.eLeapEventType_Device:
                                LEAP_DEVICE_EVENT device_evt = LeapC.PtrToStruct <LEAP_DEVICE_EVENT>(_msg.eventStructPtr);
                                handleDevice(ref device_evt);
                                break;

                            case eLeapEventType.eLeapEventType_DeviceLost:
                                LEAP_DEVICE_EVENT device_lost_evt = LeapC.PtrToStruct <LEAP_DEVICE_EVENT>(_msg.eventStructPtr);
                                handleLostDevice(ref device_lost_evt);
                                break;

                            case eLeapEventType.eLeapEventType_DeviceFailure:
                                LEAP_DEVICE_FAILURE_EVENT device_failure_evt = LeapC.PtrToStruct <LEAP_DEVICE_FAILURE_EVENT>(_msg.eventStructPtr);
                                handleFailedDevice(ref device_failure_evt);
                                break;

                            case eLeapEventType.eLeapEventType_Tracking:
                                LEAP_TRACKING_EVENT tracking_evt = LeapC.PtrToStruct <LEAP_TRACKING_EVENT>(_msg.eventStructPtr);
                                handleTrackingMessage(ref tracking_evt);
                                break;

                            case eLeapEventType.eLeapEventType_ImageComplete:
                                completeCount++;
                                LEAP_IMAGE_COMPLETE_EVENT image_complete_evt = LeapC.PtrToStruct <LEAP_IMAGE_COMPLETE_EVENT>(_msg.eventStructPtr);
                                handleImageCompletion(ref image_complete_evt);
                                break;

                            case eLeapEventType.eLeapEventType_ImageRequestError:
                                failedCount++;
                                LEAP_IMAGE_FRAME_REQUEST_ERROR_EVENT failed_image_evt = LeapC.PtrToStruct <LEAP_IMAGE_FRAME_REQUEST_ERROR_EVENT>(_msg.eventStructPtr);
                                handleFailedImageRequest(ref failed_image_evt);
                                break;

                            case eLeapEventType.eLeapEventType_TrackedQuad:
                                LEAP_TRACKED_QUAD_EVENT quad_evt = LeapC.PtrToStruct <LEAP_TRACKED_QUAD_EVENT>(_msg.eventStructPtr);
                                handleQuadMessage(ref quad_evt);
                                break;

                            case eLeapEventType.eLeapEventType_LogEvent:
                                LEAP_LOG_EVENT log_evt = LeapC.PtrToStruct <LEAP_LOG_EVENT>(_msg.eventStructPtr);
                                reportLogMessage(ref log_evt);
                                break;

                            case eLeapEventType.eLeapEventType_PolicyChange:
                                LEAP_POLICY_EVENT policy_evt = LeapC.PtrToStruct <LEAP_POLICY_EVENT>(_msg.eventStructPtr);
                                handlePolicyChange(ref policy_evt);
                                break;

                            case eLeapEventType.eLeapEventType_ConfigChange:
                                LEAP_CONFIG_CHANGE_EVENT config_change_evt = LeapC.PtrToStruct <LEAP_CONFIG_CHANGE_EVENT>(_msg.eventStructPtr);
                                handleConfigChange(ref config_change_evt);
                                break;

                            case eLeapEventType.eLeapEventType_ConfigResponse:
                                handleConfigResponse(ref _msg);
                                break;

                            default:
                                //discard unknown message types
                                Logger.Log("Unhandled message type " + Enum.GetName(typeof(eLeapEventType), _msg.type));
                                break;
                            } //switch on _msg.type
                        }     // if valid _msg.type
                        else if (result == eLeapRS.eLeapRS_NotConnected)
                        {
                            this.LeapConnectionLost.Dispatch <ConnectionLostEventArgs>(this, new ConnectionLostEventArgs());
                            result = LeapC.CreateConnection(out _leapConnection);
                            reportAbnormalResults("LeapC CreateConnection call was ", result);
                            result = LeapC.OpenConnection(_leapConnection);
                            reportAbnormalResults("LeapC OpenConnection call was ", result);
                        }
                    } // if have connection handle
                }     //while running
            }
            catch (Exception e)
            {
                Logger.Log("Exception: " + e);
            }
        }