Initial commit

example_default.vrsettings

@@ -0,0 +1,118 @@
+{
+	"steamvr" : {
+		"requireHmd" : false,
+		"forcedDriver" : "",
+		"forcedHmd" : "",
+		"displayDebug" : false,
+		"debugProcessPipe" : "",
+		"enableDistortion" : true, 
+		"displayDebugX" : 0, 
+		"displayDebugY" : 0,
+		"sendSystemButtonToAllApps" : false,
+		"loglevel" : 3,
+		"ipd" : 0.063,
+		"ipdOffset" :  0.0,
+		"background" : "",
+		"backgroundUseDomeProjection" : false,
+		"backgroundCameraHeight" : 1.6,
+		"backgroundDomeRadius" : 0.0, 
+		"environment" : "", 
+		"gridColor" : "", 
+		"playAreaColor" : "",
+		"showStage" : false,
+		"activateMultipleDrivers" : false,
+		"directMode" : true,
+		"usingSpeakers" : false,
+		"speakersForwardYawOffsetDegrees" : 0.0,
+		"basestationPowerManagement" : false,
+		"neverKillProcesses" : false,
+        "renderTargetMultiplier" : 1.0,
+        "allowAsyncReprojection" :  true,
+		"allowInterleavedReprojection" : true,
+		"forceReprojection" : false,
+		"forceFadeOnBadTracking" : true,
+		"defaultMirrorView" : 0,
+		"showMirrorView" : false,
+		"startMonitorFromAppLaunch" : true,
+		"startCompositorFromAppLaunch" : true,
+		"startDashboardFromAppLaunch" : true,
+		"startOverlayAppsFromDashboard" : true,
+		"enableHomeApp" : false,
+		"setInitialDefaultHomeApp" : false,
+		"CycleBackgroundImageTimeSec" : -1,
+		"retailDemo" : false,
+		"panelMask" : true,
+		"panelMaskVignette" : true,
+		"panelMaskVignetteWidth" : 2.0
+	},
+	"userinterface" : {
+		"StatusAlwaysOnTop" : true,
+		"screenshots" : true,
+		"screenshotType" : 2
+	},
+	"notifications" : {
+		"DoNotDisturb" : false
+	},
+	"keyboard" : {
+		"TutorialCompletions" : 0,
+		"ScaleX" : 1.1,
+		"ScaleY" : 1.1,
+		"OffsetLeftX" : 0.0,
+		"OffsetRightX" : 0.0,
+		"OffsetY" : 0.0,
+		"Smoothing" : false
+	},
+	"perfcheck" : {
+		"heuristicActive" : true, 
+		"warnInHMD" : false,
+		"warnOnlyOnce" : false,
+		"allowTimingStore" : false,
+		"saveTimingsOnExit" : false,
+		"perfTestData" : 0.0
+	},
+	"collisionBounds" : {
+		"CollisionBoundsStyle" : 0,
+		"CollisionBoundsGroundPerimeterOn" : false,
+		"CollisionBoundsCenterMarkerOn" : false, 
+		"CollisionBoundsPlaySpaceOn" : false, 
+		"CollisionBoundsFadeDistance" : 0.7,
+		"CollisionBoundsColorGammaR" : 0,
+		"CollisionBoundsColorGammaG" : 255,
+		"CollisionBoundsColorGammaB" : 255,
+		"CollisionBoundsColorGammaA" : 153 
+	},
+	"camera" : {
+		"enableCamera" : false,
+		"enableCameraInDashboard" : false,
+		"enableCameraForCollisionBounds" : false,
+		"enableCameraForRoomView" : false,
+		"cameraBoundsColorGammaR" : 0,
+		"cameraBoundsColorGammaG" : 255,
+		"cameraBoundsColorGammaB" : 255,
+		"cameraBoundsColorGammaA" : 153,
+		"cameraBoundsStrength" : 78
+	},
+	"audio" : {
+		"onPlaybackDevice" : "",
+		"onRecordDevice" : "",
+		"onPlaybackMirrorDevice" : "",
+		"offPlaybackDevice" : "", 
+		"offRecordDevice" : "",
+		"viveHDMIGain" : true
+	},   
+	"power" : {
+		"powerOffOnExit" : true,
+		"turnOffScreensTimeout" : 5.0,
+		"turnOffControllersTimeout" : 300.0,
+		"returnToWatchdogTimeout" : 0.0,
+		"autoLaunchSteamVROnButtonPress" : true
+   },
+   "modelskins" : {
+   },    
+   "dashboard" : {
+		"enableDashboard" : true,
+		"arcadeMode" : false
+   },
+   "version" : "1",
+   "jsonid" : "vrsettings"
+}

tracker_test.py

@@ -0,0 +1,26 @@
+import triad_openvr
+import time
+import sys
+
+v = triad_openvr.triad_openvr()
+v.print_discovered_objects()
+
+if len(sys.argv) == 1:
+    interval = 1/250
+elif len(sys.argv) == 2:
+    interval = 1/float(sys.argv[0])
+else:
+    print("Invalid number of arguments")
+    interval = False
+
+if interval:
+    while(True):
+        start = time.time()
+        txt = ""
+        for each in v.devices["tracker_1"].get_pose_euler():
+            txt += "%.4f" % each
+            txt += " "
+        print("\r" + txt, end="")
+        sleep_time = interval-(time.time()-start)
+        if sleep_time>0:
+            time.sleep(sleep_time)

triad_openvr.py

@@ -0,0 +1,154 @@
+import time
+import sys
+import openvr
+import math
+
+# Function to print out text but instead of starting a new line it will overwrite the existing line
+def update_text(txt):
+    sys.stdout.write('\r'+txt)
+    sys.stdout.flush()
+
+#Convert the standard 3x4 position/rotation matrix to a x,y,z location and the appropriate Euler angles (in degrees)
+def convert_to_euler(pose_mat):
+    yaw = 180 / math.pi * math.atan(pose_mat[1][0] /pose_mat[0][0])
+    pitch = 180 / math.pi * math.atan(-1 * pose_mat[2][0] / math.sqrt(pow(pose_mat[2][1], 2) + math.pow(pose_mat[2][2], 2)))
+    roll = 180 / math.pi * math.atan(pose_mat[2][1] /pose_mat[2][2])
+    x = pose_mat[0][3]
+    y = pose_mat[1][3]
+    z = pose_mat[2][3]
+    return [x,y,z,yaw,pitch,roll]
+
+#Convert the standard 3x4 position/rotation matrix to a x,y,z location and the appropriate Quaternion
+def convert_to_quaternion(pose_mat):
+    r_w = math.sqrt(1+pose_mat[0][0]+pose_mat[1][1]+pose_mat[2][2])/2
+    r_x = (pose_mat[2][1]-pose_mat[1][2])/(4*r_w)
+    r_y = (pose_mat[0][2]-pose_mat[2][0])/(4*r_w)
+    r_z = (pose_mat[1][0]-pose_mat[0][1])/(4*r_w)
+
+    x = pose_mat[0][3]
+    y = pose_mat[1][3]
+    z = pose_mat[2][3]
+    return [x,y,z,r_w,r_x,r_y,r_z]
+
+#Define a class to make it easy to append pose matricies and convert to both Euler and Quaternion for plotting
+class pose_sample_buffer():
+    def __init__(self):
+        self.i = 0
+        self.index = []
+        self.time = []
+        self.x = []
+        self.y = []
+        self.z = []
+        self.yaw = []
+        self.pitch = []
+        self.roll = []
+        self.r_w = []
+        self.r_x = []
+        self.r_y = []
+        self.r_z = []
+
+    def append(self,pose_mat,t):
+        self.time.append(t)
+        self.x.append(pose_mat[0][3])
+        self.y.append(pose_mat[1][3])
+        self.z.append(pose_mat[2][3])
+        self.yaw.append(180 / math.pi * math.atan(pose_mat[1][0] /pose_mat[0][0]))
+        self.pitch.append(180 / math.pi * math.atan(-1 * pose_mat[2][0] / math.sqrt(pow(pose_mat[2][1], 2) + math.pow(pose_mat[2][2], 2))))
+        self.roll.append(180 / math.pi * math.atan(pose_mat[2][1] /pose_mat[2][2]))
+        r_w = math.sqrt(1+pose_mat[0][0]+pose_mat[1][1]+pose_mat[2][2])/2
+        self.r_w.append(r_w)
+        self.r_x.append((pose_mat[2][1]-pose_mat[1][2])/(4*r_w))
+        self.r_y.append((pose_mat[0][2]-pose_mat[2][0])/(4*r_w))
+        self.r_z.append((pose_mat[1][0]-pose_mat[0][1])/(4*r_w))
+
+class vr_tracked_device():
+    def __init__(self,vr_obj,index,device_class):
+        self.device_class = device_class
+        self.index = index
+        self.vr = vr_obj
+
+    def get_serial(self):
+        return self.vr.getStringTrackedDeviceProperty(self.index,openvr.Prop_SerialNumber_String).decode('utf-8')
+
+    def get_model(self):
+        return self.vr.getStringTrackedDeviceProperty(self.index,openvr.Prop_ModelNumber_String).decode('utf-8')
+
+    def sample(self,num_samples,sample_rate):
+        interval = 1/sample_rate
+        rtn = pose_sample_buffer()
+        sample_start = time.time()
+        for i in range(num_samples):
+            start = time.time()
+            pose = self.vr.getDeviceToAbsoluteTrackingPose(openvr.TrackingUniverseStanding, 0,openvr.k_unMaxTrackedDeviceCount)
+            rtn.append(pose[self.index].mDeviceToAbsoluteTracking,time.time()-sample_start)
+            sleep_time = interval- (time.time()-start)
+            if sleep_time>0:
+                time.sleep(sleep_time)
+        return rtn
+
+    def get_pose_euler(self):
+        pose = self.vr.getDeviceToAbsoluteTrackingPose(openvr.TrackingUniverseStanding, 0,openvr.k_unMaxTrackedDeviceCount)
+        return convert_to_euler(pose[self.index].mDeviceToAbsoluteTracking)
+
+    def get_pose_quaternion(self):
+        pose = self.vr.getDeviceToAbsoluteTrackingPose(openvr.TrackingUniverseStanding, 0,openvr.k_unMaxTrackedDeviceCount)
+        return convert_to_quaternion(pose[self.index].mDeviceToAbsoluteTracking)
+
+class vr_tracking_reference(vr_tracked_device):
+    def get_mode(self):
+        return self.vr.getStringTrackedDeviceProperty(self.index,openvr.Prop_ModeLabel_String).decode('utf-8').upper()
+    def sample(self,num_samples,sample_rate):
+        print("Warning: Tracking References do not move, sample isn't much use...")
+
+class triad_openvr():
+    def __init__(self):
+        # Initialize OpenVR in the 
+        self.vr = openvr.init(openvr.VRApplication_Other)
+
+        # Initializing object to hold indexes for various tracked objects 
+        self.object_names = {"Tracking Reference":[],"HMD":[],"Controller":[],"Tracker":[]}
+        self.devices = {}
+        poses = self.vr.getDeviceToAbsoluteTrackingPose(openvr.TrackingUniverseStanding, 0,
+                                                               openvr.k_unMaxTrackedDeviceCount)
+        # Iterate through the pose list to find the active devices and determine their type
+        for i in range(openvr.k_unMaxTrackedDeviceCount):
+            if poses[i].bPoseIsValid:
+                device_class = self.vr.getTrackedDeviceClass(i)
+                if (device_class == openvr.TrackedDeviceClass_Controller):
+                    device_name = "controller_"+str(len(self.object_names["Controller"])+1)
+                    self.object_names["Controller"].append(device_name)
+                    self.devices[device_name] = vr_tracked_device(self.vr,i,"Controller")
+                elif (device_class == openvr.TrackedDeviceClass_HMD):
+                    device_name = "hmd_"+str(len(self.object_names["HMD"])+1)
+                    self.object_names["HMD"].append(device_name)
+                    self.devices[device_name] = vr_tracked_device(self.vr,i,"HMD")
+                elif (device_class == openvr.TrackedDeviceClass_GenericTracker):
+                    device_name = "tracker_"+str(len(self.object_names["Tracker"])+1)
+                    self.object_names["Tracker"].append(device_name)
+                    self.devices[device_name] = vr_tracked_device(self.vr,i,"Tracker")
+                elif (device_class == openvr.TrackedDeviceClass_TrackingReference):
+                    device_name = "tracking_reference_"+str(len(self.object_names["Tracking Reference"])+1)
+                    self.object_names["Tracking Reference"].append(device_name)
+                    self.devices[device_name] = vr_tracking_reference(self.vr,i,"Tracking Reference")
+
+    def rename_device(self,old_device_name,new_device_name):
+        self.devices[new_device_name] = self.devices.pop(old_device_name)
+        for i in range(len(self.object_names[self.devices[new_device_name].device_class])):
+            if self.object_names[self.devices[new_device_name].device_class][i] == old_device_name:
+                self.object_names[self.devices[new_device_name].device_class][i] = new_device_name
+
+    def print_discovered_objects(self):   
+        for device_type in self.object_names:
+            plural = device_type
+            if len(self.object_names[device_type])!=1:
+                plural+="s"
+            print("Found "+str(len(self.object_names[device_type]))+" "+plural)
+            for device in self.object_names[device_type]:
+                if device_type == "Tracking Reference":
+                    print("  "+device+" ("+self.devices[device].get_serial()+
+                          ", Mode "+self.devices[device].get_mode()+
+                          ", "+self.devices[device].get_model()+
+                          ")")
+                else:
+                    print("  "+device+" ("+self.devices[device].get_serial()+
+                          ", "+self.devices[device].get_model()+")")