예제 #1
0
    // Update is called once per frame
    void Update()
    {
        //targetText.text = targets.ToString();
        //RaycastHit hit;
        //Ray grabbingRay = new Ray (transform.position, Vector3.forward);
        //CharacterController charContr = GetComponent<CharacterController>();
        //Debug.DrawRay (transform.position, Vector3.forward * grabHeight);



        PDIposition = VRPN.vrpnTrackerPos("TrackerJohn@localhost", 1);

        transform.position = PDIposition;

        if (Input.GetKeyDown("space"))
        //if (Physics.Raycast (grabbingRay, out hit, grabHeight) && hit.collider.tag=="calibrate")
        {
            //Debug.Log ("hit the avatar");
            xpos.Add(PDIposition[0]);
            ypos.Add(PDIposition[1]);
            zpos.Add(PDIposition[2]);



            //				hit.collider.transform
            //movedCircle = GameObject.FindWithTag("avatar");
            //Destroy(hit.transform.gameObject);
            //touchedCircle = caliCircles.GetChild(targets);
            //	DestroyObject(touchedCircle);
            targets++;
            targetNumber = targets.ToString();
            pointNumber  = string.Concat("point", targetNumber);

            GameObject removePoint = GameObject.Find(pointNumber);
            Destroy(removePoint);
        }
        else
        {
        }

        if (targets > 0)           // participant only aims at middle dot.

        {
            getVirtualOrigin();
            //getTableScale();
            //getVirtualSurface();



            Debug.Log("Calibration Completed");
            Debug.Log(virtualOrigin);



            if (Input.GetKeyDown("s"))
            {
                SceneManager.LoadScene("ITI");
            }
        }
    }
예제 #2
0
    private IEnumerator Position()
    {
        while (true)
        {
            Vector3 pos = VRPN.vrpnTrackerPos(trackerAddress, channel);

            if (convertToLeft)
            {
                pos.x  = Interlocked.Exchange(ref pos.z, pos.x);
                pos.y *= -1;
                transform.localPosition = pos;
            }

            else
            {
                transform.localPosition = pos;
            }
            //float temp = pos.z;
            //pos.z = pos.x;
            //pos.x = temp;
            // pos.y = -pos.y;

            yield return(null);
        }
    }
예제 #3
0
 private void GetTrackerData(string name, int sensor)
 {
     PosVRPN      = VRPN.vrpnTrackerPos(name, sensor);
     PosTracker.x = PosVRPN.x;
     PosTracker.y = -PosVRPN.z;
     PosTracker.z = -PosVRPN.y;
     //Debug.Log("X: "+PosTracker.x.ToString("N5")+" Y: " + PosTracker.y.ToString("N5") + " Z: "+ PosTracker.z.ToString("N5"));
 }
예제 #4
0
 private IEnumerator Position()
 {
     while (true)
     {
         transform.localPosition = VRPN.vrpnTrackerPos(trackerAddress, channel);
         yield return(null);
     }
 }
    private Vector3 convertPuckPosition(Vector3 currentPos, int puckNum)
    {
        Vector3 rawVRPNpos = VRPN.vrpnTrackerPos("CC_FLAT_PUCK" + puckNum + "@" + CC_CONFIG.innovatorIP, 0);

        if ((rawVRPNpos.x != -505) || (rawVRPNpos.y != -505) || (rawVRPNpos.z != -505))
        {
            return(convertPosition(convertToLeftHandPosition(rawVRPNpos)));
        }
        return(currentPos);
    }
예제 #6
0
    void InputDataTracker(string address)
    {
        posVRPN = VRPN.vrpnTrackerPos(address, 2);

        x = 1 * posVRPN.x;
        y = -1 * posVRPN.z;
        z = -1 * posVRPN.y;

        actualTracker = new Vector3(x, y, z);
        Debug.Log(new Vector3(x * 1000, y * 1000, z * 1000));
    }
예제 #7
0
 // Update is called once per frame
 void Update()
 {
     if (trackPosition)
     {
         transform.position = VRPN.vrpnTrackerPos(obj + "@" + host, channel);
     }
     if (trackRotation)
     {
         transform.rotation = VRPN.vrpnTrackerQuat(obj + "@" + host, channel);
     }
 }
 /// <summary>
 /// Check to see if innovator tracking is valid.
 /// </summary>
 private bool checkInnovatorTracking()
 {
     /*if (VRPN.vrpnTrackerPos("CC_FLAT_HEAD@" + CC_CONFIG.trackerIP, 0) == new Vector3(-505, -505, -505)) {
      *  return false;
      * }*/
     if (VRPN.vrpnTrackerPos("CC_FLAT_HEAD@" + CC_CONFIG.innovatorIP, 0) == new Vector3(-505, -505, -505))
     {
         return(false);
     }
     return(true);
 }
    // Use this for initialization
    void Start()
    {
        //Initial calls to VRPN for puck 0, 1, 2 entries
        for (int i = 0; i < 3; i++)
        {
            VRPN.vrpnTrackerPos("CC_FLAT_PUCK" + i + "@" + CC_CONFIG.innovatorIP, 0);
            VRPN.vrpnTrackerQuat("CC_FLAT_PUCK" + i + "@" + CC_CONFIG.innovatorIP, 0);
        }

        headReference      = transform.GetChild(0).gameObject.transform;
        leftWandReference  = transform.GetChild(1).gameObject.transform;
        rightWandReference = transform.GetChild(2).gameObject.transform;
        waistReference     = transform.GetChild(3).gameObject.transform;
        leftFootReference  = transform.GetChild(4).gameObject.transform;
        rightFootReference = transform.GetChild(5).gameObject.transform;
    }
예제 #10
0
    ////////////// THREADING ///////////////////

    // Put what you want threaded in Task.Run *see below)
    // This gets called in Start();

    void GetPolhemusData()
    {
        Vector3 PDIposition = VRPN.vrpnTrackerPos(deviceName + "@" + deviceIP, sensor);

        float xpos = PDIposition [0];
        float ypos = PDIposition [1];
        float zpos = -1 * PDIposition [2];

        //string dataString = (xpos + "," + ypos + "," + zpos.ToString);
        Vector3 scalePDIposition = new Vector3(tableScaleX * xpos, tableScaleY * ypos, zpos);

        //Vector3 tablePosition = scalePDIposition - tableOrigin;
//		SensorString.Add(dataString);
        SensorData.Add(scalePDIposition.ToString("F3"));
        //SensorData.Add(scalePDIposition,DateTime.UtcNow.ToString("hh:mm:ss.ffffff"));
    }
예제 #11
0
    void InputDataTracker(string address)
    {
        posVRPN = VRPN.vrpnTrackerPos(address, 3);

        x = 1 * posVRPN.x;
        y = -1 * posVRPN.z;
        z = -1 * posVRPN.y;

        Vector3 qVector = new Vector3(x, y, z);

        bufferTracker.Enqueue(qVector);
        if (bufferTracker.Count > tamBuffer)
        {
            bufferTracker.Dequeue();
        }
    }
예제 #12
0
    // Update is called once per frame
    void Update()
    {
        // Get data from the Polhemus
        updatePDIposition = VRPN.vrpnTrackerPos(deviceName + "@" + deviceIP, sensor);
        float xpos = updatePDIposition [0];
        float ypos = updatePDIposition [1];
        float zpos = -1 * updatePDIposition [2];

        // rescale to UNITY Table dimensions
        updatescalePDIposition = new Vector3(tableScaleX * xpos, tableScaleY * ypos, scale * zpos + 2);

        frame++;

//		if (frame > 1){
//			tablePositionLast = tablePosition; // set last position
//		}

        ////// TESTING positions in Console: /////

        //Debug.Log (newPDIposition);
        //Debug.Log (tablePosition);



        // transform Pohlemus space to table space:
        tablePosition = updatescalePDIposition - tableOrigin;
        // tableXpos = tablePosition[0];
        // tableYpos = tablePosition[1];
        // tableZpos = tablePosition[2];



//		if (frame > 1){
//
//			// position differentiation (instantaneous velocity)
//			sensorVelocity = (tablePosition - tablePositionLast)/Time.deltaTime;
//
//			// velX = (tablePosition[0]-tablePositionLast[0])/ Time.deltaTime;  // isolated by axis
//			// velY = (tablePosition[1]-tablePositionLast[1])/ Time.deltaTime;
//			// velZ = (tablePosition[2]-tablePositionLast[2])/ Time.deltaTime;
//		}


        ////////// ROTATION DATA ////////////////////////

        //updatePDIrotation = VRPN.vrpnTrackerQuat("TrackerJohn@localhost",sensor);
    }
 void Update()
 {
     foreach (VRPNConnection vrpnC in _connectionList.Values)
     {
         if (vrpnC._VRPNObject != null)
         {
             Vector3    tmpPos  = VRPN.vrpnTrackerPos(vrpnC._VRPNObject, 0);
             Quaternion tmpQuat = VRPN.vrpnTrackerQuat(vrpnC._VRPNObject, 0);
             Vector3    pos     = new Vector3(-tmpPos.x, tmpPos.z, -tmpPos.y);
             Quaternion quat    = new Quaternion(tmpQuat.x, -tmpQuat.z, tmpQuat.y, tmpQuat.w);
             vrpnC._pos  = pos;
             vrpnC._quat = quat;
             //NetworkServer.SendToAll (MESSAGE_DATA, new VRPNMessage (pos, quat));
             NetworkServer.SendToClient(vrpnC._connectionID, MESSAGE_DATA, new VRPNMessage(pos, quat));
         }
     }
 }
예제 #14
0
    ////////////// THREADING ///////////////////
    public void PolhemusDataThread()
    {
        Task.Run(() => {
            //int totSampleint = Convert.ToInt32(totSample);
            // [...] Code to be executed in auxiliary thread
            for (int i = 0; i < 1000; i++)
            {
                int value           = i;
                Vector3 PDIposition = VRPN.vrpnTrackerPos(deviceName + "@" + deviceIP, sensor);
                float xpos          = PDIposition [0];
                float ypos          = PDIposition [1];
                float zpos          = -1 * PDIposition [2];

                Vector3 scalePDIposition = new Vector3(scale * xpos, scale * ypos, scale * zpos + 2);
                Vector3 tablePosition    = scalePDIposition - tableOrigin;
                SensorData.Add(tablePosition);

                // sleep in millisec (1/ (sleep/1000) = sampleRate
                System.Threading.Thread.Sleep(10);
            }
        });        //.ContinueInMainThreadWith(Update);
    }
예제 #15
0
    public static Vector3 vrpnTrackerPos(string address, int channel)
    {
        var vector = VRPN.vrpnTrackerPos(address, channel);

        return(new Vector3(-vector.x, vector.y, vector.z));
    }
예제 #16
0
    /// <summary>
    /// Obtain tracker information.
    /// </summary>
    private void getTrackerInformation()
    {
        if (CC_CONFIG.IsDestiny())
        {
            Vector3    position = new Vector3(0, 0, 0);
            Quaternion rotation = Quaternion.identity;

            if (canoe.isVive())
            {
                //Update head ClusterInput entry
                position = ClusterInput.GetTrackerPosition("head");
                rotation = ClusterInput.GetTrackerRotation("head");
                //Angle puck so flat section is bottom
                //Change "Camera Forward Tilt" in editor to change tilt if hat/helmet is angled
                rotation *= Quaternion.AngleAxis(90 - canoe.cameraForwardTilt, Vector3.left);
                rotation *= Quaternion.AngleAxis(180, Vector3.up);
                convertHeadTracking(position, rotation);

                //Update left controller ClusterInput entries
                position = ClusterInput.GetTrackerPosition("leftWand");
                rotation = ClusterInput.GetTrackerRotation("leftWand");
                convertWandTracking(Wand.Left, position, rotation);

                //Update right controller ClusterInput entries
                position = ClusterInput.GetTrackerPosition("rightWand");
                rotation = ClusterInput.GetTrackerRotation("rightWand");
                convertWandTracking(Wand.Right, position, rotation);

                //Moving the Character Controller with the head movement
                float same = CC_CANOE.CanoeCharacterController().center.y;
                CC_CANOE.CanoeCharacterController().center = new Vector3(headPosition.x, same, headPosition.z);
            }
            else if (canoe.isOptiTrack())
            {
                //Head position and rotation
                position = ClusterInput.GetTrackerPosition("head");
                //position = new Vector3(position.x, position.y, -position.z);
                rotation = ClusterInput.GetTrackerRotation("head");
                convertHeadTracking(position, rotation);

                //Left wand position and rotation
                position = ClusterInput.GetTrackerPosition("leftWand");
                rotation = ClusterInput.GetTrackerRotation("leftWand");
                convertWandTracking(Wand.Left, position, rotation);

                //Right wand position and rotation
                position = ClusterInput.GetTrackerPosition("rightWand");
                rotation = ClusterInput.GetTrackerRotation("rightWand");
                convertWandTracking(Wand.Right, position, rotation);

                //Moving the Character Controller with the head movement
                float same = CC_CANOE.CanoeCharacterController().center.y;

                CC_CANOE.CanoeCharacterController().center = new Vector3(headPosition.x, same, headPosition.z);
            }
        }
        else
        {
            if (CC_CONFIG.IsInnovator())
            {
                //if (checkInnovatorTracking()) {
                headPosition = convertToLeftHandPosition(VRPN.vrpnTrackerPos("CC_FLAT_HEAD@" + CC_CONFIG.innovatorIP, 0));
                headRotation = convertToLeftHandRotation(VRPN.vrpnTrackerQuat("CC_FLAT_HEAD@" + CC_CONFIG.innovatorIP, 0) * Quaternion.AngleAxis(90 - canoe.cameraForwardTilt, Vector3.left) * Quaternion.AngleAxis(180, Vector3.up));

                //Moving the Character Controller with the head movement
                float same = CC_CANOE.CanoeCharacterController().center.y;
                CC_CANOE.CanoeCharacterController().center = new Vector3(headPosition.x, same, headPosition.z);

                //Wands rotation and position.
                wandPosition[0] = convertToLeftHandPosition(VRPN.vrpnTrackerPos("CC_FLAT_WAND0@" + CC_CONFIG.innovatorIP, 0));
                wandPosition[1] = convertToLeftHandPosition(VRPN.vrpnTrackerPos("CC_FLAT_WAND1@" + CC_CONFIG.innovatorIP, 0));
                wandRotation[0] = convertToLeftHandRotation(VRPN.vrpnTrackerQuat("CC_FLAT_WAND0@" + CC_CONFIG.innovatorIP, 0));
                wandRotation[1] = convertToLeftHandRotation(VRPN.vrpnTrackerQuat("CC_FLAT_WAND1@" + CC_CONFIG.innovatorIP, 0));
            }
            else
            {
                setDefaultPositions();
            }
        }
    }
예제 #17
0
    public static Vector3 vrpnTrackerPos(string address, int channel)
    {
        Vector3 pos = VRPN.vrpnTrackerPos(address, channel);

        return(new Vector3(pos.x, pos.z, pos.y));
    }
예제 #18
0
    // Update is called once per frame
    void Update()
    {
        // get the time (add to list)
        //Clockupdate.Add(DateTime.UtcNow.ToString("hh:mm:ss.ffffff"));


        // check for children
        // if the required number of targets have been hit *see TableEvents.cs trigger:
//		if (TableEvents.triggerCounter.triggerCount > TableEvents.goalHitCounter.goalHit){
//
//			saveAll(); // save Polhemus data
//			//SceneManager.LoadScene("4.TableActive");
//		}


        // if trials are timed:
//		countdown -= Time.deltaTime;


//		if (countdown < 0){
//			saveAll();
//			SceneManager.LoadScene("1.splashScreen");
//
//		}


        // Get data from the Polhemus
        updatePDIposition = VRPN.vrpnTrackerPos(deviceName + "@" + deviceIP, sensor);
        float xpos = updatePDIposition [0];
        float ypos = updatePDIposition [1];         // tweeks to center avatar on marker
        float zpos = -1 * updatePDIposition [2];

        // rescale to UNITY Table dimensions
        updatescalePDIposition = new Vector3(xpos / tableScaleX, ypos / tableScaleY, zpos);


        // frames necessary if using velocity measure to move:

//		frame++;
//
//		if (frame > 1){
//			tablePositionLast = tablePosition; // set last position
//		}

        ////// TESTING positions in Console: /////

        //Debug.Log (newPDIposition);
        //Debug.Log (tablePosition);



        // transform Pohlemus space to table space:
        tablePosition   = updatescalePDIposition - tableOrigin;
        tablePosition.z = playerSide;
//		tableXpos = tablePosition[0];
//		tableYpos = tablePosition[1];
//		tableZpos = tablePosition[2];

        // tableSensor object
        transform.position = Vector3.Lerp(tablePosition, tablePositionLast, Time.deltaTime);


        tablePositions.Add(tablePosition.ToString("F3"));



//		if (frame > 1){
//
//			// position differentiation (instantaneous velocity)
//			sensorVelocity = (tablePosition - tablePositionLast)/Time.deltaTime;
//
//			// velX = (tablePosition[0]-tablePositionLast[0])/ Time.deltaTime;  // isolated by axis
//			// velY = (tablePosition[1]-tablePositionLast[1])/ Time.deltaTime;
//			// velZ = (tablePosition[2]-tablePositionLast[2])/ Time.deltaTime;
//		}


        ////////// ROTATION DATA ////////////////////////

        //updatePDIrotation = VRPN.vrpnTrackerQuat("TrackerJohn@localhost",sensor);
    }