コード例 #1
0
        private void SetRotation(VRTRIXBones bone, Quaternion rotation, bool valid, HANDTYPE type)
        {
            string     bone_name = VRTRIXUtilities.GetBoneName((int)bone);
            Quaternion qr        = new Quaternion(1f, 0f, 0f, 0f);

            GameObject obj = GameObject.Find(bone_name);

            //print(obj);
            if (obj != null)
            {
                if (!float.IsNaN(rotation.x) && !float.IsNaN(rotation.y) && !float.IsNaN(rotation.z) && !float.IsNaN(rotation.w))
                {
                    if (valid)
                    {
                        if (type == HANDTYPE.LEFT_HAND)
                        {
                            //obj.transform.rotation = (rotation * qr);
                            obj.transform.rotation = qloffset * (rotation * qr);
                            //print(obj.transform.rotation);
                        }
                        else if (type == HANDTYPE.RIGHT_HAND)
                        {
                            //obj.transform.rotation =  (rotation * qr);
                            obj.transform.rotation = qroffset * (rotation * qr);
                        }
                    }
                }
            }
        }
コード例 #2
0
        //手腕关节位置赋值函数,通过手腕外加的定位物体位置计算手部关节位置。(如果模型为全身骨骼,无需使用该函数)
        private void SetPosition(VRTRIXBones bone, Vector3 pos, Quaternion rot, Vector3 offset)
        {
            Transform obj = fingerTransformArray[(int)bone];

            if (obj != null)
            {
                obj.position = pos + rot * offset;
            }
        }
コード例 #3
0
        private void SetPosition(VRTRIXBones bone, Vector3 pos, Quaternion rot, Vector3 offset)
        {
            string     bone_name = VRTRIXUtilities.GetBoneName((int)bone);
            GameObject obj       = GameObject.Find(bone_name);

            if (obj != null)
            {
                obj.transform.position = pos + rot * offset;
            }
        }
コード例 #4
0
    private void SetPosition(VRTRIXBones bone, Vector3 pos, Quaternion rot, Vector3 offset)
    {
        string    bone_name = VRTRIXUtilities.GetBoneName((int)bone);
        Transform t         = FindNode(bone_name);

        if (t != null)
        {
            t.position = pos + rot * offset;
        }
    }
コード例 #5
0
        //获取磁场校准水平,值越小代表效果越好
        //! Get current calibration score for specific IMU sensor

        /*!
         * \param bone specific joint of hand.
         * \return current calibration score for specific IMU sensor. Lower value of score means better calibration performance.
         */
        public int GetCalScore(VRTRIXBones bone)
        {
            if ((int)bone < 16)
            {
                return(RH.GetReceivedCalScore(bone));
            }
            else
            {
                return(LH.GetReceivedCalScore(bone));
            }
        }
コード例 #6
0
 public Quaternion GetReceivedRotation(VRTRIXBones bone)
 {
     if ((int)bone < (int)VRTRIXBones.L_Hand)
     {
         return(data[(int)bone]);
     }
     else if ((int)bone < (int)VRTRIXBones.R_Arm)
     {
         return(data[(int)bone - 16]);
     }
     else
     {
         return(Quaternion.identity);
     }
 }
コード例 #7
0
        public float GetReceivedGestureAngle(VRTRIXBones bone)
        {
            Quaternion fingerOffest = Quaternion.identity;

            if (bone == VRTRIXBones.L_Thumb_2)
            {
                fingerOffest = new Quaternion(0.49673f, 0.409576f, 0.286788f, 0.709406f); //(sin(70/2), 0, 0, cos(70/2))*(0, sin(60/2), 0, cos(60/2))
            }
            else if (bone == VRTRIXBones.R_Thumb_2)
            {
                fingerOffest = new Quaternion(-0.49673f, -0.409576f, 0.286788f, 0.709406f); //(sin(-70/2), 0, 0, cos(-70/2))*(0, sin(-60/2), 0, cos(-60/2))
            }
            return(((int)bone < 16) ? (Quaternion.Inverse(data[(int)bone]) * (data[(int)VRTRIXBones.R_Hand] * fingerOffest)).eulerAngles.z :
                   (Quaternion.Inverse(data[(int)bone - 16]) * (data[(int)VRTRIXBones.L_Hand - 16] * fingerOffest)).eulerAngles.z);
        }
コード例 #8
0
    private void SetRotation(VRTRIXBones bone, Quaternion rotation, bool valid)
    {
        string bone_name = VRTRIXUtilities.GetBoneName((int)bone);

        Transform t = FindNode(bone_name);

        if (t != null)
        {
            if (!float.IsNaN(rotation.x) && !float.IsNaN(rotation.y) && !float.IsNaN(rotation.z) && !float.IsNaN(rotation.w))
            {
                if (valid)
                {
                    t.rotation = CalculateDynamicOffset() * (rotation * Quaternion.Euler(modelOffset));
                }
            }
        }
    }
コード例 #9
0
        //! Set thumb offset to counteract the difference between hands & gloves sensor installation.

        /*!
         * \param offset Offset vector to set.
         * \param joint the specific thumb joint to set.
         */
        public void SetThumbOffset(Vector3 offset, VRTRIXBones joint)
        {
            switch (joint)
            {
            case (VRTRIXBones.R_Thumb_1): SetProximalThumbOffset(sp, offset.x, offset.y, offset.z); break;

            case (VRTRIXBones.R_Thumb_2): SetIntermediateThumbOffset(sp, offset.x, offset.y, offset.z); break;

            case (VRTRIXBones.R_Thumb_3): SetDistalThumbOffset(sp, offset.x, offset.y, offset.z); break;

            case (VRTRIXBones.L_Thumb_1): SetProximalThumbOffset(sp, offset.x, offset.y, offset.z); break;

            case (VRTRIXBones.L_Thumb_2): SetIntermediateThumbOffset(sp, offset.x, offset.y, offset.z); break;

            case (VRTRIXBones.L_Thumb_3): SetDistalThumbOffset(sp, offset.x, offset.y, offset.z); break;
            }
        }
コード例 #10
0
        public int GetReceivedCalScore(VRTRIXBones bone)
        {
            switch (bone)
            {
            case VRTRIXBones.R_Index_2:
                return(calscore[3]);

            case VRTRIXBones.R_Middle_2:
                return(calscore[2]);

            case VRTRIXBones.R_Ring_2:
                return(calscore[1]);

            case VRTRIXBones.R_Pinky_2:
                return(calscore[0]);

            case VRTRIXBones.R_Thumb_2:
                return(calscore[4]);

            case VRTRIXBones.R_Hand:
                return(calscore[5]);

            case VRTRIXBones.L_Index_2:
                return(calscore[3]);

            case VRTRIXBones.L_Middle_2:
                return(calscore[2]);

            case VRTRIXBones.L_Ring_2:
                return(calscore[1]);

            case VRTRIXBones.L_Pinky_2:
                return(calscore[0]);

            case VRTRIXBones.L_Thumb_2:
                return(calscore[4]);

            case VRTRIXBones.L_Hand:
                return(calscore[5]);

            default:
                return(0);
            }
        }
コード例 #11
0
        //手部关节旋转赋值函数,每一帧都会调用,通过从数据手套硬件获取当前姿态,进一步进行处理,然后给模型赋值。
        private void SetRotation(VRTRIXBones bone, Quaternion rotation, HANDTYPE type)
        {
            Transform obj = fingerTransformArray[(int)bone];

            if (obj != null)
            {
                if (!float.IsNaN(rotation.x) && !float.IsNaN(rotation.y) && !float.IsNaN(rotation.z) && !float.IsNaN(rotation.w))
                {
                    if (type == HANDTYPE.LEFT_HAND)
                    {
                        Vector3 quat_vec = ml_axisoffset.MultiplyVector(new Vector3(rotation.x, rotation.y, rotation.z));
                        rotation = new Quaternion(quat_vec.x, quat_vec.y, quat_vec.z, rotation.w);
                        if (IsVREnabled)
                        {
                            //当VR环境下,根据固定在手腕上tracker的方向对齐手背方向。
                            obj.rotation = (bone == VRTRIXBones.L_Hand) ? CalculateDynamicOffset(LH_tracker, LH, HANDTYPE.LEFT_HAND) * rotation :
                                           CalculateDynamicOffset(LH_tracker, LH, HANDTYPE.LEFT_HAND) * rotation * Quaternion.Euler(ql_modeloffset);
                        }
                        else
                        {
                            //当3D环境下,根据相机视角方向对齐手背方向。
                            obj.rotation = (bone == VRTRIXBones.L_Hand) ? qloffset * rotation :
                                           qloffset *rotation *Quaternion.Euler(ql_modeloffset);
                        }
                    }
                    else if (type == HANDTYPE.RIGHT_HAND)
                    {
                        Vector3 quat_vec = mr_axisoffset.MultiplyVector(new Vector3(rotation.x, rotation.y, rotation.z));
                        rotation = new Quaternion(quat_vec.x, quat_vec.y, quat_vec.z, rotation.w);
                        if (IsVREnabled)
                        {
                            obj.rotation = (bone == VRTRIXBones.R_Hand) ? CalculateDynamicOffset(RH_tracker, RH, HANDTYPE.RIGHT_HAND) * rotation :
                                           CalculateDynamicOffset(RH_tracker, RH, HANDTYPE.RIGHT_HAND) * rotation * Quaternion.Euler(qr_modeloffset);
                        }
                        else
                        {
                            obj.rotation = (bone == VRTRIXBones.R_Hand) ? qroffset * rotation :
                                           qroffset *rotation *Quaternion.Euler(qr_modeloffset);
                        }
                    }
                }
            }
        }
コード例 #12
0
        public bool DataValidStatus(VRTRIXBones bone)
        {
            switch (bone)
            {
            case VRTRIXBones.R_Index_1:
                return(valid[3]);

            case VRTRIXBones.R_Middle_1:
                return(valid[2]);

            case VRTRIXBones.R_Ring_1:
                return(valid[1]);

            case VRTRIXBones.R_Pinky_1:
                return(valid[0]);

            case VRTRIXBones.R_Thumb_1:
                return(valid[4]);


            case VRTRIXBones.L_Index_1:
                return(valid[3]);

            case VRTRIXBones.L_Middle_1:
                return(valid[2]);

            case VRTRIXBones.L_Ring_1:
                return(valid[1]);

            case VRTRIXBones.L_Pinky_1:
                return(valid[0]);

            case VRTRIXBones.L_Thumb_1:
                return(valid[4]);

            default:
                return(true);
            }
        }
コード例 #13
0
        public float GetReceivedGestureAngle(VRTRIXBones bone)
        {
            switch (bone)
            {
            case VRTRIXBones.R_Index_2:
                return((Quaternion.Inverse(data[3]) * data[5]).eulerAngles.z);

            case VRTRIXBones.R_Middle_2:
                return((Quaternion.Inverse(data[2]) * data[5]).eulerAngles.z);

            case VRTRIXBones.R_Ring_2:
                return((Quaternion.Inverse(data[1]) * data[5]).eulerAngles.z);

            case VRTRIXBones.R_Pinky_2:
                return((Quaternion.Inverse(data[0]) * data[5]).eulerAngles.z);

            case VRTRIXBones.R_Thumb_2:
                return((Quaternion.Inverse(data[4]) * (data[5] * R_thumb_offset)).eulerAngles.z);

            case VRTRIXBones.L_Index_2:
                return((Quaternion.Inverse(data[3]) * data[5]).eulerAngles.z);

            case VRTRIXBones.L_Middle_2:
                return((Quaternion.Inverse(data[2]) * data[5]).eulerAngles.z);

            case VRTRIXBones.L_Ring_2:
                return((Quaternion.Inverse(data[1]) * data[5]).eulerAngles.z);

            case VRTRIXBones.L_Pinky_2:
                return((Quaternion.Inverse(data[0]) * data[5]).eulerAngles.z);

            case VRTRIXBones.L_Thumb_2:
                return((Quaternion.Inverse(data[4]) * (data[5] * L_thumb_offset)).eulerAngles.z);


            default:
                return(0f);
            }
        }
コード例 #14
0
        //! Get current rotation of specific joint

        /*!
         * \param bone specific joint of hand.
         * \return current rotation of specific joint.
         */
        public Quaternion GetRotation(VRTRIXBones bone)
        {
            return(fingerTransformArray[(int)bone].rotation);
        }
コード例 #15
0
        public Quaternion GetReceivedRotation(VRTRIXBones bone)
        {
            //UnityEngine.Debug.Log((Quaternion.Inverse(data[5]) * data[3]).eulerAngles.y);
            switch (bone)
            {
            case VRTRIXBones.R_Forearm:
                return(data[5]);

            case VRTRIXBones.R_Hand:
                return(data[5]);

            case VRTRIXBones.R_Index_2:
                return(data[3]);

            case VRTRIXBones.R_Middle_2:
                return(data[2]);

            case VRTRIXBones.R_Ring_2:
                return(data[1]);

            case VRTRIXBones.R_Pinky_2:
                return(data[0]);

            case VRTRIXBones.R_Thumb_2:
                return(data[15]);

            case VRTRIXBones.R_Index_1:
                return(data[9]);

            case VRTRIXBones.R_Middle_1:
                return(data[8]);

            case VRTRIXBones.R_Ring_1:
                return(data[7]);

            case VRTRIXBones.R_Pinky_1:
                return(data[6]);

            case VRTRIXBones.R_Thumb_1:
                return(data[10]);

            case VRTRIXBones.R_Index_3:
                return(data[14]);

            case VRTRIXBones.R_Middle_3:
                return(data[13]);

            case VRTRIXBones.R_Ring_3:
                return(data[12]);

            case VRTRIXBones.R_Pinky_3:
                return(data[11]);

            case VRTRIXBones.R_Thumb_3:
                return(data[4]);



            case VRTRIXBones.L_Forearm:
                return(data[5]);

            case VRTRIXBones.L_Hand:
                return(data[5]);

            case VRTRIXBones.L_Index_2:
                return(data[3]);

            case VRTRIXBones.L_Middle_2:
                return(data[2]);

            case VRTRIXBones.L_Ring_2:
                return(data[1]);

            case VRTRIXBones.L_Pinky_2:
                return(data[0]);

            case VRTRIXBones.L_Thumb_2:
                return(data[15]);

            case VRTRIXBones.L_Index_1:
                return(data[9]);

            case VRTRIXBones.L_Middle_1:
                return(data[8]);

            case VRTRIXBones.L_Ring_1:
                return(data[7]);

            case VRTRIXBones.L_Pinky_1:
                return(data[6]);

            case VRTRIXBones.L_Thumb_1:
                return(data[10]);

            case VRTRIXBones.L_Index_3:
                return(data[14]);

            case VRTRIXBones.L_Middle_3:
                return(data[13]);

            case VRTRIXBones.L_Ring_3:
                return(data[12]);

            case VRTRIXBones.L_Pinky_3:
                return(data[11]);

            case VRTRIXBones.L_Thumb_3:
                return(data[4]);


            default:
                return(Quaternion.identity);
            }
        }