// Use this for initialization
        void Start()
        {
            gtEvent            = new GazeTouchEvent();
            whichKeyboard      = "Accuracy";
            isDynamicCascading = true;
            keyLayout          = new string[5];
            keyLayout[0]       = "●";
            keys = GameObject.FindGameObjectsWithTag("eye_key");

            Vector3 basicPosition = keys[0].transform.localPosition;

            keyWidth  = keys[0].transform.localScale.x;
            keyHeight = keys[0].transform.localScale.y;
            Text text;


            foreach (GameObject g in keys)
            {
                g.GetComponentInChildren <Text>().text = "●";
            }
            keys[0].GetComponent <accuracy_target>().key = 'a';
            Vector3 keyPosition = new Vector3(basicPosition.x, basicPosition.y, basicPosition.z);

            keys[0].transform.localPosition = keyPosition;
            keys[1].GetComponent <accuracy_target>().key = 'b';
            keyPosition = new Vector3(basicPosition.x + 0.055f * 9, basicPosition.y, basicPosition.z);
            keys[1].transform.localPosition = keyPosition;
            keys[2].GetComponent <accuracy_target>().key = 'c';
            keyPosition = new Vector3(basicPosition.x + 0.055f * 4.5f, basicPosition.y - 0.07f * 2, basicPosition.z);
            keys[2].transform.localPosition = keyPosition;
            keys[3].GetComponent <accuracy_target>().key = 'd';
            keyPosition = new Vector3(basicPosition.x, basicPosition.y - 0.07f * 4, basicPosition.z);
            keys[3].transform.localPosition = keyPosition;
            keys[4].GetComponent <accuracy_target>().key = 'e';
            keyPosition = new Vector3(basicPosition.x + 0.055f * 9, basicPosition.y - 0.07f * 4, basicPosition.z);
            keys[4].transform.localPosition = keyPosition;
            setBaseDwell(keys[0]);
            setBaseDwell(keys[1]);
            setBaseDwell(keys[2]);
            setBaseDwell(keys[3]);
            setBaseDwell(keys[4]);
            initExperiment();
            audio.Play();
        }
        // Use this for initialization
        void Start()
        {
            gtEvent            = new GazeTouchEvent();
            whichKeyboard      = "DC";
            isDynamicCascading = true;
            keyLayout          = new string[5];
            keyLayout[0]       = "qwertyuiop";
            keyLayout[1]       = "asdfghjkl";
            keyLayout[2]       = "zxcvbnm";
            keyLayout[3]       = "<>~";
            keyLayout[4]       = "+-$";
            keys = GameObject.FindGameObjectsWithTag("eye_key");
            int     keyID         = 0;
            int     keyRow        = 0;
            int     keyCol        = 0;
            Vector3 basicPosition = keys[0].transform.localPosition;
            Text    text;


            Text[] temp = gameObject.GetComponentsInChildren <Text>();
            foreach (Text t in temp)
            {
                if (t.tag.CompareTo("dwell") == 0)
                {
                    dwellInfo     = t;
                    baseDwell_int = getDwellTime();
                    updateDwell();
                    break;
                }
            }
            foreach (GameObject key in keys)
            {
                if (key != null)
                {
                    keyWidth  = key.transform.localScale.x;
                    keyHeight = key.transform.localScale.y;
                    keyGap    = keyWidth / 15;
                    //key.transform.localScale = new Vector3(keySize, keySize, keySize / 8);
                    Vector3 keyPosition = new Vector3(basicPosition.x, basicPosition.y, basicPosition.z);
                    keyPosition.x += (keyWidth + keyGap) * keyCol + keyWidth * keyRow / 2;
                    keyPosition.y -= (keyHeight + keyGap) * keyRow;
                    key.transform.localPosition = keyPosition;
                    text = key.GetComponentInChildren <Text>();

                    text.text = keyLayout[keyRow].Substring(keyCol, 1);
                    key.GetComponent <Eyekeyboard_eye_only>().key = text.text.ToCharArray()[0];
                    setBaseDwell(key);
                    if (text.text.CompareTo("~") == 0)
                    {
                        text.text = "Enter";

                        keyPosition.x += (keyWidth * spacebarScale * 1.5f + keyGap);
                        key.transform.localPosition = keyPosition;
                    }
                    else if (text.text.CompareTo("<") == 0)
                    {
                        Vector3 keyScale = new Vector3(key.transform.localScale.x * 2, key.transform.localScale.y, key.transform.localScale.z);
                        key.transform.localScale = keyScale;

                        key.transform.localPosition = keyPosition;
                        Vector3 scaleT = text.transform.localScale;
                        scaleT.x /= 2;
                        text.transform.localScale = scaleT;
                        text.text = "del";
                    }
                    else if (text.text.CompareTo(">") == 0)
                    {
                        Vector3 keyScale = new Vector3(key.transform.localScale.x * spacebarScale, key.transform.localScale.y, key.transform.localScale.z);
                        key.transform.localScale    = keyScale;
                        keyPosition.x               = basicPosition.x + (keyWidth * spacebarScale + keyGap) * keyCol * 1.5f;
                        key.transform.localPosition = keyPosition;
                        text.text = "Space";

                        Vector3 scaleT = text.transform.localScale;
                        scaleT.x /= (spacebarScale);
                        text.transform.localScale = scaleT;
                    }
                    else if (text.text.CompareTo("-") == 0)
                    {
                        Vector3 keyScale = new Vector3(key.transform.localScale.x * spacebarScale, key.transform.localScale.y, key.transform.localScale.z);
                        key.transform.localScale    = keyScale;
                        keyPosition.x               = basicPosition.x + keyWidth * 1.7f;
                        keyPosition.y               = dwellAdjuster_y;
                        key.transform.localPosition = keyPosition;
                        //text.text = "-50";
                    }

                    else if (text.text.CompareTo("+") == 0)
                    {
                        Vector3 keyScale = new Vector3(key.transform.localScale.x * spacebarScale, key.transform.localScale.y, key.transform.localScale.z);
                        key.transform.localScale    = keyScale;
                        keyPosition.x               = basicPosition.x + keyWidth * 4.8f;
                        keyPosition.y               = dwellAdjuster_y;
                        key.transform.localPosition = keyPosition;
                        //text.text = "";
                    }
                    else if (text.text.CompareTo("$") == 0)
                    {
                        Vector3 keyScale = new Vector3(key.transform.localScale.x * spacebarScale, key.transform.localScale.y, key.transform.localScale.z);
                        key.transform.localScale    = keyScale;
                        keyPosition.x               = basicPosition.x + keyWidth * 9.4f;
                        keyPosition.y               = dwellAdjuster_y;
                        key.transform.localPosition = keyPosition;
                        text.text = "Start";
                        text.transform.localScale = new Vector3(text.transform.localScale.x / spacebarScale, text.transform.localScale.y, text.transform.localScale.z);
                    }

                    text.transform.localScale = new Vector3(text.transform.localScale.x, text.transform.localScale.y * keyWidth / keyHeight, text.transform.localScale.z);
                    keyCol++;
                    if (keyCol == keyLayout[keyRow].Length)
                    {
                        keyCol = 0;
                        keyRow++;
                    }
                    keyID++;
                }
            }
            initExperiment();
            initCalib();
            foreach (GameObject g in markers)
            {
                g.SetActive(false);
            }
            foreach (GameObject g in keys)
            {
                g.SetActive(true);
            }
            keys[31].SetActive(false);
            keys[28].SetActive(true);
            audio.Play();
            if (startTrial > 0)
            {
                keyEntered(Key.Enter);
            }
            else
            {
                adjustDwellPhaseStart();
            }
        }
Ejemplo n.º 3
0
        // Use this for initialization
        void Start()
        {
            gtEvent       = new GazeTouchEvent();
            whichKeyboard = "SwipeZone";
            keyboards     = GameObject.FindGameObjectsWithTag("SwipeZone_keyboard");
            keysTemp      = new string[9];
            keysTemp[0]   = "qwe";
            keysTemp[1]   = "asd";
            keysTemp[2]   = "zxc";
            keysTemp[3]   = "rty";
            keysTemp[4]   = "fgh";
            keysTemp[5]   = "vbn";
            keysTemp[6]   = "uio";
            keysTemp[7]   = "jkp";
            keysTemp[8]   = "ml.";
            char[] temp;
            deactivater    = new Canvas[9, 4];
            keyboardHeight = keyboards[0].transform.localScale.y;
            keyboardWidth  = keyboards[0].transform.localScale.x;
            keyboardGap    = keyboardHeight / 15;
            Vector3 basicKeyboardPosition = keyboards[0].transform.localPosition;


            int sub = 0;

            foreach (string key in keysTemp)
            {
                temp         = key.ToCharArray();
                keys[sub, 0] = temp[0];
                keys[sub, 1] = temp[1];
                keys[sub, 2] = temp[2];
                sub++;
            }

            for (int i = 0; i < keyboards.Length; i++)
            {
                keyboards[i].transform.localPosition = new Vector3(basicKeyboardPosition.x + (i / 3) * (keyboardWidth + keyboardGap), basicKeyboardPosition.y - (i % 3) * (keyboardHeight + keyboardGap), basicKeyboardPosition.z);
                Canvas[] tempC = keyboards[i].GetComponentsInChildren <Canvas>();
                deactivater[i, left]   = keyboards[i].GetComponentsInChildren <Canvas>()[left];
                deactivater[i, center] = keyboards[i].GetComponentsInChildren <Canvas>()[center];
                deactivater[i, right]  = keyboards[i].GetComponentsInChildren <Canvas>()[right];
                deactivater[i, whole]  = keyboards[i].GetComponentsInChildren <Canvas>()[whole];

                Text[] keysOn = keyboards[i].GetComponentsInChildren <Text>();
                for (int k = 0; k < 3; k++)
                {
                    keysOn[k].text = "" + keys[i, k];
                }
                if (i == 0 || i == 2 || i == 6 || i == 8)
                {
                    keyboards[i].GetComponent <MeshRenderer>().material.color = Color.white;
                    MeshFilter[] meshes = keyboards[i].GetComponentsInChildren <MeshFilter>();
                    int          k      = 0;
                    Vector3      pos;
                    Canvas[]     canvases = keyboards[i].GetComponentsInChildren <Canvas>();
                    foreach (Canvas c in canvases)
                    {
                        if (c.tag.CompareTo("highlight") == 0)
                        {
                            pos = c.transform.position;
                            switch (i)
                            {
                            case 0:
                                pos.x -= border;
                                pos.y += border;
                                break;

                            case 2:
                                pos.x -= border;
                                pos.y -= border;
                                break;

                            case 6:
                                pos.x += border;
                                pos.y += border;
                                break;

                            case 8:
                                pos.x += border;
                                pos.y -= border;
                                break;
                            }
                            c.transform.position = pos;
                        }
                    }
                    foreach (MeshFilter mesh in meshes)
                    {
                        if (k == 0)
                        {
                            k++;
                            pos = mesh.transform.position;
                            switch (i)
                            {
                            case 0:
                                pos.x += keyboardGap;
                                pos.y -= keyboardGap;
                                break;

                            case 2:
                                pos.x += keyboardGap;
                                pos.y += keyboardGap;
                                break;

                            case 6:
                                pos.x -= keyboardGap;
                                pos.y -= keyboardGap;
                                break;

                            case 8:
                                pos.x -= keyboardGap;
                                pos.y += keyboardGap;
                                break;
                            }
                            mesh.transform.position = pos;
                        }
                        else
                        {
                            pos = mesh.transform.position;
                            switch (i)
                            {
                            case 0:
                                pos.x -= border;
                                pos.y += border;
                                break;

                            case 2:
                                pos.x -= border;
                                pos.y -= border;
                                break;

                            case 6:
                                pos.x += border;
                                pos.y += border;
                                break;

                            case 8:
                                pos.x += border;
                                pos.y -= border;
                                break;
                            }
                            mesh.transform.position = pos;
                        }
                        k++;
                    }
                }
                else
                {
                    keyboards[i].GetComponent <MeshRenderer>().material.color = Color.gray;
                }
            }

            deactivateAll();

            initExperiment();
            initTouchPad();

            audio.Play();
        }
Ejemplo n.º 4
0
        void Start()
        {
            gtEvent         = new GazeTouchEvent();
            whichKeyboard   = "GAT3_adv";
            activatedWindow = 0;
            keyboards       = GameObject.FindGameObjectsWithTag("GAT_keyboard_zone");
            keysTemp        = new string[3];
            keysTemp[0]     = "qweasdzxc";
            keysTemp[1]     = "rtyfghvbn";
            keysTemp[2]     = "uioklpml.";
            char[]  temp;
            Vector3 basicKeyboardPosition = keyboards[0].transform.localPosition;
            Vector3 basicKeyboardScale    = keyboards[0].transform.localScale;

            basicKeyboardScale.x *= xScale;
            Vector3 basicTextScale = keyboards[0].GetComponentInChildren <Text>().transform.localScale;

            basicTextScale.x /= xScale;

            keyboardHeight = basicKeyboardScale.y;
            keyboardWidth  = basicKeyboardScale.x;
            keyboardGap    = keyboardHeight / 15;

            GATkeyboards  = new GAT_keyboard_zone[3];
            col_threshold = new float[3];
            int sub = 0;

            foreach (string key in keysTemp)
            {
                temp         = key.ToCharArray();
                keys[sub, 0] = temp[0];
                keys[sub, 1] = temp[1];
                keys[sub, 2] = temp[2];
                keys[sub, 3] = temp[3];
                keys[sub, 4] = temp[4];
                keys[sub, 5] = temp[5];
                keys[sub, 6] = temp[6];
                keys[sub, 7] = temp[7];
                keys[sub, 8] = temp[8];
                sub++;
            }

            //wordOnKeyboard = new Text[9];
            for (int i = 0; i < keyboards.Length; i++)
            {
                keyboards[i].transform.localPosition = new Vector3(basicKeyboardPosition.x + (i) * (keyboardWidth + keyboardGap), basicKeyboardPosition.y, basicKeyboardPosition.z);

                keyboards[i].transform.localScale = basicKeyboardScale;
                GATkeyboards[i] = keyboards[i].GetComponent <GAT_keyboard_zone>();
                //wordOnKeyboard[i] = keyboards[i].GetComponentsInChildren<Text>()[1];
                GATkeyboards[i].key = keyboards[i].GetComponentsInChildren <Text>()[0];


                GATkeyboards[i].setBasicKeys(keysTemp[i].ToCharArray());
                GATkeyboards[i].key.transform.localScale = basicTextScale;
                GATkeyboards[i].id = i;
            }
            //wordColor = wordOnKeyboard[0].color;
            integratedEyeCursor_yPoses    = new float[3];
            integratedEyeCursor_yPoses[0] = keyboards[0].transform.localPosition.y - keyboards[0].transform.localScale.y / 2;

            col_threshold = new float[2];

            col_threshold[0] = keyboards[1].transform.localPosition.x - (keyboards[1].transform.localScale.x - keyboardGap) / 2;
            col_threshold[1] = keyboards[2].transform.localPosition.x - (keyboards[2].transform.localScale.x - keyboardGap) / 2;
            selectedRow      = 0;

            initExperiment();
            initTouchPad();

            audio.Play();
        }
        void Start()
        {
            gtEvent         = new GazeTouchEvent();
            whichKeyboard   = "GAT";
            activatedWindow = 0;
            keyboards       = GameObject.FindGameObjectsWithTag("GAT_keyboard");
            keysTemp        = new string[9];
            keysTemp[0]     = "qwe";
            keysTemp[1]     = "asd";
            keysTemp[2]     = "zxc";
            keysTemp[3]     = "rty";
            keysTemp[4]     = "fgh";
            keysTemp[5]     = "vbn";
            keysTemp[6]     = "uio";
            keysTemp[7]     = "jkp";
            keysTemp[8]     = "ml.";
            char[]  temp;
            Vector3 basicKeyboardPosition = keyboards[0].transform.localPosition;
            Vector3 basicKeyboardScale    = keyboards[0].transform.localScale;

            basicKeyboardScale.x *= xScale;
            Vector3 basicTextScale = keyboards[0].GetComponentInChildren <Text>().transform.localScale;

            basicTextScale.x /= xScale;

            keyboardHeight = basicKeyboardScale.y;
            keyboardWidth  = basicKeyboardScale.x;
            keyboardGap    = keyboardHeight / 15;

            GATkeyboards  = new GAT_keyboard[9];
            col_threshold = new float[3];
            row_threshold = new float[3];
            int sub = 0;

            foreach (string key in keysTemp)
            {
                temp         = key.ToCharArray();
                keys[sub, 0] = temp[0];
                keys[sub, 1] = temp[1];
                keys[sub, 2] = temp[2];
                sub++;
            }

            //wordOnKeyboard = new Text[9];
            for (int i = 0; i < keyboards.Length; i++)
            {
                keyboards[i].transform.localPosition = new Vector3(basicKeyboardPosition.x + (i / 3) * (keyboardWidth + keyboardGap), basicKeyboardPosition.y - (i % 3) * (keyboardHeight + keyboardGap), basicKeyboardPosition.z);

                keyboards[i].transform.localScale = basicKeyboardScale;
                GATkeyboards[i] = keyboards[i].GetComponent <GAT_keyboard>();
                //wordOnKeyboard[i] = keyboards[i].GetComponentsInChildren<Text>()[1];
                GATkeyboards[i].key = keyboards[i].GetComponentsInChildren <Text>()[0];


                GATkeyboards[i].setBasicKeys(keys[i, 0], keys[i, 1], keys[i, 2]);
                GATkeyboards[i].key.transform.localScale = basicTextScale;
                GATkeyboards[i].id = i;
            }
            //wordColor = wordOnKeyboard[0].color;
            integratedEyeCursor_yPoses    = new float[3];
            integratedEyeCursor_yPoses[0] = keyboards[0].transform.localPosition.y - keyboards[0].transform.localScale.y / 2;
            integratedEyeCursor_yPoses[1] = keyboards[1].transform.localPosition.y - keyboards[1].transform.localScale.y / 2;
            integratedEyeCursor_yPoses[2] = keyboards[2].transform.localPosition.y - keyboards[2].transform.localScale.y / 2;

            col_threshold = new float[2];
            row_threshold = new float[2];

            row_threshold[0] = keyboards[1].transform.localPosition.y + (keyboards[1].transform.localScale.y + keyboardGap) / 2;
            row_threshold[1] = keyboards[2].transform.localPosition.y + (keyboards[2].transform.localScale.y + keyboardGap) / 2;
            col_threshold[0] = keyboards[3].transform.localPosition.x - (keyboards[3].transform.localScale.x - keyboardGap) / 2;
            col_threshold[1] = keyboards[6].transform.localPosition.x - (keyboards[6].transform.localScale.x - keyboardGap) / 2;

            initExperiment();
            initTouchPad();

            initCalib();


            foreach (GameObject g in markers)
            {
                g.SetActive(false);
            }
            foreach (GameObject g in keyboards)
            {
                g.SetActive(true);
            }
            audio.Play();
        }
Ejemplo n.º 6
0
        // Use this for initialization
        void Start()
        {
            gtEvent            = new GazeTouchEvent();
            whichKeyboard      = "Accuracy";
            isDynamicCascading = true;


            gazeRef      = new Vector2[calibPoint];
            markerPos    = new Vector2[calibPoint];
            keyLayout    = new string[calibPoint];
            keyLayout[0] = "●";
            keys         = GameObject.FindGameObjectsWithTag("marker");

            Vector3 basicPosition = keys[0].transform.localPosition;

            keyWidth  = keys[0].transform.localScale.x;
            keyHeight = keys[0].transform.localScale.y;
            Text text;


            foreach (GameObject g in keys)
            {
                g.GetComponentInChildren <Text>().text = "●";
            }
            keys[0].GetComponent <Calib_marker>().key = 'q';
            Vector3 keyPosition = new Vector3(basicPosition.x, basicPosition.y, basicPosition.z);

            keys[0].transform.localPosition           = keyPosition;
            keys[1].GetComponent <Calib_marker>().key = 'w';
            keyPosition = new Vector3(basicPosition.x + 0.055f * 4.5f, basicPosition.y, basicPosition.z);
            keys[1].transform.localPosition           = keyPosition;
            keys[2].GetComponent <Calib_marker>().key = 'e';
            keyPosition = new Vector3(basicPosition.x + 0.055f * 9, basicPosition.y, basicPosition.z);
            keys[2].transform.localPosition           = keyPosition;
            keys[3].GetComponent <Calib_marker>().key = 'a';
            keyPosition = new Vector3(basicPosition.x, basicPosition.y - 0.07f * 2, basicPosition.z);
            keys[3].transform.localPosition           = keyPosition;
            keys[4].GetComponent <Calib_marker>().key = 's';
            keyPosition = new Vector3(basicPosition.x + 0.055f * 4.5f, basicPosition.y - 0.07f * 2, basicPosition.z);
            keys[4].transform.localPosition           = keyPosition;
            keys[5].GetComponent <Calib_marker>().key = 'd';
            keyPosition = new Vector3(basicPosition.x + 0.055f * 9, basicPosition.y - 0.07f * 2, basicPosition.z);
            keys[5].transform.localPosition           = keyPosition;
            keys[6].GetComponent <Calib_marker>().key = 'z';
            keyPosition = new Vector3(basicPosition.x, basicPosition.y - 0.07f * 4, basicPosition.z);
            keys[6].transform.localPosition           = keyPosition;
            keys[7].GetComponent <Calib_marker>().key = 'x';
            keyPosition = new Vector3(basicPosition.x + 0.055f * 4.5f, basicPosition.y - 0.07f * 4, basicPosition.z);
            keys[7].transform.localPosition           = keyPosition;
            keys[8].GetComponent <Calib_marker>().key = 'c';
            keyPosition = new Vector3(basicPosition.x + 0.055f * 9, basicPosition.y - 0.07f * 4, basicPosition.z);
            keys[8].transform.localPosition = keyPosition;

            int i = 0;

            foreach (GameObject g in keys)
            {
                //should match input plane transform
                gazeRef[i]     = new Vector2();
                markerPos[i]   = new Vector2();
                markerPos[i].x = g.transform.localPosition.x;
                markerPos[i].y = g.transform.localPosition.y;
                i++;
            }
            initExperiment();
            audio.Play();
        }