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)));
}
}
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));
}
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));
}
/**
* 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;
}
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);
}
public static extern eLeapRS RecordingWrite(IntPtr pRecording, ref LEAP_TRACKING_EVENT pEvent, ref UInt64 pnBytesWritten);
public static extern eLeapRS RecordingRead(IntPtr pRecording, ref LEAP_TRACKING_EVENT pEvent, UInt64 ncbEvent);
//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();
}
}
//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);
}
}