// Recursively get tracking states
public static IEnumerable<TrackingState> GetTrackingStates
(this ITrackable item, TrackingState? trackingState = null,
ObjectVisitationHelper visitationHelper = null)
{
// Prevent endless recursion
ObjectVisitationHelper.EnsureCreated(ref visitationHelper);
if (!visitationHelper.TryVisit(item)) yield break;
foreach (var navProp in item.GetNavigationProperties())
{
foreach (var refProp in navProp.AsReferenceProperty())
{
foreach (var state in refProp.EntityReference.GetTrackingStates(visitationHelper: visitationHelper))
{
if (trackingState == null || state == trackingState)
yield return state;
}
}
foreach (var colProp in navProp.AsCollectionProperty())
{
foreach (ITrackable child in colProp.EntityCollection)
{
foreach (var state in child.GetTrackingStates(visitationHelper: visitationHelper))
{
if (trackingState == null || state == trackingState)
yield return state;
}
}
}
}
yield return item.TrackingState;
}
/// <summary>
/// Initializes a new instance of the <see cref="CustomBody"/> class.
/// </summary>
public CustomBody()
{
_clippedEdges = FrameEdges.None;
_handLeftConfidence = TrackingConfidence.Low;
_handLeftState = HandState.Unknown;
_handRightConfidence = TrackingConfidence.Low;
_handRightState = HandState.Unknown;
_isDisposed = false;
_isRestricted = false;
_isTracked = false;
_joints = new Dictionary<JointType, IJoint>();
_jointOrientations = new Dictionary<JointType, IJointOrientation>();
foreach (var jointType in CustomJointType.AllJoints)
{
_joints.Add(jointType, new CustomJoint(jointType));
_jointOrientations.Add(jointType, new CustomJointOrientation(jointType));
}
_lean = new PointF();
_leanTrackingState = TrackingState.NotTracked;
_trackingId = ulong.MaxValue;
_hasMappedDepthPositions = false;
_hasMappedColorPositions = false;
}
// Recursively set tracking state
public static void SetTrackingState(this ITrackable item,
TrackingState state, ObjectVisitationHelper visitationHelper = null)
{
// Prevent endless recursion
ObjectVisitationHelper.EnsureCreated(ref visitationHelper);
if (!visitationHelper.TryVisit(item)) return;
foreach (var navProp in item.GetNavigationProperties())
{
foreach (var refProp in navProp.AsReferenceProperty())
{
refProp.EntityReference.SetTrackingState(state, visitationHelper);
refProp.EntityReference.TrackingState = state;
}
foreach (var colProp in navProp.AsCollectionProperty())
{
foreach (ITrackable child in colProp.EntityCollection)
{
child.SetTrackingState(state, visitationHelper);
child.TrackingState = state;
}
}
}
}
/// <summary>
/// Create a new <c>CustomJoint</c> object based on the supplied
/// <c>JointType</c> value.
/// </summary>
public CustomJoint(JointType type)
{
_jointType = type;
_position = new CameraSpacePoint();
_depthPosition = new DepthSpacePoint();
_colorPosition = new ColorSpacePoint();
_trackingState = TrackingState.NotTracked;
}
public void Setup()
{
var originalList = new List<NotifyingStringClass> { new NotifyingStringClass() };
this.trackingObservableCollection = new TrackingObservableCollection<NotifyingStringClass>(originalList);
this.trackingObservableCollection.TrackingObservableCollectionChanged += (sender, eventArgs) =>
{
this.trackingState = eventArgs.TrackingState;
};
}
private void MyDataFrameReadyEventHandler(object sender, DataFrameReadyEventArgs e)
{
using (DataFrame dataFrame = e.OpenFrame() as DataFrame)
{
if (dataFrame != null)
{
lastEngineState = dataFrame.Skeletons[0].TrackingState;
}
}
}
private void MyDataFrameReady(object sender, DataFrameReadyEventArgs e)
{
using (var dataFrame = e.OpenFrame() as DataFrame)
{
if (dataFrame != null)
{
state = dataFrame.Skeletons[0].TrackingState;
mySkeleton = dataFrame.Skeletons[0].Joints;
}
}
}
public AnalyticsForm()
{
lineChart.Parent = this.chartPanel;
InitializeComponent();
state = TrackingState.None;
analyticsListBox.SelectedValueChanged +=new EventHandler(analyticsListBox_SelectedValueChanged);
PopulateColorsList();
this.FormClosed += new FormClosedEventHandler(AnalyticsForm_FormClosed);
}
/// <summary>
/// TODO:
/// </summary>
/// <param name="Parent"></param>
/// <param name="Localvec"></param>
public Bone(Bone Parent, Vector3f Localvec, TrackingState ts)
{
if (Parent != null)
{
this.Parent = Parent;
this.LocalVec = Localvec;
}
else
{
this.GlobalVec = LocalVec;
}
this.trackingstate = ts;
}
/// <summary>
/// Constructs a body adapter from a kinect sdk body
/// </summary>
/// <param name="body">Body from Kinect SDK</param>
public KinectBody(Microsoft.Kinect.Body body)
{
this.clippedEdges = body.ClippedEdges;
this.handLeftConfidence = body.HandLeftConfidence;
this.handLeftState = body.HandLeftState;
this.handRightConfidence = body.HandRightConfidence;
this.handRightState = body.HandRightState;
this.isRestricted = body.IsRestricted;
this.isTracked = body.IsTracked;
this.jointOrientations = body.JointOrientations;
this.joints = body.Joints;
this.lean = body.Lean;
this.leanTrackingState = body.LeanTrackingState;
this.trackingId = body.TrackingId;
}
private void MyDataFrameReadyEventHandler(object sender, DataFrameReadyEventArgs e)
{
using (DataFrame dataFrame = e.OpenFrame() as DataFrame)
{
if (dataFrame != null)
{
Skeleton skl = dataFrame.Skeletons[0];
trackingState = skl.TrackingState;
if (SdkManager.IsDebugRun)
{
FrameId = dataFrame.FrameKey.FrameNumberKey;
Debug.Log ("Skeleton frame: " + FrameId + ", state: " + skl.TrackingState + ", proximity: " + skl.Proximity.SkeletonProximity);
}
}
}
}
protected async override Task OnToolActivateAsync(bool active) {
_trackingMouseMove = TrackingState.NotTracking;
if (_pointSymbol == null)
_pointSymbol = await Module1.CreatePointSymbolAsync();
//_lastLocations.Clear();
_lastLocation = null;
_workingLocation = null;
if (!Module1.MessageShown) {
if (!Module1.AreThereAnyLineLayers()) {
MessageBox.Show("You need to add at least one line featurelayer to the map.",
this.Caption);
}
else {
MessageBox.Show("Click on any line feature and hold the mouse down to move the graphic. " +
"The graphic will track the mouse along the selected line feature.",
this.Caption);
Module1.MessageShown = true;
}
}
}
private static void ApplyChangesOnCollectionProperties(TrackingState stateFilter, bool includeState,
EntityNavigationProperty navProp, EntityCollectionProperty <IList> colProp,
DbContext context, ITrackable item, ObjectVisitationHelper visitationHelper, TrackingState?state = null)
{
// Apply changes to 1-M and M-M properties filtering by tracking state
var count = colProp.EntityCollection.Count;
for (int i = count - 1; i > -1; i--)
{
var trackableChild = colProp.EntityCollection[i] as ITrackable;
if (trackableChild != null)
{
bool condition = includeState
? trackableChild.TrackingState == stateFilter
: trackableChild.TrackingState != stateFilter;
if (condition)
{
context.ApplyChanges(trackableChild, item, visitationHelper, navProp.Property.Name, state);
}
}
}
}
// Update is called once per frame
private void Update()
{
Debug.Log(",rG:" + rState.CurrentGesture + ",rD:" + rState.CurrentDirection);
Debug.Log(",lG" + lState.CurrentGesture + ",lD" + lState.CurrentDirection);
var rHandState = InputSources.Instance.hands.GetHandState(rHand.Handedness, 0.1f);
var lHandState = InputSources.Instance.hands.GetHandState(lHand.Handedness, 0.1f);
rState = DetectTracking(rHand, rHandState, rState);
lState = DetectTracking(lHand, lHandState, lState);
_hand.Tracking = HandCoach.HandVisibilityEnum.None;
if (rState.CurrentGesture == TargetRightGesture &&
(rState.CurrentDirection & TargetRightDirection) == TargetRightDirection)
{
_hand.Tracking = HandCoach.HandVisibilityEnum.Right;
}
if (lState.CurrentGesture == TargetLeftGesture &&
(lState.CurrentDirection & TargetLeftDirection) == TargetLeftDirection)
{
_hand.Tracking = _hand.Tracking | HandCoach.HandVisibilityEnum.Left;
}
}
/// <summary>
/// Gets the head pose at the current time or predicted at the given time.
/// </summary>
public OVRPose GetHeadPose(double predictionTime = 0d)
{
#if !UNITY_ANDROID || UNITY_EDITOR
double abs_time_plus_pred = Hmd.GetTimeInSeconds() + predictionTime;
TrackingState state = OVRManager.capiHmd.GetTrackingState(abs_time_plus_pred);
return(state.HeadPose.ThePose.ToPose());
#else
float px = 0, py = 0, pz = 0, ow = 0, ox = 0, oy = 0, oz = 0;
double atTime = Time.time + predictionTime;
OVR_GetCameraPositionOrientation(ref px, ref py, ref pz,
ref ox, ref oy, ref oz, ref ow, atTime);
return(new OVRPose
{
position = new Vector3(px, py, -pz),
orientation = new Quaternion(-ox, -oy, oz, ow),
});
#endif
}
void Update()
{
if (!startTrackerDone)
{
TrackerManager.GetInstance().StartTracker(TrackerManager.TRACKER_TYPE_IMAGE);
startTrackerDone = true;
}
DisableAllTrackables();
TrackingState state = TrackerManager.GetInstance().UpdateTrackingState();
TrackingResult trackingResult = state.GetTrackingResult();
cameraBackgroundBehaviour.UpdateCameraBackgroundImage(state);
for (int i = 0; i < trackingResult.GetCount(); i++)
{
Trackable trackable = trackingResult.GetTrackable(i);
imageTrackablesMap[trackable.GetName()].OnTrackSuccess(
trackable.GetId(), trackable.GetName(), trackable.GetPose());
}
}
void FixedUpdate()
{
TrackingState trackingState = TrackerManager.GetInstance().UpdateTrackingState();
if (trackingState == null)
{
return;
}
cameraBackgroundBehaviour.UpdateCameraBackgroundImage(trackingState);
TrackingResult trackingResult = trackingState.GetTrackingResult();
// state flag
bool arCodeTracked = trackingResult.GetCount() > 0;
// events flags (state changing)
bool arCodeFound = arCode == null && arCodeTracked;
bool arCodeLost = arCode != null && !arCodeTracked;
// Debug.Log("tracked + " + arCodeFound);
// update
if (arCodeTracked)
{
arCode = trackingResult.GetTrackable(0);
arCodeUpdate.Invoke(arCode.GetPose());
}
// call events handlers
if (arCodeFound)
{
this.arCodeFound.Invoke();
}
else if (arCodeLost)
{
Debug.Log("LOST");
arCode = null;
this.arCodeLost.Invoke();
}
}
void Update()
{
DisableAllTrackables();
TrackingState state = TrackerManager.GetInstance().UpdateTrackingState();
if (state == null)
{
return;
}
TrackedImage image = state.GetImage();
cameraBackgroundBehaviour.UpdateCameraBackgroundImage(state);
TrackingResult trackingResult = state.GetTrackingResult();
if (trackingResult.GetCount() > 0)
{
Trackable trackable = trackingResult.GetTrackable(0);
if (cloudTrackablesMap.ContainsKey(trackable.GetCloudName()))
{
foreach (var cloudTrackable in cloudTrackablesMap[trackable.GetCloudName()])
{
cloudTrackable.OnTrackSuccess(trackable.GetId(), trackable.GetName(), trackable.GetPose());
}
}
else
{
if (cloudTrackablesMap.ContainsKey("_MaxstCloud_"))
{
foreach (var cloudTrackable in cloudTrackablesMap["_MaxstCloud_"])
{
cloudTrackable.OnTrackSuccess(trackable.GetId(), trackable.GetName(), trackable.GetPose());
}
}
}
}
}
void Update()
{
DisableAllTrackables();
TrackingState state = TrackerManager.GetInstance().UpdateTrackingState();
if (state == null)
{
return;
}
cameraBackgroundBehaviour.UpdateCameraBackgroundImage(state);
TrackingResult trackingResult = state.GetTrackingResult();
for (int i = 0; i < trackingResult.GetCount(); i++)
{
Trackable trackable = trackingResult.GetTrackable(i);
imageTrackablesMap[trackable.GetName()].OnTrackSuccess(
trackable.GetId(), trackable.GetName(), trackable.GetPose());
}
}
/// <summary>
/// Entry point of pipeline processing, decides whether calibrate or track
/// </summary>
public void Update(TrackingState trackingStateOfGame)
{
if (TrackingCanceled)
{
return;
}
if (!IsTracking)
{
try
{
Calibration();
IsTracking = true;
}
catch (Exception e)
{
TrackingCanceled = true;
if (e is TimeoutException)
{
SendResultMessageToUserThread(new TrackingError(ProgramLocalization.CalibrationNoDataArrived));
}
else if (e is CalibrationException)
{
if (!string.IsNullOrEmpty(e.Message))
{
SendResultMessageToUserThread(new TrackingError(e.Message));
}
}
else
{
SendResultMessageToUserThread(new TrackingError(ProgramLocalization.CalibrationThrewException));
}
}
}
else
{
Tracking(trackingStateOfGame);
}
}
void Update()
{
TrackingState state = TrackerManager.GetInstance().UpdateTrackingState();
if (state == null)
{
return;
}
cameraBackgroundBehaviour.UpdateCameraBackgroundImage(state);
string codeScanResult = state.GetCodeScanResult();
if (!codeScanResult.Equals("") && codeScanResult.Length > 0)
{
Dictionary <string, string> resultAsDicionary =
new JsonReader(codeScanResult).Deserialize <Dictionary <string, string> >();
codeFormatText.text = "Format : " + resultAsDicionary["Format"];
codeValueText.text = "Value : " + resultAsDicionary["Value"];
}
}
/// <summary>
/// Performs averaging of currently saved states
/// </summary>
/// <param name="trackingState">Arrived state</param>
/// <returns>Averaged result</returns>
private TrackingState Averaging(TrackingState trackingState)
{
AveragingQueue.Enqueue(new TimestampObject <TrackingState>(trackingState));
var now = DateTime.Now;
// discard all states older than x seconds
var temp = AveragingQueue.ToList();
temp.RemoveAll(x => Math.Abs((now - x.Timestamp).Seconds) > 2);
AveragingQueue = new Queue <TimestampObject <TrackingState> >(temp);
// don't average if there aren't enough samples
if (AveragingQueue.Count <= 3)
{
return(null);
}
// choose most common tracking state
List <Tuple <TrackingState, int> > aggregation = new List <Tuple <TrackingState, int> >();
foreach (var state in AveragingQueue)
{
if (aggregation.Any(x => x.Item1.IsEquivalentTo(state.StoredObject)))
{
var old = aggregation.Single(x => x.Item1.IsEquivalentTo(state.StoredObject));
aggregation.Remove(old);
aggregation.Add(new Tuple <TrackingState, int>(old.Item1, old.Item2 + 1));
}
else
{
aggregation.Add(new Tuple <TrackingState, int>(state.StoredObject, 1));
}
}
return(aggregation.OrderByDescending(x => x.Item2).First().Item1);
}
void Update()
{
if (Input.GetKey(KeyCode.Escape))
{
SceneStackManager.Instance.LoadPrevious();
}
StartCamera();
if (!startTrackerDone)
{
TrackerManager.GetInstance().StartTracker(TrackerManager.TRACKER_TYPE_SLAM);
startTrackerDone = true;
}
EnableChildrenRenderer(false);
Debug.Log(TrackerManager.GetInstance().GetGuideInfo().GetInitializingProgress().ToString());
TrackingState state = TrackerManager.GetInstance().UpdateTrackingState();
TrackingResult trackingResult = state.GetTrackingResult();
if (trackingResult.GetCount() == 0)
{
return;
}
EnableChildrenRenderer(true);
Trackable trackable = trackingResult.GetTrackable(0);
Matrix4x4 poseMatrix = trackable.GetPose();
transform.position = MatrixUtils.PositionFromMatrix(poseMatrix);
transform.rotation = MatrixUtils.QuaternionFromMatrix(poseMatrix);
transform.localScale = MatrixUtils.ScaleFromMatrix(poseMatrix);
}
public static TrackableId AddOrUpdate(
TrackableId planeId,
TrackableId?subsumedById,
Pose pose,
Vector2[] boundaryPoints,
TrackingState trackingState,
PlaneAlignment?alignment,
PlaneClassification?classification,
Vector3?center,
Vector2?size)
{
lock (stateLock)
{
if (boundaryPoints == null)
{
throw new ArgumentNullException("boundaryPoints");
}
if (planeId == TrackableId.invalidId)
{
planeId = NativeApi.NewTrackableId();
}
if (!datas.ContainsKey(planeId))
{
datas[planeId] = trackingState;
}
SetPlaneData(planeId, pose, boundaryPoints, alignment, classification, center, size);
if (subsumedById.HasValue)
{
OnSubsumedPlane(planeId, subsumedById.Value);
}
return(planeId);
}
}
/// <summary>
/// Update the source input from the device.
/// </summary>
/// <param name="inputDevice">The InputDevice retrieved from the platform.</param>
/// <returns>Whether position or rotation was successfully updated.</returns>
public bool UpdateSourceData(InputDevice inputDevice)
{
using (UpdateSourceDataPerfMarker.Auto())
{
TrackingState lastState = TrackingState;
LastControllerPose = CurrentControllerPose;
// Check for position and rotation.
bool isPositionAvailable = inputDevice.TryGetFeatureValue(CommonUsages.devicePosition, out Vector3 position);
bool isRotationAvailable = inputDevice.TryGetFeatureValue(CommonUsages.deviceRotation, out Quaternion rotation);
if (isPositionAvailable || isRotationAvailable)
{
IsPositionAvailable = isPositionAvailable;
IsPositionApproximate = false;
IsRotationAvailable = isRotationAvailable;
// Devices are considered tracked if we receive position OR rotation data from the sensors.
TrackingState = (IsPositionAvailable || IsRotationAvailable) ? TrackingState.Tracked : TrackingState.NotTracked;
CurrentControllerPosition = MixedRealityPlayspace.TransformPoint(position);
CurrentControllerRotation = MixedRealityPlayspace.Rotation * rotation;
CurrentControllerPose.Position = CurrentControllerPosition;
CurrentControllerPose.Rotation = CurrentControllerRotation;
// Raise input system events if it is enabled.
if (lastState != TrackingState)
{
CoreServices.InputSystem?.RaiseSourceTrackingStateChanged(InputSource, this, TrackingState);
}
return(true);
}
return(false);
}
}
public void MovementHotKeyDown()
{
if (movement != Movement.HOTKEY || state == TrackingState.ERROR || state == TrackingState.PAUSED)
{
return;
}
if (!movementHotKeyDown)
{
if (!dragging)
{
if (mode == Mode.EYEX_AND_EVIACAM)
{
SendKeys.Send("{F11}"); // trigger eViacam to start tracking
}
warp.RefreshTracking();
state = TrackingState.STARTING;
updatedAtLeastOnce = false;
}
}
movementHotKeyDown = true;
}
public void MergeChanges_Should_Set_Properties_For_Added_Order_With_Null_Customer()
{
// Arrange
var database = new MockNorthwind();
var origOrder = new Order
{
OrderDate = DateTime.Parse("1996-07-04"),
CustomerId = "ALFKI"
};
var changeTracker = new ChangeTrackingCollection <Order>(true)
{
origOrder
};
TrackingState origTrackingState = origOrder.TrackingState;
var addedOrder = AddOrders(database, origOrder)[0];
// Act
changeTracker.MergeChanges(addedOrder);
// Assert
Assert.Equal(TrackingState.Added, origTrackingState);
Assert.Equal(TrackingState.Unchanged, origOrder.TrackingState);
}
internal Body(
Joint[] jointData,
Guid entityId,
bool isTracked,
HandState leftHandState,
TrackingConfidence leftHandConfidence,
HandState rightHandState,
TrackingConfidence rightHandConfidence,
Vector2 lean,
TrackingState leanState,
FrameEdges clippedEdges)
{
Joints = new EnumDictionary <Joint>(jointData);
IsTracked = isTracked;
EntityId = entityId;
HandStateLeft = leftHandState;
ConfidenceLeft = leftHandConfidence;
HandStateRight = rightHandState;
ConfidenceRight = rightHandConfidence;
Lean = lean;
LeanTrackingState = leanState;
ClippedEdges = clippedEdges;
}
protected override Task HandleMouseDownAsync(MapViewMouseButtonEventArgs e)
{
//Select a line feature and place the initial graphic. Clear out any
//previously placed graphic
return(QueuedTask.Run(() => {
var mapPoint = this.ActiveMapView.ClientToMap(e.ClientPoint);
var lineFeature = Module1.SelectLineFeature(mapPoint);
if (lineFeature != null)
{
var nearest = GeometryEngine.Instance.NearestPoint(lineFeature, mapPoint);
lock (_lock) {
_workingLocation = null;
_lineFeature = lineFeature;
if (_graphic != null)
{
_graphic.Dispose();
}
_graphic = this.AddOverlay(nearest.Point, _pointSymbol.MakeSymbolReference());
_trackingMouseMove = TrackingState.CanTrack;
}
}
else
{
lock (_lock) {
_workingLocation = null;
_lineFeature = null;
if (_graphic != null)
{
_graphic.Dispose();
}
_graphic = null;
_trackingMouseMove = TrackingState.NotTracking;
}
}
}));
}
/// <summary>
/// Draws a body
/// </summary>
/// <param name="joints">joints to draw</param>
/// <param name="jointPoints">translated positions of joints to draw</param>
/// <param name="drawingContext">drawing context to draw to</param>
/// <param name="drawingPen">specifies color to draw a specific body</param>
private void DrawBody(IDictionary <JointType, Joint> joints, IDictionary <JointType, Point> jointPoints, DrawingContext drawingContext, Pen drawingPen)
{
// Draw the bones
foreach (var bone in this.bones)
{
if (bone.Item2.ToString().Contains("Right") || bone.Item1.ToString().Contains("Right"))
{
this.DrawBone(joints, jointPoints, bone.Item1, bone.Item2, drawingContext, new Pen(Brushes.WhiteSmoke, 6));
}
else
{
this.DrawBone(joints, jointPoints, bone.Item1, bone.Item2, drawingContext, drawingPen);
}
}
// Draw the joints
foreach (JointType jointType in joints.Keys)
{
Brush drawBrush = null;
TrackingState trackingState = joints[jointType].TrackingState;
if (trackingState == TrackingState.Tracked)
{
drawBrush = this.trackedJointBrush;
}
else if (trackingState == TrackingState.Inferred)
{
drawBrush = this.inferredJointBrush;
}
if (drawBrush != null)
{
drawingContext.DrawEllipse(drawBrush, null, jointPoints[jointType], JointThickness, JointThickness);
}
}
}
void Update()
{
if (instantTrackable == null)
{
return;
}
StartCamera();
if (!startTrackerDone)
{
TrackerManager.GetInstance().StartTracker(TrackerManager.TRACKER_TYPE_INSTANT);
SensorDevice.GetInstance().Start();
startTrackerDone = true;
}
TrackingState state = TrackerManager.GetInstance().UpdateTrackingState();
TrackingResult trackingResult = state.GetTrackingResult();
if (trackingResult.GetCount() == 0)
{
instantTrackable.OnTrackFail();
return;
}
Trackable trackable = trackingResult.GetTrackable(0);
planMatrix = trackable.GetPose();
Matrix4x4 poseMatrix = trackable.GetPose() * Matrix4x4.Translate(touchSumPosition);
instantTrackable.OnTrackSuccess(trackable.GetId(), trackable.GetName(), poseMatrix);
if (Input.touchCount > 0 && !rotationController.getRotationState() && !zoomInOut.getScaleState())
{
UpdateTouchDelta(Input.GetTouch(0).position);
}
}
protected override void OnUpdateFrame(FrameEventArgs e)
{
base.OnUpdateFrame(e);
//get the time the frame will be displayed on the oculus
double displayMidpoint = OvrDLL.ovr_GetPredictedDisplayTime(session, 0);
//get the predicted position of the device at that time
TrackingState ts = OvrDLL.ovr_GetTrackingState(session, displayMidpoint, true);
//calculate eye poses
Vector3[] eyeOffsets = new Vector3[2] { eyes[0].desc.HmdToEyeOffset, eyes[1].desc.HmdToEyeOffset };
Posef[] eyePoses = new Posef[2];
OvrDLL.ovr_CalcEyePoses(ts.HeadPose.ThePose, eyeOffsets, eyePoses);
//get the orientation of the hmd if it was tracked
if (ts.StatusFlags.HasFlag(StatusBits.OrientationTracked))
{
eyes[0].pose.Orientation = eyePoses[0].Orientation;
eyes[1].pose.Orientation = eyePoses[1].Orientation;
}
else
{
eyes[0].pose.Orientation = Quaternion.Identity;
eyes[1].pose.Orientation = Quaternion.Identity;
}
//get the position of the hmd if it was tracked
if (ts.StatusFlags.HasFlag(StatusBits.PositionTracked))
{
eyes[0].pose.Position = eyePoses[0].Position;
eyes[1].pose.Position = eyePoses[1].Position;
}
else
{
eyes[0].pose.Position = Vector3.Zero;
eyes[1].pose.Position = Vector3.Zero;
}
}
public override void Update()
{
base.Update();
DisableAllTrackables();
TrackingState state = TrackerManager.GetInstance().UpdateTrackingState();
if (state == null)
{
return;
}
cameraBackgroundBehaviour.UpdateCameraBackgroundImage(state);
TrackingResult trackingResult = state.GetTrackingResult();
string recognizedID = null;
for (int i = 0; i < trackingResult.GetCount(); i++)
{
Trackable trackable = trackingResult.GetTrackable(i);
int markerId = -1;
if (int.TryParse(trackable.GetName(), out markerId))
{
if (markerTrackableMap.ContainsKey(markerId))
{
markerTrackableMap[markerId].OnTrackSuccess(
trackable.GetId(), trackable.GetName(), trackable.GetPose());
recognizedID += trackable.GetId().ToString() + ", ";
}
}
}
Debug.Log("Recognized Marker id : " + recognizedID);
}
private void TrackingImplementation(TrackingState trackingStateOfGame)
{
var data = Buffer.TryTake();
if (data == null)
{
return;
}
UserParameters = UserParametersFactory.GetShallowCopy();
var inputData = new InputData(data, UserParameters, trackingStateOfGame);
var planeData = PlaneLocalization.Track(inputData);
var chessboardData = ChessboardLocalization.Track(planeData);
var figuresData = FiguresLocalization.Track(chessboardData);
SendResultMessageToUserThread(
new ResultMessage(
figuresData.ResultData.VisualisationBitmap.HorizontalFlip(),
figuresData.ResultData.TrackingState,
figuresData.ResultData.SceneDisrupted,
figuresData.ResultData.PointCountsOverFields)
);
}
public static void Reset()
{
timestampNs = null;
averageBrightness = null;
averageColorTemperature = null;
colorCorrection = null;
projectionMatrix = null;
displayMatrix = null;
trackingState = TrackingState.Tracking;
properties = null;
averageIntensityInLumens = null;
exposureDuration = null;
exposureOffset = null;
mainLightIntensityLumens = null;
mainLightColor = null;
mainLightDirection = null;
ambientSphericalHarmonics = null;
cameraGrain = null;
noiseIntensity = null;
permissionGranted = true;
screenSize = null;
screenOrientation = null;
SetTextures(null, null);
}
private void HandleDataEvent(DataFrameReadyEventArgs dataFrameReadyEventArgs)
{
using (var dataFrame = dataFrameReadyEventArgs.OpenFrame() as DataFrame)
{
if (dataFrame != null) // Making sure it's really DataFrame
{
StringBuilder text = new StringBuilder();
Skeleton skel = dataFrame.Skeletons[0];
if (dataFrame.Skeletons[0] != null)
{
var joints = dataFrame.Skeletons[0].Joints; // Possibly several Skeletons, we'll use the first
TrackingState state = dataFrame.Skeletons[0].TrackingState;
// We only want to display a tracked Skeleton
if (state == TrackingState.Tracked)
{
// Serialize skeleton
string json = new JavaScriptSerializer().Serialize(dataFrame.Skeletons[0]);
SendData(json);
}
}
}
}
}
private void Tracking(TrackingState trackingStateOfGame)
{
PipelineSlowdown();
Semaphore.Wait();
LastReleasedTrackingTask = DateTime.Now;
Task.Run(() =>
{
try
{
TrackingImplementation(trackingStateOfGame);
}
catch (Exception)
{
// ignored
}
finally
{
Semaphore.Release();
}
});
}
private void Update()
{
if (deviceTrackingStateText != null &&
SpatialCoordinateSystemManager.IsInitialized &&
SpatialCoordinateSystemManager.Instance.TrackingState != cachedTrackingState)
{
cachedTrackingState = SpatialCoordinateSystemManager.Instance.TrackingState;
if (!promptDictionary.TryGetValue(cachedTrackingState, out var stateText))
{
Debug.LogError($"Tracking state not supported by DeviceTrackingStateVisual promptDictionary: {cachedTrackingState}");
stateText = promptDictionary[TrackingState.Unknown];
}
deviceTrackingStateText.text = $"{deviceTrackingPrompt} {stateText}";
if (!colorDictionary.TryGetValue(cachedTrackingState, out var stateColor))
{
Debug.LogError($"Tracking state not supported by DeviceTrackingStateVisual colorDictionary: {cachedTrackingState}");
stateColor = colorDictionary[TrackingState.Unknown];
}
deviceTrackingStateText.color = stateColor;
}
}
public void PauseHotKeyDown()
{
log.Debug("Pause key down");
if (pauseMode)
{
pauseMode = false;
if (state != TrackingState.ERROR)
{
warp.RefreshTracking();
log.Debug("State change to starting");
state = TrackingState.STARTING;
updatedAtLeastOnce = false;
}
}
else
{
pauseMode = true;
if (state == TrackingState.STARTING || state == TrackingState.RUNNING)
{
log.Debug("State change to paused");
state = TrackingState.PAUSED;
}
}
}
public Data(double leftHandX, double leftHandY, TrackingState lhTS,
double rightHandX, double rightHandY, TrackingState rhTS,
double leftElbowX, double leftElbowY, TrackingState leTS,
double rightElbowX, double rightElbowY, TrackingState reTS,
GestureType gestureType)
{
LeftHandX = leftHandX;
LeftHandY = leftHandY;
LHTS = lhTS;
RightHandX = rightHandX;
RightHandY = rightHandY;
RHTS = rhTS;
LeftElbowX = leftElbowX;
LeftElbowY = leftElbowY;
LETS = leTS;
RightElbowX = rightElbowX;
RightElbowY = rightElbowY;
RETS = reTS;
GestureType = gestureType;
}
void UpdatePose(TrackingState trackingState)
{
if (trackingState == TrackingState.Tracking)
{
Quaternion q;
Vector3 position;
SonarLib.GetCameraWorldPose(out q, out position);
if (lastTrackingsState == TrackingState.Tracking)
{
q = Quaternion.Slerp(q, lastQ, rotationSmooth);
position = Vector3.Slerp(position, lastPosition, positionSmooth);
lastQ = q;
lastPosition = position;
}
else
{
q = lastQ;
position = lastPosition;
}
transform.localRotation = q;
transform.localPosition = position;
}
lastTrackingsState = trackingState;
}
private void Update()
{
if (RayHitToPlayer())
{
nowTrackingState = TrackingState.APPROACHING;
Vector2 hereVec2 = transform.position;
Vector2 destVec2 = dest.position;
if (Vector2.Distance(hereVec2, destVec2) <= behaveRange)
{
nowTrackingState = TrackingState.BEHAVING;
}
}
else
{
nowTrackingState = TrackingState.ROAMING;
}
if (nowTrackingState != preTrackingState)
{
stateToExitDict[preTrackingState]();
stateToInitDict[nowTrackingState]();
}
stateToUpdateDict[nowTrackingState]();
preTrackingState = nowTrackingState;
}
void maximized()
{
WinSys.GetWindowPlacement( windowHandle, ref windowInformation);
// Ok, if we're not maximized anymore.
if ( (windowInformation.flags & WinSys.SW_SHOWMAXIMIZED) == 0
&& (windowInformation.flags & WinSys.SW_MAXIMIZE) == 0)
{
currentState = TrackingState.TrackingMove;
}
else
{ // we still have to handle the case
// when another window is front of us
// and vim is briggen back to foreground.
WinSys.GetWindowRect(thisHandle, ref thisWindowSize);
WinSys.SetWindowPos( thisHandle
, windowHandle
, thisWindowSize.Left
, thisWindowSize.Top
, thisWindowSize.Right - thisWindowSize.Left
, thisWindowSize.Bottom - thisWindowSize.Top
, 0);
}
}
protected override void OnToolMouseUp(MapViewMouseButtonEventArgs e) {
lock (_lock) {
_trackingMouseMove = TrackingState.NotTracking;
_lineFeature = null;
}
}
/// <summary>
/// Update the joint position based on the referenced <c>IJoint</c>.
/// </summary>
public virtual void Update(IJoint joint)
{
if (this.JointType != joint.JointType)
throw new Exception("Cannot Update with Joint of a different Type");
_position = joint.Position;
_depthPosition = new DepthSpacePoint();
_colorPosition = new ColorSpacePoint();
_trackingState = joint.TrackingState;
}
private NTrackingState ResolveTrackingState(TrackingState state) {
switch (state) {
case TrackingState.Tracked: return NTrackingState.Tracked;
case TrackingState.Inferred: return NTrackingState.Inferred;
case TrackingState.NotTracked: return NTrackingState.NotTracked;
}
return NTrackingState.NotTracked;
}
private KinectBase.TrackingState convertTrackingState(TrackingState trackingState)
{
//Both enums are numbered the same, so we can do a straight cast
return (KinectBase.TrackingState)trackingState;
}
//These methods do the actual calculations of the points
private void RecalculateAllVariables()
{
rightGrab = RecalculateHandGrab(JointType.HandRight);
leftGrab = RecalculateHandGrab(JointType.HandLeft);
skeletonPosition = RecalculatePosition();
skeletonTrackingState = RecalculateSkeletonTrackingState();
mergedSkeleton = new SkeletonData();
for (int i = 0; i < mergedSkeleton.Count; i++)
{
Joint tempJoint = new Joint();
tempJoint.JointType = mergedSkeleton[i].JointType;
tempJoint.Confidence = RecalculateJointConfidence(mergedSkeleton[i].JointType);
tempJoint.Orientation = RecalculateJointOrientation(mergedSkeleton[i].JointType);
tempJoint.Position = RecalculateJointPosition(mergedSkeleton[i].JointType);
tempJoint.TrackingState = RecalculateJointTrackingState(mergedSkeleton[i].JointType);
mergedSkeleton[i] = tempJoint;
}
needsUpdate = false;
}
/// <summary>
/// In this method, we wait till the window has finished it's animation
/// of maximization to tackle ourselves nearby, without changing the
/// maximization state.
/// </summary>
void waitingMaximization()
{
WinSys.GetWindowRect(windowHandle, ref followedWindowSize);
// animation is finished.
if ( WinSys.RECT.Diff( oldPos, followedWindowSize ) == 0 )
{
// ok, the user just to maximize it, we're gonna give it to him
WinSys.GetWindowRect( thisHandle, ref thisWindowSize);
int thisWidth = thisWindowSize.Right - thisWindowSize.Left;
Left = Math.Max( followedWindowSize.Left - thisWidth, 0 );
Top = followedWindowSize.Top;
Height = followedWindowSize.Bottom - followedWindowSize.Top;
WinSys.SetWindowPos( windowHandle
, IntPtr.Zero
, followedWindowSize.Left + thisWidth
, followedWindowSize.Top
, followedWindowSize.Right - followedWindowSize.Left - thisWidth
, followedWindowSize.Bottom - followedWindowSize.Top
, 0
);
WinSys.SetWindowPos( thisHandle
, windowHandle
, followedWindowSize.Left
, followedWindowSize.Top
, thisWidth
, followedWindowSize.Bottom - followedWindowSize.Top
, 0
);
currentState = TrackingState.Maximized;
windowFollowTimer.Interval = windowFollowDelay;
}
oldPos = followedWindowSize;
}
public static Offset<Joint> CreateJoint(FlatBufferBuilder builder,
JointType type = JointType.SpineBase,
TrackingState state = TrackingState.NotTracked,
Offset<Vector2> position2DOffset = default(Offset<Vector2>),
Offset<Vector3> position3DOffset = default(Offset<Vector3>),
Offset<Vector4> rotationOffset = default(Offset<Vector4>))
{
builder.StartObject(5);
Joint.AddRotation(builder, rotationOffset);
Joint.AddPosition3D(builder, position3DOffset);
Joint.AddPosition2D(builder, position2DOffset);
Joint.AddState(builder, state);
Joint.AddType(builder, type);
return Joint.EndJoint(builder);
}
private void ChangeState(TrackingState newState)
{
state = newState;
metricsComboBox.Items.Clear();
switch (state)
{
case TrackingState.Capabilities:
ClearControls("Capabilities");
metricsComboBox.Items.Add("Capability Gap Type");
metricsComboBox.Items.Add("Prioritized Capability Gap Type");
metricsComboBox.Items.Add("Capability Gap Amount");
metricsComboBox.Items.Add("Prioritized Capability Gap Amount");
graphTypeComboBox.Items.Clear();
break;
case TrackingState.CUPEQuestions:
ClearControls("CUPE");
metricsComboBox.Items.Add("Business Future");
metricsComboBox.Items.Add("Business Current");
metricsComboBox.Items.Add("IT Future");
metricsComboBox.Items.Add("IT Current");
graphTypeComboBox.Items.Clear();
graphTypeComboBox.Items.Add("Line Graph");
graphTypeComboBox.Items.Add("Bar Graph");
break;
case TrackingState.Objectives:
ClearControls("Objectives");
metricsComboBox.Items.Add("Total Priority");
break;
case TrackingState.ITAttributes:
ClearControls("Capabilities");
metricsComboBox.Items.Add("Average As Is Score");
metricsComboBox.Items.Add("Average To Be Score");
itAttributesComboBox.Enabled = true;
graphTypeComboBox.Items.Clear();
break;
case TrackingState.Imperatives:
ClearControls("Imperatives");
metricsComboBox.Items.Add("Differentiation");
metricsComboBox.Items.Add("Criticality");
metricsComboBox.Items.Add("Effectiveness");
graphTypeComboBox.Items.Clear();
graphTypeComboBox.Items.Add("Line Graph");
graphTypeComboBox.Items.Add("Bar Graph");
break;
}
}
public static void AddState(FlatBufferBuilder builder, TrackingState state)
{
builder.AddInt(1, (int)state, 0);
}
Ellipse MakeEllipseForJoint(
JointType jointType,
TrackingState trackingState,
Brush brush,
Point position2d)
{
int width = jointType == JointType.Head ? HEAD_WIDTH : REGULAR_WIDTH;
Ellipse ellipse = new Ellipse()
{
Width = width,
Height = width,
Fill = trackingState == TrackingState.Inferred ? InferredBrush : brush
};
Canvas.SetLeft(ellipse, position2d.X - (width / 2));
Canvas.SetTop(ellipse, position2d.Y - (width / 2));
return (ellipse);
}
void tracking()
{
WinSys.GetWindowRect(windowHandle, ref followedWindowSize);
WinSys.GetWindowPlacement( windowHandle, ref windowInformation);
// if the window has been maximized
if ( (windowInformation.flags & WinSys.SW_SHOWMAXIMIZED) != 0
|| (windowInformation.flags & WinSys.SW_MAXIMIZE) != 0)
{
currentState = TrackingState.WaitingMaximization;
windowFollowTimer.Interval = fastTimerInterval;
}
else
{
if ( WinSys.RECT.Diff( oldPos, followedWindowSize ) > 0 )
{
#if LOGGING
logEvent( "% Moved < " + followedWindowSize.Left.ToString()
+ ", " + followedWindowSize.Top.ToString()
+ ", " + (followedWindowSize.Right - followedWindowSize.Left).ToString()
+ ", " + (followedWindowSize.Bottom - followedWindowSize.Top).ToString()
+ " >" );
#endif
Left = Math.Max( followedWindowSize.Left - Width, 0 );
Top = followedWindowSize.Top;
Height = followedWindowSize.Bottom - followedWindowSize.Top;
oldPos = followedWindowSize;
// here we handle the speedup to follow the window
// to obtain a smoother move
lastWindowMove = 0;
if (windowFollowTimer.Interval != fastTimerInterval)
windowFollowTimer.Interval = fastTimerInterval;
}
else if (windowFollowTimer.Interval.Milliseconds == fastTimerInterval.Milliseconds)
{
// when the window don't move anymore, we hope to bring
// back the old slow timer.
lastWindowMove += fastTimerInterval.Milliseconds;
if (lastWindowMove > maxWaitDelay)
windowFollowTimer.Interval = windowFollowDelay;
}
WinSys.GetWindowRect(thisHandle, ref thisWindowSize );
WinSys.SetWindowPos( thisHandle
, windowHandle
, thisWindowSize.Left
, thisWindowSize.Top
, thisWindowSize.Right - thisWindowSize.Left
, thisWindowSize.Bottom - thisWindowSize.Top
, 0);
}
}
public void Update()
{
if (!activated)
{
return;
}
if (currentTarget)
{
// Check if lost target / new target
currentTarget = GetTarget();
if (!currentTarget)
{
trackingState = TrackingState.TrackingRight;
trackingTimer = 0f;
}
}
else
{
if (trackingState == TrackingState.TrackingTarget)
{
trackingState = TrackingState.TrackingRight;
}
// Check if acquired target
currentTarget = GetTarget();
if (currentTarget)
{
trackingState = TrackingState.TrackingTarget;
firingTimer = reloadTime;
AudioSource3D.PlayClipAtPoint(targetAcquiredSound, transform.position);
}
}
switch (trackingState)
{
case TrackingState.TrackingTarget:
TrackTarget();
break;
case TrackingState.TrackingRight:
{
trackingTimer += Time.deltaTime;
Quaternion rightRotation = Quaternion.FromToRotation(Vector3.up, rightLimit.position - gunPivot.position);
Quaternion leftRotation = Quaternion.FromToRotation(Vector3.up, leftLimit.position - gunPivot.position);
float leftAngle = leftRotation.eulerAngles.z;
float rightAngle = rightRotation.eulerAngles.z;
float parameter = Mathfx.Hermite(0, 1, trackingTimer / trackTime);
gunPivot.eulerAngles = new Vector3(0, 0, Mathf.LerpAngle(leftAngle, rightAngle, parameter));
if (trackingTimer > trackTime)
{
trackingState = TrackingState.TrackingLeft;
trackingTimer = 0f;
}
}
break;
case TrackingState.TrackingLeft:
{
trackingTimer += Time.deltaTime;
Quaternion rightRotation = Quaternion.FromToRotation(Vector3.up, rightLimit.position - gunPivot.position);
Quaternion leftRotation = Quaternion.FromToRotation(Vector3.up, leftLimit.position - gunPivot.position);
float leftAngle = leftRotation.eulerAngles.z;
float rightAngle = rightRotation.eulerAngles.z;
float parameter = Mathfx.Hermite(0, 1, trackingTimer / trackTime);
gunPivot.eulerAngles = new Vector3(0, 0, Mathf.LerpAngle(rightAngle, leftAngle, parameter));
if (trackingTimer > trackTime)
{
trackingState = TrackingState.TrackingRight;
trackingTimer = 0f;
}
}
break;
}
}
protected override async void OnToolMouseMove(MapViewMouseEventArgs e) {
//All of this logic is to avoid unnecessarily updating the graphic position
//for ~every~ mouse move. We skip any "intermediate" points in-between rapid
//mouse moves.
lock (_lock) {
if (_trackingMouseMove == TrackingState.NotTracking)
return;
else {
if (_workingLocation.HasValue) {
_lastLocation = e.ClientPoint;
return;
}
else {
_lastLocation = e.ClientPoint;
_workingLocation = e.ClientPoint;
}
}
_trackingMouseMove = TrackingState.Tracking;
}
//The code "inside" the QTR will execute for all points that
//get "buffered" or "queued". This avoids having to spin up a QTR
//for ~every~ point of ~every mouse move.
await QueuedTask.Run(() => {
var symReference = _pointSymbol.MakeSymbolReference();
while (true) {
System.Windows.Point? point;
Polyline lineFeature = null;
IDisposable graphic = null;
lock (_lock) {
point = _lastLocation;
_lastLocation = null;
_workingLocation = point;
if (point == null || !point.HasValue) {//No new points came in while we updated the overlay
_workingLocation = null;
break;
}
else if (_lineFeature == null || _graphic == null) {//conflict with the mouse down,
//If this happens then we are done. A new line and point will be
//forthcoming from the SketchCompleted callback
_trackingMouseMove = TrackingState.NotTracking;
break;
}
lineFeature = _lineFeature;
graphic = _graphic;
}
//update the graphic overlay
var nearest = GeometryEngine.NearestPoint(lineFeature, MapView.Active.ClientToMap(point.Value));
this.UpdateOverlay(graphic, nearest.Point, symReference);
}
});
}
public void Start()
{
firingState = FiringState.Reloading;
firingTimer = reloadTime;
trackingTimer = 0;
laserRenderer.enabled = false;
trackingState = TrackingState.TrackingRight;
targets = new List<GameObject>();
currentTarget = null;
}
protected override Task HandleMouseDownAsync(MapViewMouseButtonEventArgs e) {
//Select a line feature and place the initial graphic. Clear out any
//previously placed graphic
return QueuedTask.Run(() => {
var mapPoint = this.ActiveMapView.ClientToMap(e.ClientPoint);
var lineFeature = Module1.SelectLineFeature(mapPoint);
if (lineFeature != null) {
var nearest = GeometryEngine.NearestPoint(lineFeature, mapPoint);
lock (_lock) {
_workingLocation = null;
_lineFeature = lineFeature;
if (_graphic != null)
_graphic.Dispose();
_graphic = this.AddOverlay(nearest.Point, _pointSymbol.MakeSymbolReference());
_trackingMouseMove = TrackingState.CanTrack;
}
}
else {
lock (_lock) {
_workingLocation = null;
_lineFeature = null;
if (_graphic != null)
_graphic.Dispose();
_graphic = null;
_trackingMouseMove = TrackingState.NotTracking;
}
}
});
}
// Update is called once per frame
void Update()
{
if (! isTraining) {
return;
}
if(lastEngineState != currentEngineState)
{
currentEngineState = lastEngineState;
switch (currentEngineState) {
case TrackingState.Tracked:
break;
case TrackingState.Calibrating:
break;
case TrackingState.NotTracked:
OnLostTracking();
break;
default:
break;
}
}
textRepetition.text = count.ToString();
totalTime += Time.deltaTime;
int seconds = ((int)totalTime) % 60;
int minutes = ((int)totalTime) / 60;
string time = minutes + ":" + seconds;
textDuration.text = time;
}
/// <summary>
/// Constructs a body adapter from a serialized version
/// </summary>
/// <param name="body"></param>
public KinectBody(KGP.Serialization.Body.KinectBodyInternal body)
{
body.Validate(); //This will check preconditions to make sure we have a valid construct
this.clippedEdges = body.ClippedEdges;
this.handLeftConfidence = body.HandLeftConfidence;
this.handLeftState = body.HandLeftState;
this.handRightConfidence = body.HandRightConfidence;
this.handRightState = body.HandRightState;
this.isRestricted = body.IsRestricted;
this.isTracked = body.IsTracked;
Dictionary<JointType, JointOrientation> orientations = new Dictionary<JointType, JointOrientation>();
Dictionary<JointType, Joint> jointsDic = new Dictionary<JointType,Joint>();
for (int i = 0; i < body.Joints.Length;i++)
{
var joint = body.Joints[i];
orientations.Add(joint.JointType, body.JointOrientations[i]);
jointsDic.Add(joint.JointType, joint);
}
this.joints = jointsDic;
this.jointOrientations =orientations;
this.lean = body.Lean;
this.leanTrackingState = body.LeanTrackingState;
this.trackingId = body.TrackingId;
}
