private void UpdateARObjectTransform(Mat rvec, Mat tvec, int id) { // Find the object of this id if (idDict.ContainsKey(id)) { arGameObject = GameObject.Find(idDict[id]); } // Convert to unity pose data. double[] rvecArr = new double[3]; rvec.get(0, 0, rvecArr); double[] tvecArr = new double[3]; tvec.get(0, 0, tvecArr); PoseData poseData = ARUtils.ConvertRvecTvecToPoseData(rvecArr, tvecArr); // Changes in pos/rot below these thresholds are ignored. if (enableLowPassFilter) { ARUtils.LowpassPoseData(ref oldPoseData, ref poseData, positionLowPass, rotationLowPass); } oldPoseData = poseData; // Convert to transform matrix. ARM = ARUtils.ConvertPoseDataToMatrix(ref poseData, true, true); ARM = arCamera.transform.localToWorldMatrix * ARM; ARUtils.SetTransformFromMatrix(arGameObject.transform, ref ARM); //Only move and do not rotate Vector3 rawRotation = arGameObject.transform.rotation.eulerAngles; arGameObject.transform.rotation = Quaternion.Euler(new Vector3(0, adjustRotation(rawRotation[1]), 0)); }
public void AddToPoseList(ref PoseData a_newPose) { if (PoseList == null) PoseList = new List<PoseData>(); PoseList.Add(a_newPose); }
public override bool Run() { bool result = true; Actor.OverlayComponent.UpdateInteractionFreeParts(AwarenessLevel.OverlayNone); Actor.LookAtManager.DisableLookAts(); for (int i = 0; i < shots; i++) { if (Actor.HasExitReason(ExitReason.UserCanceled)) { result = false; break; } PoseData poseData = GetRandomPose(); if (poseData == null) { result = false; break; } PoseManager.SetCurrentPose(Actor, poseData.Key); Target.PlaySoloAnimation(this.Actor.SimDescription.IsHuman, this.Actor, poseData.Key, true, ProductVersion.BaseGame); Actor.ResetAllAnimation(); Target.PlaySoloAnimation(this.Actor.SimDescription.IsHuman, this.Actor, poseData.Key, true, ProductVersion.BaseGame); Actor.ResetAllAnimation(); bool userCanceled = Actor.WaitForExitReason(simMinutesToPose, ExitReason.UserCanceled); if (userCanceled) { result = false; break; } } Actor.LookAtManager.EnableLookAts(); return(result); }
public override void DrawFrame(SceneGame scene, Vector2 pos, PoseData poseData, Facing facing, Matrix transform, Color color, ColorMatrix colorMatrix) { var mirror = Microsoft.Xna.Framework.Graphics.SpriteEffects.None; int frameOffset = 0; switch (poseData.Pose) { case (CreaturePose.Stand): frameOffset = (int)Math.Round(poseData.Frame * AnimationSpeedStand); break; case (CreaturePose.Walk): frameOffset = (int)Math.Round(poseData.Frame * AnimationSpeedWalk); break; case (CreaturePose.Attack): frameOffset = (int)Math.Round(poseData.Frame * AnimationSpeedAttack); break; case (CreaturePose.Cast): frameOffset = (int)Math.Round(poseData.Frame * AnimationSpeedCast); break; } scene.PushSpriteBatch(shader: scene.Shader, shaderSetup: (matrix, projection) => { scene.SetupColorMatrix(Color * colorMatrix, transform * matrix, projection); }); scene.DrawSprite(Sprite, frameOffset, pos, mirror, color, 0); scene.PopSpriteBatch(); }
public void SetPose(CreatureRender render, Facing facing, PoseData poseData, Vector2 origin) { Render = render; Facing = facing; PoseData = poseData; Origin = origin; }
public void Play() { currentPose = SelectedPoses[0]; SetupWinScreen(); SetupCurrentPose(); PoseImage.gameObject.SetActive(true); }
public void RegisterConfig(JointDeltaConfig config) { bool containsKeyAlready = _requestors.ContainsKey(config.InstanceID); Assert.IsFalse(containsKeyAlready, "Trying to register multiple configs with the same id into " + "JointDeltaProvider."); _requestors.Add(config.InstanceID, new List <HandJointId>(config.JointIDs)); // Check if any new joints added, if so then add to cache foreach (var joint in config.JointIDs) { if (!_poseDataCache.ContainsKey(joint)) { _poseDataCache.Add(joint, new PoseData[2] { new PoseData(), new PoseData() }); // New joint tracked, so write current data PoseData toWrite = _poseDataCache[joint][CurDataIndex]; toWrite.IsValid = Hand.GetJointPose(joint, out toWrite.Pose); } } }
private void UpdateData() { if (Hand.CurrentDataVersion <= _lastUpdateDataVersion) { return; } _lastUpdateDataVersion = Hand.CurrentDataVersion; // Swap read and write indices each data version CurDataIndex = 1 - CurDataIndex; // Only fetch pose data for currently tracked joints _trackedJoints.Clear(); foreach (var key in _requestors.Keys) { IList <HandJointId> joints = _requestors[key]; _trackedJoints.UnionWithNonAlloc(joints); } // Fetch pose data for tracked joints, and // invalidate data for untracked joints foreach (var joint in _poseDataCache.Keys) { PoseData toWrite = _poseDataCache[joint][CurDataIndex]; toWrite.IsValid = _trackedJoints.Contains(joint) && Hand.GetJointPose(joint, out toWrite.Pose); } }
virtual protected void onDetectionRun() { //Add/remove quads to match how many we saw if (quadInstances.Count > ArucoTracking.marker_count) { //Clear out any instances we don't need anymore for (int i = quadInstances.Count - 1; i >= ArucoTracking.marker_count; i--) { GameObject.Destroy(quadInstances[i]); quadInstances.RemoveAt(i); } } else if (ArucoTracking.marker_count > quadInstances.Count) { int to_add = ArucoTracking.marker_count - quadInstances.Count; for (int i = 0; i < to_add; i++) { quadInstances.Add(makeMarkerObject()); } } for (int i = 0; i < ArucoTracking.marker_count; i++) { PoseData pose = trackingRunner.poseDict[ArucoTracking.ids[i]]; quadInstances[i].transform.localPosition = pose.pos; quadInstances[i].transform.localRotation = pose.rot; } }
public override void DrawFrame(SceneGame scene, Vector2 pos, PoseData poseData, Facing facing, Matrix transform, Color color, ColorMatrix colorMatrix) { SpriteReference abyssalTendril = SpriteLoader.Instance.AddSprite("content/abyssal_tendril_bush"); var mirror = Microsoft.Xna.Framework.Graphics.SpriteEffects.None; bool tendrilDown = IsTendrilDown(poseData.Pose); bool tendrilDownLast = IsTendrilDown(poseData.PoseLast); int frameOffset = 0; switch (poseData.Pose) { case (CreaturePose.Attack): frameOffset = 3 + (poseData.PoseFrame / 2) % 4; break; case (CreaturePose.Cast): frameOffset = 3 + (poseData.PoseFrame / 4) % 4; break; } if (tendrilDown != tendrilDownLast && poseData.PoseFrame < 15) { frameOffset = 1 + (poseData.PoseFrame / 10) % 2; } scene.PushSpriteBatch(shader: scene.Shader, shaderSetup: (matrix, projection) => { scene.SetupColorMatrix(Color * colorMatrix, transform * matrix, projection); }); scene.DrawSprite(abyssalTendril, frameOffset, pos - new Vector2(0, 16), mirror, color, 0); scene.PopSpriteBatch(); }
private void UpdateARObjectTransform_2(Mat rvec, Mat tvec) { // Convert to unity pose data. double[] rvecArr = new double[3]; rvec.get(0, 0, rvecArr); double[] tvecArr = new double[3]; tvec.get(0, 0, tvecArr); PoseData poseData = ARUtils.ConvertRvecTvecToPoseData(rvecArr, tvecArr); // Changes in pos/rot below these thresholds are ignored. if (enableLowPassFilter) { ARUtils.LowpassPoseData(ref oldPoseData, ref poseData, positionLowPass, rotationLowPass); } oldPoseData = poseData; // Convert to transform matrix. ARM = ARUtils.ConvertPoseDataToMatrix(ref poseData, true, true); //if (shouldMoveARCamera) { // ARM = arGameObject.transform.localToWorldMatrix * ARM.inverse; // ARUtils.SetTransformFromMatrix(arCamera.transform, ref ARM); //} else { ARM = arCamera.transform.localToWorldMatrix * ARM; ARUtils.SetTransformFromMatrix(arGameObject.transform, ref ARM); //} }
public PoseDiff CompareWithController(ControllerInput controller, float progress) { int firstPhase = (int)Mathf.Floor(progress / phaseLength); int secondPhase = firstPhase + 1; if (data.count == 1) { secondPhase = 0; } PoseData firstPose = data.poses [firstPhase]; PoseData secondPose = data.poses [secondPhase]; PoseData desiredPose = new PoseData(); float subProgress = progress % phaseLength; subProgress /= phaseLength; //normalize it; desiredPose.leftWing = firstPose.leftWing + (secondPose.leftWing - firstPose.leftWing) * subProgress; desiredPose.rightWing = firstPose.rightWing + (secondPose.rightWing - firstPose.rightWing) * subProgress; desiredPose.head.x = firstPose.head.x + (secondPose.head.x - firstPose.head.x) * subProgress; desiredPose.head.y = firstPose.head.y + (secondPose.head.y - firstPose.head.y) * subProgress; desiredPose.tail.x = firstPose.tail.x + (secondPose.tail.x - firstPose.tail.x) * subProgress; desiredPose.tail.y = firstPose.tail.y + (secondPose.tail.y - firstPose.tail.y) * subProgress; PoseData controllerPose = CalculateFromController(controller); return(CalculatePoseDiffs(desiredPose, controllerPose)); }
private void onDetectionRun() { if (trackingRunner.poseDict.ContainsKey(markerId)) { if (!persist) { gameObject.SetActive(true); } PoseData pose = trackingRunner.poseDict[markerId]; if (parentCamera == null) { gameObject.transform.localPosition = pose.pos; } else { Vector3 posePos = pose.pos; posePos.z = -posePos.z; gameObject.transform.position = parentCamera.cameraToWorldMatrix.MultiplyPoint(posePos); } gameObject.transform.localRotation = pose.rot * baseRotation; } else { if (!persist) { gameObject.SetActive(false); } } }
public static Dictionary <int, PoseData> createUnityPoseData(int marker_count, int[] ids, double[] rvecs, double[] tvecs) { Dictionary <int, PoseData> out_dict = new Dictionary <int, PoseData>(); if (marker_count == 0) { return(out_dict); } Vector3 rvec = new Vector3(); for (int i = 0; i < marker_count; i++) { PoseData data = new PoseData(); data.pos.Set((float)tvecs[i * 3], (float)tvecs[i * 3 + 1], (float)tvecs[i * 3 + 2]); rvec.Set((float)rvecs[i * 3], (float)rvecs[i * 3 + 1], (float)rvecs[i * 3 + 2]); float theta = rvec.magnitude; rvec.Normalize(); //the rvec from OpenCV is a compact axis-angle format. The direction of the vector is the axis, and the length of it is the angle to rotate about (i.e. theta) //From this stackoverflow answer: http://stackoverflow.com/questions/12933284/rodrigues-into-eulerangles-and-vice-versa data.rot = Quaternion.AngleAxis(theta * Mathf.Rad2Deg, rvec); out_dict[ids[i]] = data; } return(out_dict); }
public PoseDiff CompareWithController(ControllerInput controller, float progress) { int firstPhase = (int)Mathf.Floor(progress/phaseLength); int secondPhase = firstPhase + 1; if (data.count == 1) { secondPhase = 0; } PoseData firstPose = data.poses [firstPhase]; PoseData secondPose = data.poses [secondPhase]; PoseData desiredPose = new PoseData(); float subProgress = progress % phaseLength; subProgress /= phaseLength; //normalize it; desiredPose.leftWing = firstPose.leftWing + (secondPose.leftWing - firstPose.leftWing) * subProgress; desiredPose.rightWing = firstPose.rightWing + (secondPose.rightWing - firstPose.rightWing) * subProgress; desiredPose.head.x = firstPose.head.x + (secondPose.head.x - firstPose.head.x) * subProgress; desiredPose.head.y = firstPose.head.y + (secondPose.head.y - firstPose.head.y) * subProgress; desiredPose.tail.x = firstPose.tail.x + (secondPose.tail.x - firstPose.tail.x) * subProgress; desiredPose.tail.y = firstPose.tail.y + (secondPose.tail.y - firstPose.tail.y) * subProgress; PoseData controllerPose = CalculateFromController(controller); return CalculatePoseDiffs (desiredPose, controllerPose); }
protected static int GetFrameOffset(PoseData poseData) { int frameOffset = 0; switch (poseData.Pose) { case (CreaturePose.Stand): frameOffset = 1; break; case (CreaturePose.Walk): double lerp = LerpHelper.ForwardReverse(0, 2, (poseData.Frame / 50.0) % 1); frameOffset = (int)Math.Round(lerp); break; case (CreaturePose.Attack): frameOffset = 3; break; case (CreaturePose.Cast): frameOffset = 4; break; } return(frameOffset); }
public override void DrawFrame(SceneGame scene, Vector2 pos, PoseData poseData, Facing facing, Matrix transform, Color color, ColorMatrix colorMatrix) { var mirror = Microsoft.Xna.Framework.Graphics.SpriteEffects.None; int facingOffset = 0; switch (facing) { case (Facing.North): facingOffset = 2; break; case (Facing.East): facingOffset = 1; mirror = Microsoft.Xna.Framework.Graphics.SpriteEffects.FlipHorizontally; break; case (Facing.South): facingOffset = 0; break; case (Facing.West): facingOffset = 1; break; } scene.PushSpriteBatch(shader: scene.Shader, shaderSetup: (matrix, projection) => { scene.SetupColorMatrix(Color * colorMatrix, transform * matrix, projection); }); scene.DrawSprite(Sprite, facingOffset, pos, mirror, color, 0); scene.PopSpriteBatch(); }
public static bool CreateVirtualVehicleAtOrigin(this IFleetManagerClient fleetManager, IPAddress ipAddress) { PoseData pose = new PoseData() { X = 0, Y = 0, Heading = 0 }; return(fleetManager.CreateVirtualVehicle(ipAddress, pose)); }
/// <summary> /// Get the previous frame's pose /// </summary> /// <param name="joint">The joint for which to retrieve data</param> /// <param name="pose">The previous pose</param> /// <returns>True if data available</returns> public bool GetPrevJointPose(HandJointId joint, out Pose pose) { UpdateData(); PoseData poseData = _poseDataCache[joint][PrevDataIndex]; pose = poseData.Pose; return(poseData.IsValid); }
public override bool Run() { PoseData poseData = PoseData.SelectPoseFromList(); if (poseData == null) { return(false); } return(PoseManager.Pose(Actor, Target, poseData.Key)); }
//public void ReceiveRigData(Vector3 playerPos, RigData _rigData) //{ // transform.position = playerPos; // rigData = _rigData; //} public void SetTransformToPose(Transform target, PoseData pose) { if (pose.IsNull()) { return; } target.localPosition = pose.GetPosition(); target.localRotation = pose.GetRotation(); }
public PoseData GetRandomPose() { PoseData pose = null; int count = PoseData.sData.Count; if (count > 0) { pose = RandomUtil.GetRandomObjectFromList <PoseData>(PoseList); } return(pose); }
private void GeneratePoses() { var data = Pose.GeneratePoses(); for (int i = 0; i < data.Count; i++) { PoseData.Add(new Pose { Name = data[i].Name, Comment = data[i].Comment, Position = data[i].Position, Score = data[i].Score }); } }
//Applies the given offset to the positions of all markers in the dictionary, in the coordinate space of the markers (i.e. camera space) //Modifies the dictionary values directly public static void addCamSpaceOffset(Dictionary <int, PoseData> dict, Vector3 offset) { List <int> keys = new List <int>(dict.Keys); foreach (int key in keys) { PoseData data = dict[key]; data.pos += offset; dict[key] = data; } }
public static PoseData getPoseData() { PoseData pd = new PoseData(); CubemanController cm = GameObject.Find("Cubeman").GetComponent <CubemanController>(); GameObject[] bones = cm.GetBones(); for (int i = 0; i < 20; i++) { pd.bonePos[i] = bones[i].transform.position; pd.bonePos[i] = bones[i].transform.localEulerAngles; } return(pd); }
public static PoseDiff CalculatePoseDiffs(PoseData a, PoseData b) { PoseDiff result = new PoseDiff(); result = CalculateDiffs(a.leftWing, b.leftWing, result); result = CalculateDiffs(a.rightWing, b.rightWing, result); //result = CalculateDiffs (a.head.x, b.head.x, result); //result = CalculateDiffs (a.head.y, b.head.y, result); //result = CalculateDiffs (a.tail.x, b.tail.x, result); //result = CalculateDiffs (a.tail.y, b.tail.y, result); return(result); }
public static PoseData CalculateFromController(ControllerInput controller) { PoseData result = new PoseData(); result.leftWing = controller.GetAxis(ControllerAction.L2); result.rightWing = controller.GetAxis(ControllerAction.R2); result.head.x = controller.GetAxis(ControllerAction.LEFT_STICK_X); result.head.y = controller.GetAxis(ControllerAction.LEFT_STICK_Y); result.tail.x = controller.GetAxis(ControllerAction.RIGHT_STICK_X); result.tail.y = controller.GetAxis(ControllerAction.RIGHT_STICK_Y); return(result); }
public RigData(PoseData _head) { quality = 1; Head = _head; Left = PoseData.empty; Right = PoseData.empty; LeftShoulder = PoseData.empty; RightShoulder = PoseData.empty; LeftElbow = PoseData.empty; RightElbow = PoseData.empty; }
public RigData(PoseData _head, PoseData _left, PoseData _right) { quality = 2; Head = _head; Left = _left; Right = _right; LeftShoulder = PoseData.empty; RightShoulder = PoseData.empty; LeftElbow = PoseData.empty; RightElbow = PoseData.empty; }
public override void DrawFrame(SceneGame scene, Vector2 pos, PoseData poseData, Facing facing, Matrix transform, Color color, ColorMatrix colorMatrix) { var mirror = GetMirror(facing); int facingOffset = GetFacingOffset(facing); int frameOffset = GetFrameOffset(poseData); scene.PushSpriteBatch(shader: scene.Shader, shaderSetup: (matrix, projection) => { scene.SetupColorMatrix(Color * colorMatrix, transform * matrix, projection); }); scene.DrawSprite(Sprite, facingOffset + frameOffset, pos, mirror, color, 0); scene.PopSpriteBatch(); }
private void DrawSceneGUI(SceneView sceneView) { if (gameObject != null && editedData != null) { if (selectedOption == 1) { DrawSelectedContactPoint(); DrawCalculatedContactPoints(); } if (_bDrawTrajectory) { Handles.color = Color.cyan; Handles.DrawWireCube(gameObject.transform.position, Vector3.one * 0.1f); Trajectory t = new Trajectory(editedData.trajectoryPointsTimes.Count); editedData.GetTrajectoryInTime(ref t, currentAnimaionTime); Handles.color = Color.green; t.TransformToWorldSpace(gameObject.transform); MM_Gizmos.DrawTrajectory_Handles( editedData.trajectoryPointsTimes.ToArray(), gameObject.transform.position, gameObject.transform.forward, t, 0.04f, 0.2f ); } if (_bDrawPose) { PoseData p = new PoseData(editedData[0].pose.Count); editedData.GetPoseInTime(ref p, currentAnimaionTime); p.TransformToWorldSpace(gameObject.transform); MM_Gizmos.DrawPose(p, Color.blue, Color.yellow); } if (selectedOption == 1) { float length = 200f; float height = 25f; Rect r = new Rect( sceneView.position.width / 2f - length / 2f, 30f, length, height ); DrawContactGizmosSelectRect(r); } } }
public static PoseDiff CalculatePoseDiffs(PoseData a, PoseData b) { PoseDiff result = new PoseDiff (); result = CalculateDiffs (a.leftWing, b.leftWing, result); result = CalculateDiffs (a.rightWing, b.rightWing, result); //result = CalculateDiffs (a.head.x, b.head.x, result); //result = CalculateDiffs (a.head.y, b.head.y, result); //result = CalculateDiffs (a.tail.x, b.tail.x, result); //result = CalculateDiffs (a.tail.y, b.tail.y, result); return result; }
public static PoseData CalculateFromController(ControllerInput controller) { PoseData result = new PoseData (); result.leftWing = controller.GetAxis (ControllerAction.L2); result.rightWing = controller.GetAxis (ControllerAction.R2); result.head.x = controller.GetAxis (ControllerAction.LEFT_STICK_X); result.head.y = controller.GetAxis (ControllerAction.LEFT_STICK_Y); result.tail.x = controller.GetAxis (ControllerAction.RIGHT_STICK_X); result.tail.y = controller.GetAxis (ControllerAction.RIGHT_STICK_Y); return result; }
private void PositionCamera(TrackableBehaviour trackableBehaviour, PoseData camToTargetPose) { camera.transform.localPosition = trackableBehaviour.transform.rotation * Quaternion.AngleAxis(90, Vector3.left) * Quaternion.Inverse(camToTargetPose.orientation) * (-camToTargetPose.position) + trackableBehaviour.transform.position; camera.transform.rotation = trackableBehaviour.transform.rotation * Quaternion.AngleAxis(90, Vector3.left) * Quaternion.Inverse(camToTargetPose.orientation); }
private void PositionTrackable(TrackableBehaviour trackableBehaviour, PoseData camToTargetPose) { trackableBehaviour.transform.position = camera.transform.TransformPoint(camToTargetPose.position); trackableBehaviour.transform.rotation = camera.transform.rotation * camToTargetPose.orientation * Quaternion.AngleAxis(270, Vector3.left); }