/*
* Oculus Rift - Lots of obsolete functions, bits of which might be needed in the future if Oculus Unity Utilities support will be added
*/
// Oculus positional tracking camera's coordinate system origin in Unity coordinate system
// public Vector3 GetOculusCameraOriginRaw()
// {
//// if (OVRManager.capiHmd != null)
//// {
//// Vector3 currentOvrCameraPose = OVRManager.capiHmd.GetTrackingState().CameraPose.Position.ToVector3 (); //06to08
////
//// return Quaternion.Inverse(GetOculusCameraOrientationRaw())*currentOvrCameraPose;
//// } else //06to08
// return Vector3.zero; // HACK remove this method
// }
// Oculus positional tracking camera's coordinate system origin in master coordinate system
// public Vector3 GetOculusCameraOrigin()
// {
// return ConvertLocation(GetOculusCameraOriginRaw(), RUISDevice.Oculus_DK2);
// }
// Oculus positional tracking camera's coordinate system orientation in Unity coordinates
// public Quaternion GetOculusCameraOrientationRaw()
// {
//// if (OVRManager.capiHmd != null)
//// {
//// return OVRManager.capiHmd.GetTrackingState().CameraPose.Orientation.ToQuaternion(); //06to08
//// } else
// return Quaternion.identity; // HACK remove this method
// }
// public Vector3 ConvertRawOculusDK2Location(Vector3 position)
// {
//// Vector3 currentcameraPosition = Vector3.zero;
//// if (OVRManager.capiHmd != null)
//// currentcameraPosition = OVRManager.capiHmd.GetTrackingState().CameraPose.Position.ToVector3(); //06to08
//// return Quaternion.Inverse(GetOculusCameraOrientationRaw())*(position - currentcameraPosition); //06to08
//
// return UnityEngine.VR.InputTracking.GetLocalPosition(UnityEngine.VR.VRNode.Head); // HACK TODO if this doesn't work for major HMDs, add wrapper
// }
/// <summary>
/// Convert velocity or angular velocity obtained with a certain device to master coordinate system, apply yaw offset, and apply Kinect pitch correction
/// </summary>
public Vector3 ConvertVelocity(Vector3 velocity, RUISDevice device)
{
Vector3 newVelocity = velocity;
if (applyToRootCoordinates && rootDevice != device)
{
string devicePairString = device.ToString() + "-" + rootDevice.ToString();
newVelocity = RUISCalibrationResultsInQuaternion[devicePairString] * newVelocity;
}
// Apply floor pitch rotation (which is identity to anything else than Kinect 1/2)
if (applyToRootCoordinates || device == rootDevice)
{
newVelocity = RUISCalibrationResultsFloorPitchRotation[rootDevice] * newVelocity;
}
else
{
if (device == RUISDevice.Kinect_2)
{
newVelocity = RUISCalibrationResultsFloorPitchRotation[RUISDevice.Kinect_2] * newVelocity;
}
else if (device == RUISDevice.Kinect_1)
{
newVelocity = RUISCalibrationResultsFloorPitchRotation[RUISDevice.Kinect_1] * newVelocity;
}
}
newVelocity = Quaternion.Euler(0, yawOffset, 0) * newVelocity;
return(newVelocity);
}
/// <summary>
/// Convert rotation obtained with a certain device to master coordinate system, apply yaw offset, and apply Kinect pitch correction
/// </summary>
public Quaternion ConvertRotation(Quaternion inputRotation, RUISDevice device)
{
Quaternion outputRotation = inputRotation;
if (applyToRootCoordinates && rootDevice != device)
{
string devicePairString = device.ToString() + "-" + rootDevice.ToString();
outputRotation = RUISCalibrationResultsInQuaternion[devicePairString] * outputRotation;
}
// Apply floor pitch rotation (which is identity to anything else than Kinect 1/2)
if (applyToRootCoordinates || device == rootDevice)
{
outputRotation = RUISCalibrationResultsFloorPitchRotation[rootDevice] * outputRotation;
}
else
{
if (device == RUISDevice.Kinect_2)
{
outputRotation = RUISCalibrationResultsFloorPitchRotation[RUISDevice.Kinect_2] * outputRotation;
}
else if (device == RUISDevice.Kinect_1)
{
outputRotation = RUISCalibrationResultsFloorPitchRotation[RUISDevice.Kinect_1] * outputRotation;
}
}
// Apply yaw offset
if (applyToRootCoordinates || device == rootDevice)
{
outputRotation = Quaternion.Euler(0, yawOffset, 0) * outputRotation;
}
return(outputRotation);
}
/// <summary>
/// Convert location obtained with a certain device to master coordinate system, apply position offset, and set Kinect origin to floor if applicable
/// </summary>
public Vector3 ConvertLocation(Vector3 inputLocation, RUISDevice device)
{
Vector3 outputLocation = inputLocation;
// Transform location into master coordinate system
if (applyToRootCoordinates && rootDevice != device)
{
string devicePairString = device.ToString() + "-" + rootDevice.ToString();
outputLocation = RUISCalibrationResultsIn4x4Matrix[devicePairString].MultiplyPoint3x4(outputLocation);
// outputLocation = RUISCalibrationResultsInQuaternion[devicePairString] * outputLocation;
}
// Apply yaw offset and floor pitch rotation (which is identity to anything else than Kinect 1/2)
if (applyToRootCoordinates || device == rootDevice)
{
outputLocation = Quaternion.Euler(0, yawOffset, 0) * RUISCalibrationResultsFloorPitchRotation[rootDevice] * outputLocation;
}
else
{
if (device == RUISDevice.Kinect_2)
{
outputLocation = RUISCalibrationResultsFloorPitchRotation[RUISDevice.Kinect_2] * outputLocation;
}
else if (device == RUISDevice.Kinect_1)
{
outputLocation = RUISCalibrationResultsFloorPitchRotation[RUISDevice.Kinect_1] * outputLocation;
}
}
// Set Kinect 1/2 origin to floor
if (setKinectOriginToFloor)
{
if (applyToRootCoordinates || device == rootDevice)
{
outputLocation.y += RUISCalibrationResultsDistanceFromFloor[rootDevice];
}
else
{
if (device == RUISDevice.Kinect_2)
{
outputLocation.y += RUISCalibrationResultsDistanceFromFloor[RUISDevice.Kinect_2];
}
else if (device == RUISDevice.Kinect_1)
{
outputLocation.y += RUISCalibrationResultsDistanceFromFloor[RUISDevice.Kinect_1];
}
}
}
// Position offset
if (applyToRootCoordinates || device == rootDevice)
{
outputLocation += positionOffset;
}
return(outputLocation);
}
/// <summary>
/// Returns an approximation of Vector3 localScale (calculated from RUISCalibrationResultsIn4x4Matrix[devicePairString]),
/// which can be used to compensate the scale difference between the master coordinate system frame and the argument device frame.
/// </summary>
public Vector3 ExtractLocalScale(RUISDevice device)
{
if (applyToRootCoordinates && rootDevice != device)
{
string devicePairString = device.ToString() + "-" + rootDevice.ToString();
Matrix4x4 matrix = RUISCalibrationResultsIn4x4Matrix[devicePairString];
// Extract new local scale
return(new Vector3(matrix.GetColumn(0).magnitude, matrix.GetColumn(1).magnitude, matrix.GetColumn(2).magnitude));
}
else
{
return(Vector3.one);
}
}
public void updateDictionaries(Dictionary <string, Vector3> RUISCalibrationResultsInVector3,
Dictionary <string, Quaternion> RUISCalibrationResultsInQuaternion,
Dictionary <string, Matrix4x4> RUISCalibrationResultsIn4x4Matrix,
Vector3 translate, Quaternion rotation, Matrix4x4 pairwiseTransform,
RUISDevice device1, RUISDevice device2)
{
RUISCalibrationResultsInVector3[device1.ToString() + "-" + device2.ToString()] = translate;
RUISCalibrationResultsIn4x4Matrix[device1.ToString() + "-" + device2.ToString()] = pairwiseTransform;
RUISCalibrationResultsInQuaternion[device1.ToString() + "-" + device2.ToString()] = rotation;
// Inverses
RUISCalibrationResultsInVector3[device2.ToString() + "-" + device1.ToString()] = -translate;
RUISCalibrationResultsIn4x4Matrix[device2.ToString() + "-" + device1.ToString()] = pairwiseTransform.inverse;
RUISCalibrationResultsInQuaternion[device2.ToString() + "-" + device1.ToString()] = Quaternion.Inverse(rotation);
}
public void updateDictionaries(Dictionary<string, Vector3> RUISCalibrationResultsInVector3,
Dictionary<string, Quaternion> RUISCalibrationResultsInQuaternion,
Dictionary<string, Matrix4x4> RUISCalibrationResultsIn4x4Matrix,
Vector3 translate, Quaternion rotation, Matrix4x4 pairwiseTransform,
RUISDevice device1, RUISDevice device2)
{
RUISCalibrationResultsInVector3[device1.ToString() + "-" + device2.ToString()] = translate;
RUISCalibrationResultsIn4x4Matrix[device1.ToString() + "-" + device2.ToString()] = pairwiseTransform;
RUISCalibrationResultsInQuaternion[device1.ToString() + "-" + device2.ToString()] = rotation;
// Inverses
RUISCalibrationResultsInVector3[device2.ToString() + "-" + device1.ToString()] = -translate;
RUISCalibrationResultsIn4x4Matrix[device2.ToString() + "-" + device1.ToString()] = pairwiseTransform.inverse;
RUISCalibrationResultsInQuaternion[device2.ToString() + "-" + device1.ToString()] = Quaternion.Inverse(rotation);
}
private Vector3 getSample(RUISDevice device)
{
Vector3 sample = new Vector3(0, 0, 0);
Vector3 tempSample;
if (device == RUISDevice.Oculus_DK2)
{
Ovr.Posef headpose = RUISOVRManager.ovrHmd.GetTrackingState().HeadPose.ThePose;
float px = headpose.Position.x;
float py = headpose.Position.y;
float pz = -headpose.Position.z; // This needs to be negated TODO: might change with future OVR version
tempSample = new Vector3(px, py, pz);
tempSample = coordinateSystem.ConvertRawOculusDK2Location(tempSample);
if ((Vector3.Distance(tempSample, lastOculusDK2Sample) > 0.1) &&
(RUISOVRManager.ovrHmd.GetTrackingState().StatusFlags & (uint)StatusBits.PositionTracked) != 0)
{
sample = tempSample;
lastOculusDK2Sample = sample;
this.guiTextUpperLocal = "";
}
else
{
this.guiTextUpperLocal = "Not enough hand movement.";
}
}
if (device == RUISDevice.PS_Move)
{
if (psMoveWrapper.sphereVisible[calibratingPSMoveControllerId] &&
psMoveWrapper.handleVelocity[calibratingPSMoveControllerId].magnitude <= 10.0f)
{
tempSample = coordinateSystem.ConvertRawPSMoveLocation(psMoveWrapper.handlePosition[calibratingPSMoveControllerId]);
if (Vector3.Distance(tempSample, lastPSMoveSample) > 0.1)
{
sample = tempSample;
lastPSMoveSample = sample;
this.guiTextUpperLocal = "";
}
else
{
this.guiTextUpperLocal = "Not enough hand movement.";
}
}
}
return(sample);
}
private Vector3 getSample(RUISDevice device)
{
Vector3 sample = new Vector3(0, 0, 0);
Vector3 tempSample;
if (device == RUISDevice.Kinect_1)
{
OpenNI.SkeletonJointPosition jointPosition;
bool success = kinectSelection.GetPlayer(0).GetSkeletonJointPosition(OpenNI.SkeletonJoint.RightHand, out jointPosition);
if (success && jointPosition.Confidence >= 0.5)
{
tempSample = coordinateSystem.ConvertRawKinectLocation(jointPosition.Position);
if (Vector3.Distance(tempSample, lastKinectSample) > 0.1)
{
sample = tempSample;
lastKinectSample = sample;
this.guiTextUpperLocal = "";
}
else
{
this.guiTextUpperLocal = "Not enough hand movement.";
}
}
}
if (device == RUISDevice.Oculus_DK2)
{
Ovr.Posef headpose = RUISOVRManager.ovrHmd.GetTrackingState().HeadPose.ThePose;
float px = headpose.Position.x;
float py = headpose.Position.y;
float pz = -headpose.Position.z; // This needs to be negated TODO: might change with future OVR version
tempSample = new Vector3(px, py, pz);
tempSample = coordinateSystem.ConvertRawOculusDK2Location(tempSample);
if ((Vector3.Distance(tempSample, lastOculusDK2Sample) > 0.1) &&
(RUISOVRManager.ovrHmd.GetTrackingState().StatusFlags & (uint)StatusBits.PositionTracked) != 0) // Code from OVRManager.cs
{
sample = tempSample;
lastOculusDK2Sample = sample;
this.guiTextUpperLocal = "";
}
else
{
this.guiTextUpperLocal = "Not enough hand movement.";
}
}
return(sample);
}
public void SetDistanceFromFloor(float distance, RUISDevice floorDetectingDevice)
{
switch (floorDetectingDevice)
{
case RUISDevice.Kinect_1:
RUISCalibrationResultsDistanceFromFloor[RUISDevice.Kinect_1] = distance;
break;
case RUISDevice.Kinect_2:
RUISCalibrationResultsDistanceFromFloor[RUISDevice.Kinect_2] = distance;
break;
default:
Debug.LogWarning("Currently floor distance detection with " + floorDetectingDevice.ToString() + " is not supported!");
break;
}
}
private Vector3 getSample(RUISDevice device)
{
Vector3 sample = new Vector3(0, 0, 0);
Vector3 tempSample;
if (device == RUISDevice.Kinect_1)
{
OpenNI.SkeletonJointPosition jointPosition;
bool success = kinectSelection.GetPlayer(0).GetSkeletonJointPosition(OpenNI.SkeletonJoint.RightHand, out jointPosition);
if (success && jointPosition.Confidence >= 0.5)
{
tempSample = coordinateSystem.ConvertRawKinectLocation(jointPosition.Position);
if (Vector3.Distance(tempSample, lastKinectSample) > 0.1)
{
sample = tempSample;
lastKinectSample = sample;
this.guiTextUpperLocal = "";
}
else
{
this.guiTextUpperLocal = "Not enough hand movement.";
}
}
}
if (device == RUISDevice.PS_Move)
{
if (psMoveWrapper.sphereVisible[calibratingPSMoveControllerId] &&
psMoveWrapper.handleVelocity[calibratingPSMoveControllerId].magnitude <= 10.0f)
{
tempSample = coordinateSystem.ConvertRawPSMoveLocation(psMoveWrapper.handlePosition[calibratingPSMoveControllerId]);
if (Vector3.Distance(tempSample, lastPSMoveSample) > 0.1)
{
sample = tempSample;
lastPSMoveSample = sample;
this.guiTextUpperLocal = "";
}
else
{
this.guiTextUpperLocal = "Not enough hand movement.";
}
}
}
return(sample);
}
/// <summary>
/// Head-mounted display coordinate system's orientation around master coordinate system's Y-axis
/// </summary>
public Quaternion GetHmdCoordinateSystemYaw(RUISDevice device)
{
Quaternion convertedRotation = ConvertRotation(Quaternion.identity, device);
Vector3 projected = convertedRotation * Vector3.forward;
projected.Set(projected.x, 0, projected.z);
// Make sure that the projection is not pointing too much up
if (projected.sqrMagnitude > 0.001)
{
return(Quaternion.LookRotation(projected));
}
else // *** HACK TODO The HMD coordinate system view axis is parallel with the master coordinate system's Y-axis!
{
return(Quaternion.identity);
}
}
public void SetFloorNormal(Vector3 newFloorNormal, RUISDevice floorDetectingDevice)
{
Quaternion kinectFloorRotator = Quaternion.identity;
kinectFloorRotator.SetFromToRotation(newFloorNormal, Vector3.up);
kinectFloorRotator = Quaternion.Inverse(kinectFloorRotator);
switch (floorDetectingDevice)
{
case RUISDevice.Kinect_1:
RUISCalibrationResultsFloorPitchRotation[RUISDevice.Kinect_1] = kinectFloorRotator;
break;
case RUISDevice.Kinect_2:
RUISCalibrationResultsFloorPitchRotation[RUISDevice.Kinect_2] = kinectFloorRotator;
break;
default:
Debug.LogWarning("Currently floor normal detection with " + floorDetectingDevice.ToString() + " is not supported!");
break;
}
}
public RUISKinect2ToKinectCalibrationProcess(RUISCalibrationProcessSettings calibrationSettings) {
this.inputDevice1 = RUISDevice.Kinect_2;
this.inputDevice2 = RUISDevice.Kinect_1;
this.numberOfSamplesToTake = calibrationSettings.numberOfSamplesToTake;
this.numberOfSamplesPerSecond = calibrationSettings.numberOfSamplesPerSecond;
trackingIDs = new trackedBody[6];
for(int y = 0; y < trackingIDs.Length; y++) {
trackingIDs[y] = new trackedBody(-1, false, 1);
}
kinectSelection = MonoBehaviour.FindObjectOfType(typeof(NIPlayerManagerCOMSelection)) as NIPlayerManagerCOMSelection;
settingsManager = MonoBehaviour.FindObjectOfType(typeof(OpenNISettingsManager)) as OpenNISettingsManager;
inputManager = MonoBehaviour.FindObjectOfType(typeof(RUISInputManager)) as RUISInputManager;
coordinateSystem = MonoBehaviour.FindObjectOfType(typeof(RUISCoordinateSystem)) as RUISCoordinateSystem;
kinect2SourceManager = MonoBehaviour.FindObjectOfType(typeof(Kinect2SourceManager)) as Kinect2SourceManager;
this.timeSinceScriptStart = 0;
this.timeBetweenSamples = 1 / (float)numberOfSamplesPerSecond;
// Limit sample rate
if(this.timeBetweenSamples < 0.1f) {
this.timeBetweenSamples = 0.1f;
}
calibrationSpheres = new List<GameObject>();
samples_Kinect1 = new List<Vector3>();
samples_Kinect2 = new List<Vector3>();
this.calibrationCube = calibrationSettings.calibrationCubePrefab;
this.calibrationSphere = calibrationSettings.calibrationSpherePrefab;
this.calibrationPhaseObjects = calibrationSettings.calibrationPhaseObjects;
this.calibrationResultPhaseObjects = calibrationSettings.calibrationResultPhaseObjects;
this.deviceModelObjects = calibrationSettings.deviceModelObjects;
this.depthViewObjects = calibrationSettings.depthViewObjects;
this.iconObjects = calibrationSettings.iconObjects;
if(GameObject.Find ("PSMoveWand") != null)
GameObject.Find ("PSMoveWand").SetActive(false);
// Models
this.kinect1ModelObject = GameObject.Find ("KinectCamera");
this.kinect2ModelObject = GameObject.Find ("Kinect2Camera");
RUISSkeletonController skeletonController = Component.FindObjectOfType<RUISSkeletonController>();
Transform rightHand = null;
if(skeletonController)
rightHand = skeletonController.rightHand;
FixedFollowTransform followTransform = Component.FindObjectOfType<FixedFollowTransform>();
if(followTransform && rightHand)
followTransform.transformToFollow = rightHand;
// Depth view
this.depthView = GameObject.Find ("KinectDepthView");
this.depthView2 = GameObject.Find ("Kinect2DepthView");
// Icons
this.Kinect1Icon = GameObject.Find ("Kinect Icon");
this.Kinect2Icon = GameObject.Find ("Kinect2 Icon");
this.floorPlane = GameObject.Find ("Floor");
if(this.Kinect1Icon && this.Kinect1Icon.GetComponent<GUITexture>())
this.Kinect1Icon.GetComponent<GUITexture>().pixelInset = new Rect(5.1f, 10.0f, 70.0f, 70.0f);
foreach (Transform child in this.deviceModelObjects.transform)
{
child.gameObject.SetActive(false);
}
foreach (Transform child in this.depthViewObjects.transform)
{
child.gameObject.SetActive(false);
}
foreach (Transform child in this.iconObjects.transform)
{
child.gameObject.SetActive(false);
}
if(this.kinect1ModelObject)
this.kinect1ModelObject.SetActive(true);
if(this.kinect2ModelObject)
this.kinect2ModelObject.SetActive(true);
if(this.Kinect1Icon)
this.Kinect1Icon.SetActive(true);
if(this.Kinect2Icon)
this.Kinect2Icon.SetActive(true);
if(this.calibrationPhaseObjects)
this.calibrationPhaseObjects.SetActive(true);
if(this.calibrationResultPhaseObjects)
this.calibrationResultPhaseObjects.SetActive(false);
if(this.depthView)
this.depthView.SetActive(true);
if(this.depthView2)
this.depthView2.SetActive(true);
this.xmlFilename = calibrationSettings.xmlFilename;
}
void Awake()
{
string[] names = System.Enum.GetNames(typeof(RUISDevice));
foreach (string device in names)
{
RUISDevice device1Enum = (RUISDevice)System.Enum.Parse(typeof(RUISDevice), device, true);
RUISCalibrationResultsFloorPitchRotation[device1Enum] = Quaternion.identity;
RUISCalibrationResultsDistanceFromFloor[device1Enum] = 0.0f;
foreach (string device2 in names)
{
if (device != device2)
{
string devicePairString = device + "-" + device2;
RUISCalibrationResultsInVector3[devicePairString] = new Vector3(0, 0, 0);
RUISCalibrationResultsInQuaternion[devicePairString] = Quaternion.identity;
RUISCalibrationResultsIn4x4Matrix[devicePairString] = Matrix4x4.identity;
}
}
}
if (loadFromXML)
{
if (!LoadMultiXML(coordinateXmlFile))
{
createExampleXML(coordinateXmlFile);
}
}
inputManager = FindObjectOfType <RUISInputManager>();
if (switchToAvailableDevice && inputManager)
{
bool needToSwitch = false;
RUISDevice previousDevice = rootDevice;
switch (rootDevice)
{
case RUISDevice.Kinect_1:
if (!inputManager.enableKinect)
{
needToSwitch = true;
}
break;
case RUISDevice.Kinect_2:
if (!inputManager.enableKinect2)
{
needToSwitch = true;
}
break;
case RUISDevice.PS_Move:
if (!inputManager.enablePSMove)
{
needToSwitch = true;
}
break;
case RUISDevice.Oculus_DK2:
if (!isPositionTrackableRiftPresent())
{
needToSwitch = true;
}
break;
}
if (needToSwitch)
{
if (inputManager.enableKinect2)
{
rootDevice = RUISDevice.Kinect_2;
}
else if (inputManager.enableKinect)
{
rootDevice = RUISDevice.Kinect_1;
}
else if (isPositionTrackableRiftPresent())
{
rootDevice = RUISDevice.Oculus_DK2;
}
else if (inputManager.enablePSMove)
{
rootDevice = RUISDevice.PS_Move;
}
if (rootDevice != previousDevice)
{
if (previousDevice == RUISDevice.Oculus_DK2)
{
Debug.LogWarning("Switched 'Master Coordinate System Sensor' from " + previousDevice + " to " + rootDevice + " "
+ "because Oculus Rift DK2+ was not detected!");
}
else
{
Debug.LogWarning("Switched 'Master Coordinate System Sensor' from " + previousDevice + " to " + rootDevice + " "
+ "because the former was not enabled in " + typeof(RUISInputManager) + " while the latter was!");
}
}
}
}
}
private Vector3 getSample(RUISDevice device) {
Vector3 sample = new Vector3(0,0,0);
Vector3 tempSample;
updateBodyData();
if(device == RUISDevice.Kinect_2)
{
Kinect.Body[] data = kinect2SourceManager.GetBodyData();
bool trackedBodyFound = false;
int foundBodies = 0;
foreach(var body in data)
{
foundBodies++;
if(body.IsTracked)
{
if(trackingIDtoIndex[body.TrackingId] == 0)
{
trackedBodyFound = true;
if(body.Joints[Kinect.JointType.HandRight].TrackingState == Kinect.TrackingState.Tracked)
{
tempSample = new Vector3(body.Joints[Kinect.JointType.HandRight].Position.X,
body.Joints[Kinect.JointType.HandRight].Position.Y,
body.Joints[Kinect.JointType.HandRight].Position.Z);
tempSample = coordinateSystem.ConvertRawKinect2Location(tempSample);
if(Vector3.Distance(tempSample, lastKinect2Sample) > 0.1)
{
sample = tempSample;
lastKinect2Sample = sample;
device1Error = false;
if(!device2Error) this.guiTextUpperLocal = "";
}
else
{
device1Error = true;
this.guiTextUpperLocal = "Not enough hand movement.";
}
}
}
}
}
if(!trackedBodyFound && foundBodies > 1)
{
device1Error = true;
this.guiTextUpperLocal = "Step out of the Kinect's\nview and come back.";
}
}
if(device == RUISDevice.Kinect_1)
{
OpenNI.SkeletonJointPosition jointPosition;
bool success = kinectSelection.GetPlayer(0).GetSkeletonJointPosition(OpenNI.SkeletonJoint.RightHand, out jointPosition);
if(success && jointPosition.Confidence >= 0.5)
{
tempSample = coordinateSystem.ConvertRawKinectLocation(jointPosition.Position);
if(Vector3.Distance(tempSample, lastKinectSample) > 0.1)
{
sample = tempSample;
lastKinectSample = sample;
device2Error = false;
if(!device1Error) this.guiTextUpperLocal = "";
}
else {
device2Error = true;
this.guiTextUpperLocal = "Not enough hand movement.";
}
}
else
{
device2Error = true;
this.guiTextUpperLocal = "Not enough hand movement.";
}
}
return sample;
}
/*
* Convert rotations obtained with a certain device to master coordinate system, apply yaw offset, and apply Kinect pitch correction
*/
public Quaternion ConvertRotation(Quaternion inputRotation, RUISDevice device)
{
Quaternion outputRotation = inputRotation;
if (applyToRootCoordinates && rootDevice != device)
{
string devicePairString = device.ToString() + "-" + rootDevice.ToString();
outputRotation = RUISCalibrationResultsInQuaternion[devicePairString] * outputRotation;
}
// Apply floor pitch rotation (which is identity to anything else than Kinect 1/2)
if (applyToRootCoordinates || device == rootDevice)
outputRotation = RUISCalibrationResultsFloorPitchRotation[rootDevice] * outputRotation;
else
{
if(device == RUISDevice.Kinect_2)
outputRotation = RUISCalibrationResultsFloorPitchRotation[RUISDevice.Kinect_2] * outputRotation;
else if(device == RUISDevice.Kinect_1)
outputRotation = RUISCalibrationResultsFloorPitchRotation[RUISDevice.Kinect_1] * outputRotation;
}
// Apply yaw offset
if (applyToRootCoordinates || device == rootDevice)
outputRotation = Quaternion.Euler(0, yawOffset, 0) * outputRotation;
return outputRotation;
}
// Quaternion kinect1PitchRotation = Quaternion.identity;
public RUISPSMoveToOculusDK2CalibrationProcess(RUISCalibrationProcessSettings calibrationSettings) {
this.inputDevice1 = RUISDevice.Oculus_DK2;
this.inputDevice2 = RUISDevice.PS_Move;
this.numberOfSamplesToTake = calibrationSettings.numberOfSamplesToTake;
this.numberOfSamplesPerSecond = calibrationSettings.numberOfSamplesPerSecond;
psMoveWrapper = MonoBehaviour.FindObjectOfType(typeof(PSMoveWrapper)) as PSMoveWrapper;
inputManager = MonoBehaviour.FindObjectOfType(typeof(RUISInputManager)) as RUISInputManager;
coordinateSystem = MonoBehaviour.FindObjectOfType(typeof(RUISCoordinateSystem)) as RUISCoordinateSystem;
this.timeSinceScriptStart = 0;
this.timeBetweenSamples = 1 / (float)numberOfSamplesPerSecond;
// Limit sample rate
if(this.timeBetweenSamples < 0.1f) {
this.timeBetweenSamples = 0.1f;
}
calibrationSpheres = new List<GameObject>();
samples_PSMove = new List<Vector3>();
samples_OculusDK2 = new List<Vector3>();
this.calibrationCube = calibrationSettings.calibrationCubePrefab;
this.calibrationSphere = calibrationSettings.calibrationSpherePrefab;
this.calibrationPhaseObjects = calibrationSettings.calibrationPhaseObjects;
this.calibrationResultPhaseObjects = calibrationSettings.calibrationResultPhaseObjects;
this.deviceModelObjects = calibrationSettings.deviceModelObjects;
this.depthViewObjects = calibrationSettings.depthViewObjects;
this.iconObjects = calibrationSettings.iconObjects;
this.PSMoveWandObject = GameObject.Find ("PSMoveWand");
this.mannequin = GameObject.Find ("Mannequin");
// Models
this.psEyeModelObject = GameObject.Find ("PS Eye");
this.oculusDK2CameraObject = GameObject.Find ("OculusDK2Camera");
this.oculusRiftModel = GameObject.Find ("OculusRift");
// Icons
this.psMoveIcon = GameObject.Find ("PS Move Icon");
this.oculusDK2Icon = GameObject.Find ("OculusDK2 Icon");
// this.floorPlane = GameObject.Find ("Floor");
foreach (Transform child in this.deviceModelObjects.transform)
{
child.gameObject.SetActive(false);
}
foreach (Transform child in this.depthViewObjects.transform)
{
child.gameObject.SetActive(false);
}
foreach (Transform child in this.iconObjects.transform)
{
child.gameObject.SetActive(false);
}
if(this.mannequin)
this.mannequin.SetActive(false);
if(this.psEyeModelObject)
this.psEyeModelObject.SetActive(true);
if(this.PSMoveWandObject)
this.PSMoveWandObject.SetActive(true);
if(this.oculusRiftModel)
this.oculusRiftModel.SetActive(true);
if(this.oculusDK2CameraObject)
this.oculusDK2CameraObject.SetActive(true);
if(this.psMoveIcon)
this.psMoveIcon.SetActive(true);
if(this.oculusDK2Icon)
this.oculusDK2Icon.SetActive(true);
if(this.calibrationPhaseObjects)
this.calibrationPhaseObjects.SetActive(true);
if(this.calibrationResultPhaseObjects)
this.calibrationResultPhaseObjects.SetActive(false);
this.xmlFilename = calibrationSettings.xmlFilename;
}
void Awake()
{
string[] names = System.Enum.GetNames(typeof(RUISDevice));
foreach (string device in names)
{
RUISDevice device1Enum = (RUISDevice)System.Enum.Parse(typeof(RUISDevice), device, true);
RUISCalibrationResultsFloorPitchRotation[device1Enum] = Quaternion.identity;
RUISCalibrationResultsDistanceFromFloor[device1Enum] = 0.0f;
foreach (string device2 in names)
{
if (device != device2)
{
string devicePairString = device + "-" + device2;
RUISCalibrationResultsInVector3[devicePairString] = new Vector3(0, 0, 0);
RUISCalibrationResultsInQuaternion[devicePairString] = Quaternion.identity;
RUISCalibrationResultsIn4x4Matrix[devicePairString] = Matrix4x4.identity;
}
}
}
if (loadFromXML)
{
if (!LoadMultiXML(coordinateXmlFile))
{
createExampleXML(coordinateXmlFile);
}
}
inputManager = FindObjectOfType <RUISInputManager>();
if (switchToAvailableDevice && inputManager)
{
bool needToSwitch = false;
RUISDevice previousDevice = rootDevice;
switch (rootDevice)
{
case RUISDevice.Kinect_1:
if (!inputManager.enableKinect)
{
needToSwitch = true;
}
break;
case RUISDevice.Kinect_2:
if (!inputManager.enableKinect2)
{
needToSwitch = true;
}
break;
case RUISDevice.PS_Move:
if (!inputManager.enablePSMove)
{
needToSwitch = true;
}
break;
case RUISDevice.OpenVR: // If OpenVR can't accessed AND a HMD can't be detected
if (!RUISDisplayManager.IsOpenVrAccessible() && !RUISDisplayManager.IsHmdPresent())
{
needToSwitch = true;
}
break;
}
if (needToSwitch)
{
// Try to determine if Kinect2 can be used (because this method is run before RUISInputManager can disable enableKinect2)
bool kinect2FoundBySystem = false;
if (inputManager.enableKinect2)
{
try
{
Kinect2SourceManager kinect2SourceManager = FindObjectOfType(typeof(Kinect2SourceManager)) as Kinect2SourceManager;
if (kinect2SourceManager != null && kinect2SourceManager.GetSensor() != null && kinect2SourceManager.GetSensor().IsOpen)
{
// IsOpen seems to return false mostly if Kinect 2 drivers are not installed?
// Debug.Log("Kinect 2 was detected by the system.");
kinect2FoundBySystem = true;
}
}
catch
{}
}
if (RUISDisplayManager.IsHmdPositionTrackable())
{
rootDevice = RUISDevice.OpenVR;
}
else if (inputManager.enableKinect2 && kinect2FoundBySystem)
{
rootDevice = RUISDevice.Kinect_2;
}
else if (inputManager.enableKinect)
{
rootDevice = RUISDevice.Kinect_1;
}
else if (inputManager.enablePSMove)
{
rootDevice = RUISDevice.PS_Move;
}
if (rootDevice != previousDevice)
{
if (previousDevice == RUISDevice.OpenVR)
{
Debug.LogWarning("Switched 'Master Coordinate System Sensor' from " + previousDevice + " to " + rootDevice + " "
+ "because OpenVR could not be accessed! Is SteamVR installed?");
}
else
{
Debug.LogWarning("Switched 'Master Coordinate System Sensor' from " + previousDevice + " to " + rootDevice + " "
+ "because the former was not enabled in " + typeof(RUISInputManager) + " while the latter was!");
}
}
}
}
}
public RUISKinect2ToPSMoveCalibrationProcess(RUISCalibrationProcessSettings calibrationSettings) {
this.inputDevice1 = RUISDevice.Kinect_2;
this.inputDevice2 = RUISDevice.PS_Move;
this.numberOfSamplesToTake = calibrationSettings.numberOfSamplesToTake;
this.numberOfSamplesPerSecond = calibrationSettings.numberOfSamplesPerSecond;
trackingIDs = new trackedBody[6];
for(int y = 0; y < trackingIDs.Length; y++) {
trackingIDs[y] = new trackedBody(-1, false, 1);
}
psMoveWrapper = MonoBehaviour.FindObjectOfType(typeof(PSMoveWrapper)) as PSMoveWrapper;
inputManager = MonoBehaviour.FindObjectOfType(typeof(RUISInputManager)) as RUISInputManager;
coordinateSystem = MonoBehaviour.FindObjectOfType(typeof(RUISCoordinateSystem)) as RUISCoordinateSystem;
kinect2SourceManager = MonoBehaviour.FindObjectOfType(typeof(Kinect2SourceManager)) as Kinect2SourceManager;
this.timeSinceScriptStart = 0;
this.timeBetweenSamples = 1 / (float)numberOfSamplesPerSecond;
// Limit sample rate
if(this.timeBetweenSamples < 0.1f) {
this.timeBetweenSamples = 0.1f;
}
calibrationSpheres = new List<GameObject>();
samples_PSMove = new List<Vector3>();
samples_Kinect2 = new List<Vector3>();
this.calibrationCube = calibrationSettings.calibrationCubePrefab;
this.calibrationSphere = calibrationSettings.calibrationSpherePrefab;
this.calibrationPhaseObjects = calibrationSettings.calibrationPhaseObjects;
this.calibrationResultPhaseObjects = calibrationSettings.calibrationResultPhaseObjects;
this.deviceModelObjects = calibrationSettings.deviceModelObjects;
this.depthViewObjects = calibrationSettings.depthViewObjects;
this.iconObjects = calibrationSettings.iconObjects;
this.PSMoveWandObject = GameObject.Find ("PSMoveWand");
// Models
this.psEyeModelObject = GameObject.Find ("PS Eye");
this.kinect2ModelObject = GameObject.Find ("Kinect2Camera");
// Depth view
this.depthView = GameObject.Find ("Kinect2DepthView");
// Icons
this.psMoveIcon = GameObject.Find ("PS Move Icon");
this.KinectIcon = GameObject.Find ("Kinect2 Icon");
this.floorPlane = GameObject.Find ("Floor");
foreach (Transform child in this.deviceModelObjects.transform)
{
child.gameObject.SetActive(false);
}
foreach (Transform child in this.depthViewObjects.transform)
{
child.gameObject.SetActive(false);
}
foreach (Transform child in this.iconObjects.transform)
{
child.gameObject.SetActive(false);
}
if(this.psEyeModelObject)
this.psEyeModelObject.SetActive(true);
if(this.PSMoveWandObject)
this.PSMoveWandObject.SetActive(true);
if(this.kinect2ModelObject)
this.kinect2ModelObject.SetActive(true);
if(this.psMoveIcon)
this.psMoveIcon.SetActive(true);
if(this.KinectIcon)
this.KinectIcon.SetActive(true);
if(this.calibrationPhaseObjects)
this.calibrationPhaseObjects.SetActive(true);
if(this.calibrationResultPhaseObjects)
this.calibrationResultPhaseObjects.SetActive(false);
if(this.depthView)
this.depthView.SetActive(true);
this.xmlFilename = calibrationSettings.xmlFilename;
}
public RUISKinect2ToPSMoveCalibrationProcess(RUISCalibrationProcessSettings calibrationSettings)
{
this.inputDevice1 = RUISDevice.Kinect_2;
this.inputDevice2 = RUISDevice.PS_Move;
this.numberOfSamplesToTake = calibrationSettings.numberOfSamplesToTake;
this.numberOfSamplesPerSecond = calibrationSettings.numberOfSamplesPerSecond;
trackingIDs = new trackedBody[6];
for(int y = 0; y < trackingIDs.Length; y++) {
trackingIDs[y] = new trackedBody(-1, false, 1);
}
psMoveWrapper = MonoBehaviour.FindObjectOfType(typeof(PSMoveWrapper)) as PSMoveWrapper;
inputManager = MonoBehaviour.FindObjectOfType(typeof(RUISInputManager)) as RUISInputManager;
coordinateSystem = MonoBehaviour.FindObjectOfType(typeof(RUISCoordinateSystem)) as RUISCoordinateSystem;
kinect2SourceManager = MonoBehaviour.FindObjectOfType(typeof(Kinect2SourceManager)) as Kinect2SourceManager;
this.timeSinceScriptStart = 0;
this.timeBetweenSamples = 1 / (float)numberOfSamplesPerSecond;
// Limit sample rate
if(this.timeBetweenSamples < 0.1f) {
this.timeBetweenSamples = 0.1f;
}
calibrationSpheres = new List<GameObject>();
samples_PSMove = new List<Vector3>();
samples_Kinect2 = new List<Vector3>();
this.calibrationCube = calibrationSettings.calibrationCubePrefab;
this.calibrationSphere = calibrationSettings.calibrationSpherePrefab;
this.calibrationPhaseObjects = calibrationSettings.calibrationPhaseObjects;
this.calibrationResultPhaseObjects = calibrationSettings.calibrationResultPhaseObjects;
this.deviceModelObjects = calibrationSettings.deviceModelObjects;
this.depthViewObjects = calibrationSettings.depthViewObjects;
this.iconObjects = calibrationSettings.iconObjects;
this.PSMoveWandObject = GameObject.Find ("PSMoveWand");
// Models
this.psEyeModelObject = GameObject.Find ("PS Eye");
this.kinect2ModelObject = GameObject.Find ("Kinect2Camera");
// Depth view
this.depthView = GameObject.Find ("Kinect2DepthView");
// Icons
this.psMoveIcon = GameObject.Find ("PS Move Icon");
this.KinectIcon = GameObject.Find ("Kinect2 Icon");
this.floorPlane = GameObject.Find ("Floor");
foreach (Transform child in this.deviceModelObjects.transform)
{
child.gameObject.SetActive(false);
}
foreach (Transform child in this.depthViewObjects.transform)
{
child.gameObject.SetActive(false);
}
foreach (Transform child in this.iconObjects.transform)
{
child.gameObject.SetActive(false);
}
if(this.psEyeModelObject)
this.psEyeModelObject.SetActive(true);
if(this.PSMoveWandObject)
this.PSMoveWandObject.SetActive(true);
if(this.kinect2ModelObject)
this.kinect2ModelObject.SetActive(true);
if(this.psMoveIcon)
this.psMoveIcon.SetActive(true);
if(this.KinectIcon)
this.KinectIcon.SetActive(true);
if(this.calibrationPhaseObjects)
this.calibrationPhaseObjects.SetActive(true);
if(this.calibrationResultPhaseObjects)
this.calibrationResultPhaseObjects.SetActive(false);
if(this.depthView)
this.depthView.SetActive(true);
this.xmlFilename = calibrationSettings.xmlFilename;
}
public void SaveFloorData(string filename, RUISDevice device, Vector3 normal, float distance)
{
string wrapperElementName = device.ToString();
XmlNode calibrationMatrixElement;
XmlDocument xmlDoc = XMLUtil.LoadAndValidateXml(filename, coordinateSchema);
XmlNode groupElement;
if(xmlDoc != null) {
calibrationMatrixElement = xmlDoc.DocumentElement;
groupElement = calibrationMatrixElement.SelectSingleNode("FloorData");
if(groupElement == null) groupElement = xmlDoc.CreateElement("FloorData");
}
else {
xmlDoc = new XmlDocument();
xmlDoc.CreateXmlDeclaration("1.0", "UTF-8", "yes");
calibrationMatrixElement = xmlDoc.CreateElement("ns2", "RUISClibrationMatrix", "http://ruisystem.net/m2k");
xmlDoc.AppendChild(calibrationMatrixElement);
groupElement = xmlDoc.CreateElement("FloorData");
}
calibrationMatrixElement.AppendChild(groupElement);
XmlElement wrapperElement = xmlDoc.CreateElement(wrapperElementName);
groupElement.AppendChild(wrapperElement);
XmlElement kinectFloorNormalElement = xmlDoc.CreateElement("floorNormal");
kinectFloorNormalElement.SetAttribute("x", normal.x.ToString());
kinectFloorNormalElement.SetAttribute("y", normal.y.ToString());
kinectFloorNormalElement.SetAttribute("z", normal.z.ToString());
wrapperElement.AppendChild(kinectFloorNormalElement);
XmlElement kinectDistanceFromFloorElement = xmlDoc.CreateElement("distanceFromFloor");
kinectDistanceFromFloorElement.SetAttribute("value", distance.ToString());
wrapperElement.AppendChild(kinectDistanceFromFloorElement);
XmlNode groupNode = xmlDoc.DocumentElement.SelectSingleNode("FloorData");
XmlNode testNode = groupNode.SelectSingleNode(wrapperElementName);
// Element not found
if(testNode == null) {
groupNode.AppendChild(wrapperElement);
}
else {// Element already exists
var oldElem = testNode;
groupNode.ReplaceChild(wrapperElement, oldElem);
}
FileStream xmlFileStream = File.Open(filename, FileMode.Create);
StreamWriter streamWriter = new StreamWriter(xmlFileStream);
xmlDoc.Save(streamWriter);
streamWriter.Flush();
streamWriter.Close();
xmlFileStream.Close();
}
private Vector3 getSample(RUISDevice device)
{
Vector3 sample = new Vector3(0,0,0);
Vector3 tempSample;
updateBodyData();
if(device == RUISDevice.Kinect_2)
{
Kinect.Body[] data = kinect2SourceManager.GetBodyData();
bool trackedBodyFound = false;
int foundBodies = 0;
foreach(var body in data)
{
foundBodies++;
if(body.IsTracked)
{
if(trackingIDtoIndex[body.TrackingId] == 0)
{
trackedBodyFound = true;
if(body.Joints[Kinect.JointType.HandRight].TrackingState == Kinect.TrackingState.Tracked)
{
tempSample = new Vector3(body.Joints[Kinect.JointType.HandRight].Position.X,
body.Joints[Kinect.JointType.HandRight].Position.Y,
body.Joints[Kinect.JointType.HandRight].Position.Z);
tempSample = coordinateSystem.ConvertRawKinect2Location(tempSample);
if(Vector3.Distance(tempSample, lastKinect2Sample) > 0.1)
{
sample = tempSample;
lastKinect2Sample = sample;
device1Error = false;
if(!device2Error) this.guiTextUpperLocal = "";
}
else
{
device1Error = true;
this.guiTextUpperLocal = "Not enough hand movement.";
}
}
}
}
}
if(!trackedBodyFound && foundBodies > 1)
{
device1Error = true;
this.guiTextUpperLocal = "Step out of the Kinect's\nview and come back.";
}
}
if(device == RUISDevice.Oculus_DK2)
{
Ovr.Posef headpose = RUISOVRManager.ovrHmd.GetTrackingState().HeadPose.ThePose;
float px = headpose.Position.x;
float py = headpose.Position.y;
float pz = -headpose.Position.z; // This needs to be negated TODO: might change with future OVR version
tempSample = new Vector3(px, py, pz);
tempSample = coordinateSystem.ConvertRawOculusDK2Location(tempSample);
if( (Vector3.Distance(tempSample, lastOculusDK2Sample) > 0.1)
&& (RUISOVRManager.ovrHmd.GetTrackingState().StatusFlags & (uint)StatusBits.PositionTracked) != 0) // Code from OVRManager.cs
{
sample = tempSample;
lastOculusDK2Sample = sample;
device2Error = false;
if(!device1Error) this.guiTextUpperLocal = "";
}
else
{
device2Error = true;
this.guiTextUpperLocal = "Not enough hand movement.";
}
}
return sample;
}
private Vector3 getSample(RUISDevice device)
{
Vector3 sample = new Vector3(0,0,0);
Vector3 tempSample;
updateBodyData();
if(device == RUISDevice.Kinect_2)
{
Kinect.Body[] data = kinect2SourceManager.GetBodyData();
bool trackedBodyFound = false;
int foundBodies = 0;
foreach(var body in data)
{
foundBodies++;
if(body.IsTracked)
{
if(trackingIDtoIndex[body.TrackingId] == 0)
{
trackedBodyFound = true;
if(body.Joints[Kinect.JointType.HandRight].TrackingState == Kinect.TrackingState.Tracked)
{
tempSample = new Vector3(body.Joints[Kinect.JointType.HandRight].Position.X,
body.Joints[Kinect.JointType.HandRight].Position.Y,
body.Joints[Kinect.JointType.HandRight].Position.Z);
tempSample = coordinateSystem.ConvertRawKinect2Location(tempSample);
if(Vector3.Distance(tempSample, lastKinect2Sample) > 0.1)
{
sample = tempSample;
lastKinect2Sample = sample;
device1Error = false;
if(!device2Error) this.guiTextUpperLocal = "";
}
else
{
device1Error = true;
this.guiTextUpperLocal = "Not enough hand movement.";
}
}
}
}
}
if(!trackedBodyFound && foundBodies > 1)
{
device1Error = true;
this.guiTextUpperLocal = "Step out of the Kinect's\nview and come back.";
}
}
if(device == RUISDevice.PS_Move)
{
if(psMoveWrapper.sphereVisible[calibratingPSMoveControllerId] &&
psMoveWrapper.handleVelocity[calibratingPSMoveControllerId].magnitude <= 10.0f)
{
tempSample = coordinateSystem.ConvertRawPSMoveLocation(psMoveWrapper.handlePosition[calibratingPSMoveControllerId]);
if(Vector3.Distance(tempSample, lastPSMoveSample) > 0.1)
{
sample = tempSample;
lastPSMoveSample = sample;
device2Error = false;
if(!device1Error) this.guiTextUpperLocal = "";
}
else {
device2Error = true;
this.guiTextUpperLocal = "Not enough hand movement.";
}
}
}
return sample;
}
private Vector3 getSample(RUISDevice device)
{
Vector3 sample = new Vector3(0,0,0);
Vector3 tempSample;
if(device == RUISDevice.Kinect_1) {
OpenNI.SkeletonJointPosition jointPosition;
bool success = kinectSelection.GetPlayer(0).GetSkeletonJointPosition(OpenNI.SkeletonJoint.RightHand, out jointPosition);
if(success && jointPosition.Confidence >= 0.5) {
tempSample = coordinateSystem.ConvertRawKinectLocation(jointPosition.Position);
if(Vector3.Distance(tempSample, lastKinectSample) > 0.1) {
sample = tempSample;
lastKinectSample = sample;
this.guiTextUpperLocal = "";
}
else {
this.guiTextUpperLocal = "Not enough hand movement.";
}
}
}
if(device == RUISDevice.Oculus_DK2)
{
Ovr.Posef headpose = RUISOVRManager.ovrHmd.GetTrackingState().HeadPose.ThePose;
float px = headpose.Position.x;
float py = headpose.Position.y;
float pz = -headpose.Position.z; // This needs to be negated TODO: might change with future OVR version
tempSample = new Vector3(px, py, pz);
tempSample = coordinateSystem.ConvertRawOculusDK2Location(tempSample);
if( (Vector3.Distance(tempSample, lastOculusDK2Sample) > 0.1)
&& (RUISOVRManager.ovrHmd.GetTrackingState().StatusFlags & (uint)StatusBits.PositionTracked) != 0) // Code from OVRManager.cs
{
sample = tempSample;
lastOculusDK2Sample = sample;
this.guiTextUpperLocal = "";
}
else {
this.guiTextUpperLocal = "Not enough hand movement.";
}
}
return sample;
}
public void ResetDistanceFromFloor(RUISDevice floorDetectingDevice)
{
RUISCalibrationResultsDistanceFromFloor[floorDetectingDevice] = 0;
}
void Awake () {
Cursor.visible = true; // Incase cursor was hidden in previous scene
// Check if calibration settings were chosen on previous scene
ruisNGUIMenu = FindObjectOfType(typeof(RUISMenuNGUI)) as RUISMenuNGUI;
if(ruisNGUIMenu != null)
{
if(ruisNGUIMenu.currentMenuState == RUISMenuNGUI.RUISMenuStates.calibration)
{
numberOfSamplesToTake = 50;
samplesPerSecond = 5;
switch(ruisNGUIMenu.calibrationDropDownSelection)
{
case "Kinect - Kinect2":
firstDevice = RUISDevice.Kinect_1;
secondDevice = RUISDevice.Kinect_2;
break;
case "Kinect - PSMove":
firstDevice = RUISDevice.Kinect_1;
secondDevice = RUISDevice.PS_Move;
break;
case "Kinect 2 - PSMove":
firstDevice = RUISDevice.Kinect_2;
secondDevice = RUISDevice.PS_Move;
break;
case "Kinect 2 - Oculus DK2":
firstDevice = RUISDevice.Kinect_2;
secondDevice = RUISDevice.Oculus_DK2;
break;
case "Kinect - Oculus DK2":
firstDevice = RUISDevice.Kinect_1;
secondDevice = RUISDevice.Oculus_DK2;
break;
case "PSMove - Oculus DK2":
firstDevice = RUISDevice.PS_Move;
secondDevice = RUISDevice.Oculus_DK2;
break;
case "Kinect floor data":
firstDevice = RUISDevice.Kinect_1;
secondDevice = RUISDevice.Kinect_1;
break;
case "Kinect 2 floor data":
firstDevice = RUISDevice.Kinect_2;
secondDevice = RUISDevice.Kinect_2;
break;
default:
firstDevice = RUISDevice.Null;
secondDevice = RUISDevice.Null;
break;
}
}
}
// Init scene objects
this.floorPlane = GameObject.Find ("Floor");
this.calibrationPhaseObjects = GameObject.Find("CalibrationPhase");
this.calibrationResultPhaseObjects = GameObject.Find("ResultPhase");
this.depthViews = GameObject.Find ("Depth views");
this.deviceModels = GameObject.Find ("Device models");
this.icons = GameObject.Find ("Icons");
upperText = GameObject.Find ("Upper Text").GetComponent<GUIText>();
lowerText = GameObject.Find ("Lower Text").GetComponent<GUIText>();
skeletonController = FindObjectOfType(typeof(RUISSkeletonController)) as RUISSkeletonController;
coordinateSystem = FindObjectOfType(typeof(RUISCoordinateSystem)) as RUISCoordinateSystem;
// Pass variables and objects to calibrationProcess
calibrationProcessSettings = new RUISCalibrationProcessSettings();
calibrationProcessSettings.xmlFilename = xmlFilename;
calibrationProcessSettings.numberOfSamplesToTake = numberOfSamplesToTake;
calibrationProcessSettings.numberOfSamplesPerSecond = samplesPerSecond;
calibrationProcessSettings.calibrationCubePrefab = this.sampleCube;
calibrationProcessSettings.calibrationSpherePrefab = this.sampleSphere;
calibrationProcessSettings.calibrationPhaseObjects = this.calibrationPhaseObjects;
calibrationProcessSettings.calibrationResultPhaseObjects = this.calibrationResultPhaseObjects;
calibrationProcessSettings.deviceModelObjects = deviceModels;
calibrationProcessSettings.depthViewObjects = depthViews;
calibrationProcessSettings.iconObjects = icons;
}
public void SaveTransformDataToXML(string filename, RUISDevice device1, RUISDevice device2)
{
string wrapperElementName = device1.ToString() + "-" + device2.ToString();
XmlNode calibrationMatrixElement;
XmlDocument xmlDoc = XMLUtil.LoadAndValidateXml(filename, coordinateSchema);
XmlNode groupElement;
if (xmlDoc != null)
{
calibrationMatrixElement = xmlDoc.DocumentElement;
groupElement = calibrationMatrixElement.SelectSingleNode("Transforms");
if (groupElement == null)
{
groupElement = xmlDoc.CreateElement("Transforms");
}
}
else
{
xmlDoc = new XmlDocument();
xmlDoc.CreateXmlDeclaration("1.0", "UTF-8", "yes");
calibrationMatrixElement = xmlDoc.CreateElement("ns2", "RUISClibrationMatrix", "http://ruisystem.net/m2k");
xmlDoc.AppendChild(calibrationMatrixElement);
groupElement = xmlDoc.CreateElement("Transforms");
}
calibrationMatrixElement.AppendChild(groupElement);
XmlElement wrapperElement = xmlDoc.CreateElement(wrapperElementName);
groupElement.AppendChild(wrapperElement);
XmlElement translateElement = xmlDoc.CreateElement("translate");
translateElement.SetAttribute("x", deviceToRootTransform[0, 3].ToString());
translateElement.SetAttribute("y", deviceToRootTransform[1, 3].ToString());
translateElement.SetAttribute("z", deviceToRootTransform[2, 3].ToString());
wrapperElement.AppendChild(translateElement);
XmlElement rotateElement = xmlDoc.CreateElement("rotate");
rotateElement.SetAttribute("r00", deviceToRootTransform[0, 0].ToString());
rotateElement.SetAttribute("r01", deviceToRootTransform[0, 1].ToString());
rotateElement.SetAttribute("r02", deviceToRootTransform[0, 2].ToString());
rotateElement.SetAttribute("r10", deviceToRootTransform[1, 0].ToString());
rotateElement.SetAttribute("r11", deviceToRootTransform[1, 1].ToString());
rotateElement.SetAttribute("r12", deviceToRootTransform[1, 2].ToString());
rotateElement.SetAttribute("r20", deviceToRootTransform[2, 0].ToString());
rotateElement.SetAttribute("r21", deviceToRootTransform[2, 1].ToString());
rotateElement.SetAttribute("r22", deviceToRootTransform[2, 2].ToString());
wrapperElement.AppendChild(rotateElement);
XmlNode groupNode = xmlDoc.DocumentElement.SelectSingleNode("Transforms");
XmlNode testNode = groupNode.SelectSingleNode(wrapperElementName);
// Element not found
if (testNode == null)
{
groupNode.AppendChild(wrapperElement);
}
else
{
// Element already exists
var oldElem = testNode;
groupNode.ReplaceChild(wrapperElement, oldElem);
}
FileStream xmlFileStream = File.Open(filename, FileMode.Create);
StreamWriter streamWriter = new StreamWriter(xmlFileStream);
xmlDoc.Save(streamWriter);
streamWriter.Flush();
streamWriter.Close();
xmlFileStream.Close();
}
public void ResetFloorNormal(RUISDevice floorDetectingDevice)
{
RUISCalibrationResultsFloorPitchRotation[floorDetectingDevice] = Quaternion.identity;
}
public void SaveFloorData(string filename, RUISDevice device, Vector3 normal, float distance)
{
string wrapperElementName = device.ToString();
XmlNode calibrationMatrixElement;
XmlDocument xmlDoc = XMLUtil.LoadAndValidateXml(filename, coordinateSchema);
XmlNode groupElement;
if (xmlDoc != null)
{
calibrationMatrixElement = xmlDoc.DocumentElement;
groupElement = calibrationMatrixElement.SelectSingleNode("FloorData");
if (groupElement == null)
{
groupElement = xmlDoc.CreateElement("FloorData");
}
}
else
{
xmlDoc = new XmlDocument();
xmlDoc.CreateXmlDeclaration("1.0", "UTF-8", "yes");
calibrationMatrixElement = xmlDoc.CreateElement("ns2", "RUISClibrationMatrix", "http://ruisystem.net/m2k");
xmlDoc.AppendChild(calibrationMatrixElement);
groupElement = xmlDoc.CreateElement("FloorData");
}
calibrationMatrixElement.AppendChild(groupElement);
XmlElement wrapperElement = xmlDoc.CreateElement(wrapperElementName);
groupElement.AppendChild(wrapperElement);
XmlElement kinectFloorNormalElement = xmlDoc.CreateElement("floorNormal");
kinectFloorNormalElement.SetAttribute("x", normal.x.ToString());
kinectFloorNormalElement.SetAttribute("y", normal.y.ToString());
kinectFloorNormalElement.SetAttribute("z", normal.z.ToString());
wrapperElement.AppendChild(kinectFloorNormalElement);
XmlElement kinectDistanceFromFloorElement = xmlDoc.CreateElement("distanceFromFloor");
kinectDistanceFromFloorElement.SetAttribute("value", distance.ToString());
wrapperElement.AppendChild(kinectDistanceFromFloorElement);
XmlNode groupNode = xmlDoc.DocumentElement.SelectSingleNode("FloorData");
XmlNode testNode = groupNode.SelectSingleNode(wrapperElementName);
// Element not found
if (testNode == null)
{
groupNode.AppendChild(wrapperElement);
}
else
{
// Element already exists
var oldElem = testNode;
groupNode.ReplaceChild(wrapperElement, oldElem);
}
FileStream xmlFileStream = File.Open(filename, FileMode.Create);
StreamWriter streamWriter = new StreamWriter(xmlFileStream);
xmlDoc.Save(streamWriter);
streamWriter.Flush();
streamWriter.Close();
xmlFileStream.Close();
}
public void ResetDistanceFromFloor(RUISDevice floorDetectingDevice)
{
RUISCalibrationResultsDistanceFromFloor[floorDetectingDevice] = 0;
}
// Quaternion kinect1PitchRotation = Quaternion.identity;
public RUISPSMoveToOculusDK2CalibrationProcess(RUISCalibrationProcessSettings calibrationSettings)
{
this.inputDevice1 = RUISDevice.Oculus_DK2;
this.inputDevice2 = RUISDevice.PS_Move;
this.numberOfSamplesToTake = calibrationSettings.numberOfSamplesToTake;
this.numberOfSamplesPerSecond = calibrationSettings.numberOfSamplesPerSecond;
psMoveWrapper = MonoBehaviour.FindObjectOfType(typeof(PSMoveWrapper)) as PSMoveWrapper;
inputManager = MonoBehaviour.FindObjectOfType(typeof(RUISInputManager)) as RUISInputManager;
coordinateSystem = MonoBehaviour.FindObjectOfType(typeof(RUISCoordinateSystem)) as RUISCoordinateSystem;
this.timeSinceScriptStart = 0;
this.timeBetweenSamples = 1 / (float)numberOfSamplesPerSecond;
// Limit sample rate
if (this.timeBetweenSamples < 0.1f)
{
this.timeBetweenSamples = 0.1f;
}
calibrationSpheres = new List <GameObject>();
samples_PSMove = new List <Vector3>();
samples_OculusDK2 = new List <Vector3>();
this.calibrationCube = calibrationSettings.calibrationCubePrefab;
this.calibrationSphere = calibrationSettings.calibrationSpherePrefab;
this.calibrationPhaseObjects = calibrationSettings.calibrationPhaseObjects;
this.calibrationResultPhaseObjects = calibrationSettings.calibrationResultPhaseObjects;
this.deviceModelObjects = calibrationSettings.deviceModelObjects;
this.depthViewObjects = calibrationSettings.depthViewObjects;
this.iconObjects = calibrationSettings.iconObjects;
this.PSMoveWandObject = GameObject.Find("PSMoveWand");
this.mannequin = GameObject.Find("Mannequin");
// Models
this.psEyeModelObject = GameObject.Find("PS Eye");
this.oculusDK2CameraObject = GameObject.Find("OculusDK2Camera");
this.oculusRiftModel = GameObject.Find("OculusRift");
// Icons
this.psMoveIcon = GameObject.Find("PS Move Icon");
this.oculusDK2Icon = GameObject.Find("OculusDK2 Icon");
// this.floorPlane = GameObject.Find ("Floor");
foreach (Transform child in this.deviceModelObjects.transform)
{
child.gameObject.SetActive(false);
}
foreach (Transform child in this.depthViewObjects.transform)
{
child.gameObject.SetActive(false);
}
foreach (Transform child in this.iconObjects.transform)
{
child.gameObject.SetActive(false);
}
if (this.mannequin)
{
this.mannequin.SetActive(false);
}
if (this.psEyeModelObject)
{
this.psEyeModelObject.SetActive(true);
}
if (this.PSMoveWandObject)
{
this.PSMoveWandObject.SetActive(true);
}
if (this.oculusRiftModel)
{
this.oculusRiftModel.SetActive(true);
}
if (this.oculusDK2CameraObject)
{
this.oculusDK2CameraObject.SetActive(true);
}
if (this.psMoveIcon)
{
this.psMoveIcon.SetActive(true);
}
if (this.oculusDK2Icon)
{
this.oculusDK2Icon.SetActive(true);
}
if (this.calibrationPhaseObjects)
{
this.calibrationPhaseObjects.SetActive(true);
}
if (this.calibrationResultPhaseObjects)
{
this.calibrationResultPhaseObjects.SetActive(false);
}
this.xmlFilename = calibrationSettings.xmlFilename;
}
private Vector3 getSample(RUISDevice device) {
Vector3 sample = new Vector3(0,0,0);
Vector3 tempSample;
updateBodyData();
if(device == RUISDevice.Kinect_2)
{
Kinect.Body[] data = kinect2SourceManager.GetBodyData();
bool trackedBodyFound = false;
int foundBodies = 0;
foreach(var body in data)
{
foundBodies++;
if(body.IsTracked)
{
if(trackingIDtoIndex[body.TrackingId] == 0)
{
trackedBodyFound = true;
if(body.Joints[Kinect.JointType.HandRight].TrackingState == Kinect.TrackingState.Tracked)
{
tempSample = new Vector3(body.Joints[Kinect.JointType.HandRight].Position.X,
body.Joints[Kinect.JointType.HandRight].Position.Y,
body.Joints[Kinect.JointType.HandRight].Position.Z);
tempSample = coordinateSystem.ConvertRawKinect2Location(tempSample);
if(Vector3.Distance(tempSample, lastKinect2Sample) > 0.1)
{
sample = tempSample;
lastKinect2Sample = sample;
device1Error = false;
if(!device2Error) this.guiTextUpperLocal = "";
}
else
{
device1Error = true;
this.guiTextUpperLocal = "Not enough hand movement.";
}
}
}
}
}
if(!trackedBodyFound && foundBodies > 1)
{
device1Error = true;
this.guiTextUpperLocal = "Step out of the Kinect's\nview and come back.";
}
}
if(device == RUISDevice.PS_Move)
{
if(psMoveWrapper.sphereVisible[calibratingPSMoveControllerId] &&
psMoveWrapper.handleVelocity[calibratingPSMoveControllerId].magnitude <= 10.0f)
{
tempSample = coordinateSystem.ConvertRawPSMoveLocation(psMoveWrapper.handlePosition[calibratingPSMoveControllerId]);
if(Vector3.Distance(tempSample, lastPSMoveSample) > 0.1)
{
sample = tempSample;
lastPSMoveSample = sample;
device2Error = false;
if(!device1Error) this.guiTextUpperLocal = "";
}
else {
device2Error = true;
this.guiTextUpperLocal = "Not enough hand movement.";
}
}
}
return sample;
}
public void SetDistanceFromFloor(float distance, RUISDevice floorDetectingDevice)
{
switch(floorDetectingDevice)
{
case RUISDevice.Kinect_1:
RUISCalibrationResultsDistanceFromFloor[RUISDevice.Kinect_1] = distance;
break;
case RUISDevice.Kinect_2:
RUISCalibrationResultsDistanceFromFloor[RUISDevice.Kinect_2] = distance;
break;
default:
Debug.LogWarning("Currently floor distance detection with " + floorDetectingDevice.ToString() + " is not supported!");
break;
}
}
public void ResetFloorNormal(RUISDevice floorDetectingDevice)
{
RUISCalibrationResultsFloorPitchRotation[floorDetectingDevice] = Quaternion.identity;
}
void Awake()
{
string[] names = System.Enum.GetNames( typeof( RUISDevice ) );
foreach(string device in names) {
RUISDevice device1Enum = (RUISDevice) System.Enum.Parse( typeof(RUISDevice), device, true );
RUISCalibrationResultsFloorPitchRotation[device1Enum] = Quaternion.identity;
RUISCalibrationResultsDistanceFromFloor[device1Enum] = 0.0f;
foreach(string device2 in names) {
if(device != device2) {
string devicePairString = device + "-" + device2;
RUISCalibrationResultsInVector3[devicePairString] = new Vector3(0,0,0);
RUISCalibrationResultsInQuaternion[devicePairString] = Quaternion.identity;
RUISCalibrationResultsIn4x4Matrix[devicePairString] = Matrix4x4.identity;
}
}
}
if (loadFromXML)
{
if(!LoadMultiXML(coordinateXmlFile)) {
createExampleXML(coordinateXmlFile);
}
}
inputManager = FindObjectOfType<RUISInputManager>();
if(switchToAvailableDevice && inputManager)
{
bool needToSwitch = false;
RUISDevice previousDevice = rootDevice;
switch(rootDevice)
{
case RUISDevice.Kinect_1:
if(!inputManager.enableKinect)
needToSwitch = true;
break;
case RUISDevice.Kinect_2:
if(!inputManager.enableKinect2)
needToSwitch = true;
break;
case RUISDevice.PS_Move:
if(!inputManager.enablePSMove)
needToSwitch = true;
break;
case RUISDevice.Oculus_DK2:
if(!isPositionTrackableRiftPresent())
needToSwitch = true;
break;
}
if(needToSwitch)
{
if(inputManager.enableKinect2)
rootDevice = RUISDevice.Kinect_2;
else if(inputManager.enableKinect)
rootDevice = RUISDevice.Kinect_1;
else if(isPositionTrackableRiftPresent())
rootDevice = RUISDevice.Oculus_DK2;
else if(inputManager.enablePSMove)
rootDevice = RUISDevice.PS_Move;
if(rootDevice != previousDevice)
{
if(previousDevice == RUISDevice.Oculus_DK2)
Debug.LogWarning( "Switched 'Master Coordinate System Sensor' from " + previousDevice + " to " + rootDevice + " "
+ "because Oculus Rift DK2+ was not detected!");
else
Debug.LogWarning( "Switched 'Master Coordinate System Sensor' from " + previousDevice + " to " + rootDevice + " "
+ "because the former was not enabled in " + typeof(RUISInputManager) + " while the latter was!");
}
}
}
}
/*
* Convert locations obtained with a certain device to master coordinate system, apply position offset, and set Kinect origin to floor if applicable
*/
public Vector3 ConvertLocation(Vector3 inputLocation, RUISDevice device)
{
Vector3 outputLocation = inputLocation;
// Transform location into master coordinate system
if (applyToRootCoordinates && rootDevice != device)
{
string devicePairString = device.ToString() + "-" + rootDevice.ToString();
outputLocation = RUISCalibrationResultsIn4x4Matrix[devicePairString].MultiplyPoint3x4(outputLocation);
}
// Apply yaw offset and floor pitch rotation (which is identity to anything else than Kinect 1/2)
if (applyToRootCoordinates || device == rootDevice)
outputLocation = Quaternion.Euler(0, yawOffset, 0) * RUISCalibrationResultsFloorPitchRotation[rootDevice] * outputLocation;
else
{
if(device == RUISDevice.Kinect_2)
outputLocation = RUISCalibrationResultsFloorPitchRotation[RUISDevice.Kinect_2] * outputLocation;
else if(device == RUISDevice.Kinect_1)
outputLocation = RUISCalibrationResultsFloorPitchRotation[RUISDevice.Kinect_1] * outputLocation;
}
// Set Kinect 1/2 origin to floor
if (setKinectOriginToFloor)
{
if (applyToRootCoordinates || device == rootDevice)
outputLocation.y += RUISCalibrationResultsDistanceFromFloor[rootDevice];
else
{
if(device == RUISDevice.Kinect_2)
outputLocation.y += RUISCalibrationResultsDistanceFromFloor[RUISDevice.Kinect_2];
else if(device == RUISDevice.Kinect_1)
outputLocation.y += RUISCalibrationResultsDistanceFromFloor[RUISDevice.Kinect_1];
}
}
// Position offset
if (applyToRootCoordinates || device == rootDevice)
outputLocation += positionOffset;
return outputLocation;
}
public void SaveTransformDataToXML(string filename, RUISDevice device1, RUISDevice device2)
{
string wrapperElementName = device1.ToString() + "-" + device2.ToString();
XmlNode calibrationMatrixElement;
XmlDocument xmlDoc = XMLUtil.LoadAndValidateXml(filename, coordinateSchema);
XmlNode groupElement;
if(xmlDoc != null) {
calibrationMatrixElement = xmlDoc.DocumentElement;
groupElement = calibrationMatrixElement.SelectSingleNode("Transforms");
if(groupElement == null) groupElement = xmlDoc.CreateElement("Transforms");
}
else {
xmlDoc = new XmlDocument();
xmlDoc.CreateXmlDeclaration("1.0", "UTF-8", "yes");
calibrationMatrixElement = xmlDoc.CreateElement("ns2", "RUISClibrationMatrix", "http://ruisystem.net/m2k");
xmlDoc.AppendChild(calibrationMatrixElement);
groupElement = xmlDoc.CreateElement("Transforms");
}
calibrationMatrixElement.AppendChild(groupElement);
XmlElement wrapperElement = xmlDoc.CreateElement(wrapperElementName);
groupElement.AppendChild(wrapperElement);
XmlElement translateElement = xmlDoc.CreateElement("translate");
translateElement.SetAttribute("x", deviceToRootTransform[0, 3].ToString());
translateElement.SetAttribute("y", deviceToRootTransform[1, 3].ToString());
translateElement.SetAttribute("z", deviceToRootTransform[2, 3].ToString());
wrapperElement.AppendChild(translateElement);
XmlElement rotateElement = xmlDoc.CreateElement("rotate");
rotateElement.SetAttribute("r00", deviceToRootTransform[0, 0].ToString());
rotateElement.SetAttribute("r01", deviceToRootTransform[0, 1].ToString());
rotateElement.SetAttribute("r02", deviceToRootTransform[0, 2].ToString());
rotateElement.SetAttribute("r10", deviceToRootTransform[1, 0].ToString());
rotateElement.SetAttribute("r11", deviceToRootTransform[1, 1].ToString());
rotateElement.SetAttribute("r12", deviceToRootTransform[1, 2].ToString());
rotateElement.SetAttribute("r20", deviceToRootTransform[2, 0].ToString());
rotateElement.SetAttribute("r21", deviceToRootTransform[2, 1].ToString());
rotateElement.SetAttribute("r22", deviceToRootTransform[2, 2].ToString());
wrapperElement.AppendChild(rotateElement);
XmlNode groupNode = xmlDoc.DocumentElement.SelectSingleNode("Transforms");
XmlNode testNode = groupNode.SelectSingleNode(wrapperElementName);
// Element not found
if(testNode == null) {
groupNode.AppendChild(wrapperElement);
}
else {// Element already exists
var oldElem = testNode;
groupNode.ReplaceChild(wrapperElement, oldElem);
}
FileStream xmlFileStream = File.Open(filename, FileMode.Create);
StreamWriter streamWriter = new StreamWriter(xmlFileStream);
xmlDoc.Save(streamWriter);
streamWriter.Flush();
streamWriter.Close();
xmlFileStream.Close();
}
void Awake()
{
Cursor.visible = true; // Incase cursor was hidden in previous scene
// Check if calibration settings were chosen on previous scene
ruisNGUIMenu = FindObjectOfType(typeof(RUISMenuNGUI)) as RUISMenuNGUI;
if (ruisNGUIMenu != null)
{
if (ruisNGUIMenu.currentMenuState == RUISMenuNGUI.RUISMenuStates.calibration)
{
numberOfSamplesToTake = 50;
samplesPerSecond = 5;
switch (ruisNGUIMenu.calibrationDropDownSelection)
{
case "Kinect - Kinect2":
firstDevice = RUISDevice.Kinect_1;
secondDevice = RUISDevice.Kinect_2;
break;
case "Kinect - PSMove":
firstDevice = RUISDevice.Kinect_1;
secondDevice = RUISDevice.PS_Move;
break;
case "Kinect 2 - PSMove":
firstDevice = RUISDevice.Kinect_2;
secondDevice = RUISDevice.PS_Move;
break;
case "Kinect 2 - Oculus DK2":
firstDevice = RUISDevice.Kinect_2;
secondDevice = RUISDevice.Oculus_DK2;
break;
case "Kinect - Oculus DK2":
firstDevice = RUISDevice.Kinect_1;
secondDevice = RUISDevice.Oculus_DK2;
break;
case "PSMove - Oculus DK2":
firstDevice = RUISDevice.PS_Move;
secondDevice = RUISDevice.Oculus_DK2;
break;
case "Kinect floor data":
firstDevice = RUISDevice.Kinect_1;
secondDevice = RUISDevice.Kinect_1;
break;
case "Kinect 2 floor data":
firstDevice = RUISDevice.Kinect_2;
secondDevice = RUISDevice.Kinect_2;
break;
default:
firstDevice = RUISDevice.Null;
secondDevice = RUISDevice.Null;
break;
}
}
}
// Init scene objects
this.floorPlane = GameObject.Find("Floor");
this.calibrationPhaseObjects = GameObject.Find("CalibrationPhase");
this.calibrationResultPhaseObjects = GameObject.Find("ResultPhase");
this.depthViews = GameObject.Find("Depth views");
this.deviceModels = GameObject.Find("Device models");
this.icons = GameObject.Find("Icons");
upperText = GameObject.Find("Upper Text").GetComponent <GUIText>();
lowerText = GameObject.Find("Lower Text").GetComponent <GUIText>();
skeletonController = FindObjectOfType(typeof(RUISSkeletonController)) as RUISSkeletonController;
coordinateSystem = FindObjectOfType(typeof(RUISCoordinateSystem)) as RUISCoordinateSystem;
// Pass variables and objects to calibrationProcess
calibrationProcessSettings = new RUISCalibrationProcessSettings();
calibrationProcessSettings.xmlFilename = xmlFilename;
calibrationProcessSettings.numberOfSamplesToTake = numberOfSamplesToTake;
calibrationProcessSettings.numberOfSamplesPerSecond = samplesPerSecond;
calibrationProcessSettings.calibrationCubePrefab = this.sampleCube;
calibrationProcessSettings.calibrationSpherePrefab = this.sampleSphere;
calibrationProcessSettings.calibrationPhaseObjects = this.calibrationPhaseObjects;
calibrationProcessSettings.calibrationResultPhaseObjects = this.calibrationResultPhaseObjects;
calibrationProcessSettings.deviceModelObjects = deviceModels;
calibrationProcessSettings.depthViewObjects = depthViews;
calibrationProcessSettings.iconObjects = icons;
}
private Vector3 getSample(RUISDevice device) {
Vector3 sample = new Vector3(0,0,0);
Vector3 tempSample;
if(device == RUISDevice.Kinect_1) {
OpenNI.SkeletonJointPosition jointPosition;
bool success = kinectSelection.GetPlayer(0).GetSkeletonJointPosition(OpenNI.SkeletonJoint.RightHand, out jointPosition);
if(success && jointPosition.Confidence >= 0.5) {
tempSample = coordinateSystem.ConvertRawKinectLocation(jointPosition.Position);
if(Vector3.Distance(tempSample, lastKinectSample) > 0.1) {
sample = tempSample;
lastKinectSample = sample;
this.guiTextUpperLocal = "";
}
else {
this.guiTextUpperLocal = "Not enough hand movement.";
}
}
}
if(device == RUISDevice.PS_Move) {
if(psMoveWrapper.sphereVisible[calibratingPSMoveControllerId] &&
psMoveWrapper.handleVelocity[calibratingPSMoveControllerId].magnitude <= 10.0f) {
tempSample = coordinateSystem.ConvertRawPSMoveLocation(psMoveWrapper.handlePosition[calibratingPSMoveControllerId]);
if(Vector3.Distance(tempSample, lastPSMoveSample) > 0.1) {
sample = tempSample;
lastPSMoveSample = sample;
this.guiTextUpperLocal = "";
}
else {
this.guiTextUpperLocal = "Not enough hand movement.";
}
}
}
return sample;
}
public void SetFloorNormal(Vector3 newFloorNormal, RUISDevice floorDetectingDevice)
{
Quaternion kinectFloorRotator = Quaternion.identity;
kinectFloorRotator.SetFromToRotation(newFloorNormal, Vector3.up);
kinectFloorRotator = Quaternion.Inverse(kinectFloorRotator);
switch(floorDetectingDevice)
{
case RUISDevice.Kinect_1:
RUISCalibrationResultsFloorPitchRotation[RUISDevice.Kinect_1] = kinectFloorRotator;
break;
case RUISDevice.Kinect_2:
RUISCalibrationResultsFloorPitchRotation[RUISDevice.Kinect_2] = kinectFloorRotator;
break;
default:
Debug.LogWarning("Currently floor normal detection with " + floorDetectingDevice.ToString() + " is not supported!");
break;
}
}
public RUISKinectToOculusDK2CalibrationProcess(RUISCalibrationProcessSettings calibrationSettings)
{
this.inputDevice1 = RUISDevice.Oculus_DK2;
this.inputDevice2 = RUISDevice.Kinect_1;
this.numberOfSamplesToTake = calibrationSettings.numberOfSamplesToTake;
this.numberOfSamplesPerSecond = calibrationSettings.numberOfSamplesPerSecond;
trackingIDs = new trackedBody[6];
for (int y = 0; y < trackingIDs.Length; y++)
{
trackingIDs[y] = new trackedBody(-1, false, 1);
}
inputManager = MonoBehaviour.FindObjectOfType(typeof(RUISInputManager)) as RUISInputManager;
coordinateSystem = MonoBehaviour.FindObjectOfType(typeof(RUISCoordinateSystem)) as RUISCoordinateSystem;
kinectSelection = MonoBehaviour.FindObjectOfType(typeof(NIPlayerManagerCOMSelection)) as NIPlayerManagerCOMSelection;
settingsManager = MonoBehaviour.FindObjectOfType(typeof(OpenNISettingsManager)) as OpenNISettingsManager;
this.timeSinceScriptStart = 0;
this.timeBetweenSamples = 1 / (float)numberOfSamplesPerSecond;
// Limit sample rate
if (this.timeBetweenSamples < 0.1f)
{
this.timeBetweenSamples = 0.1f;
}
calibrationSpheres = new List <GameObject>();
samples_Kinect1 = new List <Vector3>();
samples_OculusDK2 = new List <Vector3>();
this.calibrationCube = calibrationSettings.calibrationCubePrefab;
this.calibrationSphere = calibrationSettings.calibrationSpherePrefab;
this.calibrationPhaseObjects = calibrationSettings.calibrationPhaseObjects;
this.calibrationResultPhaseObjects = calibrationSettings.calibrationResultPhaseObjects;
this.deviceModelObjects = calibrationSettings.deviceModelObjects;
this.depthViewObjects = calibrationSettings.depthViewObjects;
this.iconObjects = calibrationSettings.iconObjects;
if (GameObject.Find("PSMoveWand") != null)
{
GameObject.Find("PSMoveWand").SetActive(false);
}
// Models
this.oculusDK2CameraObject = GameObject.Find("OculusDK2Camera");
this.kinect1ModelObject = GameObject.Find("KinectCamera");
this.oculusRiftModel = GameObject.Find("OculusRift");
FixedFollowTransform followTransform = Component.FindObjectOfType <FixedFollowTransform>();
if (followTransform && this.oculusRiftModel)
{
followTransform.transformToFollow = this.oculusRiftModel.transform;
}
// Depth view
this.depthView = GameObject.Find("KinectDepthView");
// Icons
this.oculusDK2Icon = GameObject.Find("OculusDK2 Icon");
this.kinectIcon = GameObject.Find("Kinect Icon");
this.floorPlane = GameObject.Find("Floor");
if (this.oculusDK2Icon && this.oculusDK2Icon.GetComponent <GUITexture>())
{
this.oculusDK2Icon.GetComponent <GUITexture>().pixelInset = new Rect(5.1f, 10.0f, 70.0f, 70.0f);
}
foreach (Transform child in this.deviceModelObjects.transform)
{
child.gameObject.SetActive(false);
}
foreach (Transform child in this.depthViewObjects.transform)
{
child.gameObject.SetActive(false);
}
foreach (Transform child in this.iconObjects.transform)
{
child.gameObject.SetActive(false);
}
if (this.oculusDK2CameraObject)
{
this.oculusDK2CameraObject.SetActive(true);
}
if (this.kinect1ModelObject)
{
this.kinect1ModelObject.SetActive(true);
}
if (this.oculusRiftModel)
{
this.oculusRiftModel.SetActive(true);
}
if (this.oculusDK2Icon)
{
this.oculusDK2Icon.SetActive(true);
}
if (this.kinectIcon)
{
this.kinectIcon.SetActive(true);
}
if (this.calibrationPhaseObjects)
{
this.calibrationPhaseObjects.SetActive(true);
}
if (this.calibrationResultPhaseObjects)
{
this.calibrationResultPhaseObjects.SetActive(false);
}
if (this.depthView)
{
this.depthView.SetActive(true);
}
this.xmlFilename = calibrationSettings.xmlFilename;
}
public RUISKinectToPSMoveCalibrationProcess(RUISCalibrationProcessSettings calibrationSettings) {
this.inputDevice1 = RUISDevice.Kinect_1;
this.inputDevice2 = RUISDevice.PS_Move;
this.numberOfSamplesToTake = calibrationSettings.numberOfSamplesToTake;
this.numberOfSamplesPerSecond = calibrationSettings.numberOfSamplesPerSecond;
kinectSelection = MonoBehaviour.FindObjectOfType(typeof(NIPlayerManagerCOMSelection)) as NIPlayerManagerCOMSelection;
settingsManager = MonoBehaviour.FindObjectOfType(typeof(OpenNISettingsManager)) as OpenNISettingsManager;
psMoveWrapper = MonoBehaviour.FindObjectOfType(typeof(PSMoveWrapper)) as PSMoveWrapper;
inputManager = MonoBehaviour.FindObjectOfType(typeof(RUISInputManager)) as RUISInputManager;
coordinateSystem = MonoBehaviour.FindObjectOfType(typeof(RUISCoordinateSystem)) as RUISCoordinateSystem;
this.timeSinceScriptStart = 0;
this.timeBetweenSamples = 1 / (float)numberOfSamplesPerSecond;
// Limit sample rate
if(this.timeBetweenSamples < 0.1f) {
this.timeBetweenSamples = 0.1f;
}
calibrationSpheres = new List<GameObject>();
samples_PSMove = new List<Vector3>();
samples_Kinect = new List<Vector3>();
this.calibrationCube = calibrationSettings.calibrationCubePrefab;
this.calibrationSphere = calibrationSettings.calibrationSpherePrefab;
this.calibrationPhaseObjects = calibrationSettings.calibrationPhaseObjects;
this.calibrationResultPhaseObjects = calibrationSettings.calibrationResultPhaseObjects;
this.deviceModelObjects = calibrationSettings.deviceModelObjects;
this.depthViewObjects = calibrationSettings.depthViewObjects;
this.iconObjects = calibrationSettings.iconObjects;
this.PSMoveWandObject = GameObject.Find ("PSMoveWand");
// Models
this.psEyeModelObject = GameObject.Find ("PS Eye");
this.kinect1ModelObject = GameObject.Find ("KinectCamera");
// Depth view
this.depthView = GameObject.Find ("KinectDepthView");
// Icons
this.psMoveIcon = GameObject.Find ("PS Move Icon");
this.KinectIcon = GameObject.Find ("Kinect Icon");
this.floorPlane = GameObject.Find ("Floor");
foreach (Transform child in this.deviceModelObjects.transform)
{
child.gameObject.SetActive(false);
}
foreach (Transform child in this.depthViewObjects.transform)
{
child.gameObject.SetActive(false);
}
foreach (Transform child in this.iconObjects.transform)
{
child.gameObject.SetActive(false);
}
if(this.psEyeModelObject)
this.psEyeModelObject.SetActive(true);
if(this.PSMoveWandObject)
this.PSMoveWandObject.SetActive(true);
if(this.kinect1ModelObject)
this.kinect1ModelObject.SetActive(true);
if(this.psMoveIcon)
this.psMoveIcon.SetActive(true);
if(this.KinectIcon)
this.KinectIcon.SetActive(true);
if(this.calibrationPhaseObjects)
this.calibrationPhaseObjects.SetActive(true);
if(this.calibrationResultPhaseObjects)
this.calibrationResultPhaseObjects.SetActive(false);
if(this.depthView)
this.depthView.SetActive(true);
this.xmlFilename = calibrationSettings.xmlFilename;
}
private Vector3 getSample(RUISDevice device)
{
Vector3 sample = new Vector3(0, 0, 0);
Vector3 tempSample;
updateBodyData();
if (device == RUISDevice.Kinect_2)
{
Kinect.Body[] data = kinect2SourceManager.GetBodyData();
bool trackedBodyFound = false;
int foundBodies = 0;
foreach (var body in data)
{
foundBodies++;
if (body.IsTracked)
{
if (trackingIDtoIndex[body.TrackingId] == 0)
{
trackedBodyFound = true;
if (body.Joints[Kinect.JointType.HandRight].TrackingState == Kinect.TrackingState.Tracked)
{
tempSample = new Vector3(body.Joints[Kinect.JointType.HandRight].Position.X,
body.Joints[Kinect.JointType.HandRight].Position.Y,
body.Joints[Kinect.JointType.HandRight].Position.Z);
tempSample = coordinateSystem.ConvertRawKinect2Location(tempSample);
if (Vector3.Distance(tempSample, lastKinect2Sample) > 0.1)
{
sample = tempSample;
lastKinect2Sample = sample;
device1Error = false;
if (!device2Error)
{
this.guiTextUpperLocal = "";
}
}
else
{
device1Error = true;
this.guiTextUpperLocal = "Not enough hand movement.";
}
}
}
}
}
if (!trackedBodyFound && foundBodies > 1)
{
device1Error = true;
this.guiTextUpperLocal = "Step out of the Kinect's\nview and come back.";
}
}
if (device == RUISDevice.Oculus_DK2)
{
Ovr.Posef headpose = RUISOVRManager.ovrHmd.GetTrackingState().HeadPose.ThePose;
float px = headpose.Position.x;
float py = headpose.Position.y;
float pz = -headpose.Position.z; // This needs to be negated TODO: might change with future OVR version
tempSample = new Vector3(px, py, pz);
tempSample = coordinateSystem.ConvertRawOculusDK2Location(tempSample);
if ((Vector3.Distance(tempSample, lastOculusDK2Sample) > 0.1) &&
(RUISOVRManager.ovrHmd.GetTrackingState().StatusFlags & (uint)StatusBits.PositionTracked) != 0) // Code from OVRManager.cs
{
sample = tempSample;
lastOculusDK2Sample = sample;
device2Error = false;
if (!device1Error)
{
this.guiTextUpperLocal = "";
}
}
else
{
device2Error = true;
this.guiTextUpperLocal = "Not enough hand movement.";
}
}
return(sample);
}
private Vector3 getSample(RUISDevice device) {
Vector3 sample = new Vector3(0,0,0);
Vector3 tempSample;
if(device == RUISDevice.Oculus_DK2)
{
Ovr.Posef headpose = RUISOVRManager.ovrHmd.GetTrackingState().HeadPose.ThePose;
float px = headpose.Position.x;
float py = headpose.Position.y;
float pz = -headpose.Position.z; // This needs to be negated TODO: might change with future OVR version
tempSample = new Vector3(px, py, pz);
tempSample = coordinateSystem.ConvertRawOculusDK2Location(tempSample);
if( (Vector3.Distance(tempSample, lastOculusDK2Sample) > 0.1)
&& (RUISOVRManager.ovrHmd.GetTrackingState().StatusFlags & (uint)StatusBits.PositionTracked) != 0)
{
sample = tempSample;
lastOculusDK2Sample = sample;
this.guiTextUpperLocal = "";
}
else {
this.guiTextUpperLocal = "Not enough hand movement.";
}
}
if(device == RUISDevice.PS_Move) {
if(psMoveWrapper.sphereVisible[calibratingPSMoveControllerId] &&
psMoveWrapper.handleVelocity[calibratingPSMoveControllerId].magnitude <= 10.0f) {
tempSample = coordinateSystem.ConvertRawPSMoveLocation(psMoveWrapper.handlePosition[calibratingPSMoveControllerId]);
if(Vector3.Distance(tempSample, lastPSMoveSample) > 0.1) {
sample = tempSample;
lastPSMoveSample = sample;
this.guiTextUpperLocal = "";
}
else {
this.guiTextUpperLocal = "Not enough hand movement.";
}
}
}
return sample;
}
public RUISKinectToPSMoveCalibrationProcess(RUISCalibrationProcessSettings calibrationSettings)
{
this.inputDevice1 = RUISDevice.Kinect_1;
this.inputDevice2 = RUISDevice.PS_Move;
this.numberOfSamplesToTake = calibrationSettings.numberOfSamplesToTake;
this.numberOfSamplesPerSecond = calibrationSettings.numberOfSamplesPerSecond;
kinectSelection = MonoBehaviour.FindObjectOfType(typeof(NIPlayerManagerCOMSelection)) as NIPlayerManagerCOMSelection;
settingsManager = MonoBehaviour.FindObjectOfType(typeof(OpenNISettingsManager)) as OpenNISettingsManager;
psMoveWrapper = MonoBehaviour.FindObjectOfType(typeof(PSMoveWrapper)) as PSMoveWrapper;
inputManager = MonoBehaviour.FindObjectOfType(typeof(RUISInputManager)) as RUISInputManager;
coordinateSystem = MonoBehaviour.FindObjectOfType(typeof(RUISCoordinateSystem)) as RUISCoordinateSystem;
this.timeSinceScriptStart = 0;
this.timeBetweenSamples = 1 / (float)numberOfSamplesPerSecond;
// Limit sample rate
if (this.timeBetweenSamples < 0.1f)
{
this.timeBetweenSamples = 0.1f;
}
calibrationSpheres = new List <GameObject>();
samples_PSMove = new List <Vector3>();
samples_Kinect = new List <Vector3>();
this.calibrationCube = calibrationSettings.calibrationCubePrefab;
this.calibrationSphere = calibrationSettings.calibrationSpherePrefab;
this.calibrationPhaseObjects = calibrationSettings.calibrationPhaseObjects;
this.calibrationResultPhaseObjects = calibrationSettings.calibrationResultPhaseObjects;
this.deviceModelObjects = calibrationSettings.deviceModelObjects;
this.depthViewObjects = calibrationSettings.depthViewObjects;
this.iconObjects = calibrationSettings.iconObjects;
this.PSMoveWandObject = GameObject.Find("PSMoveWand");
// Models
this.psEyeModelObject = GameObject.Find("PS Eye");
this.kinect1ModelObject = GameObject.Find("KinectCamera");
// Depth view
this.depthView = GameObject.Find("KinectDepthView");
// Icons
this.psMoveIcon = GameObject.Find("PS Move Icon");
this.KinectIcon = GameObject.Find("Kinect Icon");
this.floorPlane = GameObject.Find("Floor");
foreach (Transform child in this.deviceModelObjects.transform)
{
child.gameObject.SetActive(false);
}
foreach (Transform child in this.depthViewObjects.transform)
{
child.gameObject.SetActive(false);
}
foreach (Transform child in this.iconObjects.transform)
{
child.gameObject.SetActive(false);
}
if (this.psEyeModelObject)
{
this.psEyeModelObject.SetActive(true);
}
if (this.PSMoveWandObject)
{
this.PSMoveWandObject.SetActive(true);
}
if (this.kinect1ModelObject)
{
this.kinect1ModelObject.SetActive(true);
}
if (this.psMoveIcon)
{
this.psMoveIcon.SetActive(true);
}
if (this.KinectIcon)
{
this.KinectIcon.SetActive(true);
}
if (this.calibrationPhaseObjects)
{
this.calibrationPhaseObjects.SetActive(true);
}
if (this.calibrationResultPhaseObjects)
{
this.calibrationResultPhaseObjects.SetActive(false);
}
if (this.depthView)
{
this.depthView.SetActive(true);
}
this.xmlFilename = calibrationSettings.xmlFilename;
}
private Vector3 getSample(RUISDevice device)
{
Vector3 sample = new Vector3(0, 0, 0);
Vector3 tempSample;
updateBodyData();
if (device == RUISDevice.Kinect_2)
{
Kinect.Body[] data = kinect2SourceManager.GetBodyData();
bool trackedBodyFound = false;
int foundBodies = 0;
foreach (var body in data)
{
foundBodies++;
if (body.IsTracked)
{
if (trackingIDtoIndex[body.TrackingId] == 0)
{
trackedBodyFound = true;
if (body.Joints[Kinect.JointType.HandRight].TrackingState == Kinect.TrackingState.Tracked)
{
tempSample = new Vector3(body.Joints[Kinect.JointType.HandRight].Position.X,
body.Joints[Kinect.JointType.HandRight].Position.Y,
body.Joints[Kinect.JointType.HandRight].Position.Z);
tempSample = coordinateSystem.ConvertRawKinect2Location(tempSample);
if (Vector3.Distance(tempSample, lastKinect2Sample) > 0.2)
{
sample = tempSample;
lastKinect2Sample = sample;
device1Error = false;
if (!device2Error)
{
this.guiTextUpperLocal = "";
}
}
else
{
device1Error = true;
this.guiTextUpperLocal = "Not enough hand movement.";
}
}
}
}
}
if (!trackedBodyFound && foundBodies > 1)
{
device1Error = true;
this.guiTextUpperLocal = "Step out of the Kinect's\nview and come back.";
}
}
if (device == RUISDevice.Kinect_1)
{
OpenNI.SkeletonJointPosition jointPosition;
bool success = kinectSelection.GetPlayer(0).GetSkeletonJointPosition(OpenNI.SkeletonJoint.RightHand, out jointPosition);
if (success && jointPosition.Confidence >= 0.5)
{
tempSample = coordinateSystem.ConvertRawKinectLocation(jointPosition.Position);
if (Vector3.Distance(tempSample, lastKinectSample) > 0.2)
{
sample = tempSample;
lastKinectSample = sample;
device2Error = false;
if (!device1Error)
{
this.guiTextUpperLocal = "";
}
}
else
{
device2Error = true;
// this.guiTextUpperLocal = "Not enough hand movement.";
}
}
else
{
device2Error = true;
// this.guiTextUpperLocal = "Not enough hand movement.";
}
}
return(sample);
}
