def __init__(self, multisample=0, znear=0.1, zfar=1000, poll_tracked_device_frequency=None): self.vr_system = openvr.init(openvr.VRApplication_Scene) w, h = self.vr_system.getRecommendedRenderTargetSize() self.vr_framebuffers = (OpenVRFramebuffer(w, h, multisample=multisample), OpenVRFramebuffer(w, h, multisample=multisample)) self._multisample = multisample self.vr_compositor = openvr.VRCompositor() if self.vr_compositor is None: raise Exception('unable to create compositor') self.vr_framebuffers[0].init_gl() self.vr_framebuffers[1].init_gl() self._poses = (openvr.TrackedDevicePose_t * openvr.k_unMaxTrackedDeviceCount)() self.projection_matrices = (np.asarray(matrixForOpenVRMatrix(self.vr_system.getProjectionMatrix(openvr.Eye_Left, znear, zfar))), np.asarray(matrixForOpenVRMatrix(self.vr_system.getProjectionMatrix(openvr.Eye_Right, znear, zfar)))) self.eye_transforms = (np.asarray(matrixForOpenVRMatrix(self.vr_system.getEyeToHeadTransform(openvr.Eye_Left)).I), np.asarray(matrixForOpenVRMatrix(self.vr_system.getEyeToHeadTransform(openvr.Eye_Right)).I)) self.view = np.eye(4, dtype=np.float32) self.view_matrices = (np.empty((4,4), dtype=np.float32), np.empty((4,4), dtype=np.float32)) self.controllers = TrackedDevicesActor(self._poses) #self.controllers.show_controllers_only = False self.controllers.init_gl() self.vr_event = openvr.VREvent_t() self._poll_tracked_device_count() self._poll_tracked_device_frequency = poll_tracked_device_frequency self._frames_rendered = 0 self._pulse_t0 = 0.0
def __init__(self): """ A representation of the openvr sdk """ self.openvr = openvr.init(openvr.VRApplication_Overlay) self.hmd = HMD(vr=self.openvr)
def init_gl(self): "allocate OpenGL resources" self.vr_system = openvr.init(openvr.VRApplication_Scene) w, h = self.vr_system.getRecommendedRenderTargetSize() self.left_fb = OpenVrFramebuffer(w, h, multisample=self.multisample) self.right_fb = OpenVrFramebuffer(w, h, multisample=self.multisample) self.compositor = openvr.VRCompositor() if self.compositor is None: raise Exception("Unable to create compositor") self.left_fb.init_gl() self.right_fb.init_gl() # Compute projection matrix zNear = 0.2 zFar = 500.0 self.projection_left = numpy.asarray(matrixForOpenVrMatrix(self.vr_system.getProjectionMatrix( openvr.Eye_Left, zNear, zFar))) self.projection_right = numpy.asarray(matrixForOpenVrMatrix(self.vr_system.getProjectionMatrix( openvr.Eye_Right, zNear, zFar))) self.view_left = matrixForOpenVrMatrix( self.vr_system.getEyeToHeadTransform(openvr.Eye_Left)).I # head_X_eye in Kane notation self.view_right = matrixForOpenVrMatrix( self.vr_system.getEyeToHeadTransform(openvr.Eye_Right)).I # head_X_eye in Kane notation for actor in self: actor.init_gl()
def v_initPre(): ''' init vr before MuJoCo init ''' global hmd hmd.system = openvr.init(openvr.VRApplication_Scene) hmd.roompos = np.zeros(3) hmd.roommat = np.eye(3) hmd.eyeoffset = np.zeros((2, 3)) openvr.VRCompositor().setTrackingSpace(openvr.TrackingUniverseStanding) hmd.width, hmd.height = hmd.system.getRecommendedRenderTargetSize() for n in range(2): hmd.eyeoffset[n] = np.array(hmd.system.getEyeToHeadTransform(n).m)[0:3, 3]
def __init__(self, vr=None): """ A base object for all tracked openvr elements :param vr: An already initialised version of openvr, else create a new :type vr: openvr.IVRSystem """ if vr is None: self.openvr = openvr.init(openvr.VRApplication_Utility) else: self.openvr = vr
def __init__(self): "One time initialization" # Glut glutInit() glutInitDisplayMode(GLUT_RGBA) # Create a regular desktop window, just so we can have an OpenGL context to play with glutInitWindowSize(400, 400) glutInitWindowPosition(50, 50) self.win = glutCreateWindow(b"Pink world") # Set up callback methods for use during the GLUT main loop glutDisplayFunc(self.display) glutIdleFunc(self.display) glutReshapeFunc(self.resize_gl) glutKeyboardFunc(self.key_press) # OpenVR self.vr_system = openvr.init(openvr.VRApplication_Scene) self.vr_width, self.vr_height = self.vr_system.getRecommendedRenderTargetSize() self.compositor = openvr.VRCompositor() if self.compositor is None: raise Exception("Unable to create compositor") poses_t = openvr.TrackedDevicePose_t * openvr.k_unMaxTrackedDeviceCount self.poses = poses_t() # # Set up framebuffer and render textures self.fb = glGenFramebuffers(1) glBindFramebuffer(GL_FRAMEBUFFER, self.fb) self.depth_buffer = glGenRenderbuffers(1) glBindRenderbuffer(GL_RENDERBUFFER, self.depth_buffer) glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, self.vr_width, self.vr_height) glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, self.depth_buffer) self.texture_id = glGenTextures(1) glBindTexture(GL_TEXTURE_2D, self.texture_id) glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, self.vr_width, self.vr_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, None) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, self.texture_id, 0) status = glCheckFramebufferStatus(GL_FRAMEBUFFER) if status != GL_FRAMEBUFFER_COMPLETE: glBindFramebuffer(GL_FRAMEBUFFER, 0) raise Exception("Incomplete framebuffer") glBindFramebuffer(GL_FRAMEBUFFER, 0) # OpenVR texture data self.texture = openvr.Texture_t() self.texture.handle = self.texture_id self.texture.eType = openvr.TextureType_OpenGL self.texture.eColorSpace = openvr.ColorSpace_Gamma
def __init__(self): QWidget.__init__(self) self.resize(1600, 940) self.setWindowTitle('OpenVR tracking data') self.webview = QWebView() self.button = QPushButton('Quit', self) self.button.clicked.connect(self.close) layout = QVBoxLayout(self) layout.setSpacing(0) layout.setMargin(0) layout.addWidget(self.button) layout.addWidget(self.webview) # XXX check result openvr.init(openvr.VRApplication_Scene) poses_t = openvr.TrackedDevicePose_t * openvr.k_unMaxTrackedDeviceCount self.poses = poses_t() self.timer = QTimer() self.timer.timeout.connect(self.update_page) self.timer.start(50) # ms
import openvr from sys import stdout # Init kóði poses = [] openvr.init(openvr.VRApplication_Background) # Finna fjarstýringu # for index in range(openvr.length): # print(openvr.VRSystem().getTrackedDeviceClass(3)) print(openvr.IVRSystem().getStringTrackedDeviceProperty(1, 1000)) IVRSystem = openvr.IVRSystem() print("Searching for controllers...") # Keyrir í gegnum öll tækin tengd við OpenVR rightController = None leftController = None for index in range(0, openvr.k_unMaxTrackedDeviceCount): # Tækið er fjarstýring if IVRSystem.getTrackedDeviceClass( index) == openvr.TrackedDeviceClass_Controller: print("ID:", index, " Controller role:", IVRSystem.getControllerRoleForTrackedDeviceIndex(index)) # Ef fjarstýringin sem er verið að lúppa yfir er hægri if IVRSystem.getControllerRoleForTrackedDeviceIndex( index) == openvr.TrackedControllerRole_RightHand:
def start_tracker(): # Default orientation values rollOffset = 0 pitchOffset = 0 yawOffset = 0 roll = 0 pitch = 0 yaw = 0 Filterset = 0 oscIdentifier = '/pyBinSim' ip = '127.0.0.1' port = 10000 nSources = 0 minAngleDifference = 4 run = True if (len(sys.argv)) > 1: for i in range(len(sys.argv)): if (sys.argv[i] == '-port'): port = int(sys.argv[i + 1]) if (sys.argv[i] == '-ip'): ip = sys.argv[i + 1] if (sys.argv[i] == '-nSources'): nSources = int(sys.argv[i + 1]) if (sys.argv[i] == '-angleStep'): minAngleDifference = int(sys.argv[i + 1]) # Internal settings: positionVector = np.arange(360) positionVectorSubSampled = range(0, 360, minAngleDifference) # Create OSC client parser = argparse.ArgumentParser() parser.add_argument("--ip", default=ip, help="The ip of the OSC server") parser.add_argument("--port", type=int, default=port, help="The port the OSC server is listening on") args = parser.parse_args() client = udp_client.SimpleUDPClient(args.ip, args.port) # init openvr for HTC Vive help(openvr.VRSystem) openvr.init(openvr.VRApplication_Scene) poses_t = openvr.TrackedDevicePose_t * openvr.k_unMaxTrackedDeviceCount poses = poses_t() try: while 1: openvr.VRCompositor().waitGetPoses(poses, len(poses), None, 0) hmd_pose = poses[openvr.k_unTrackedDeviceIndex_Hmd] v = hmd_pose.mDeviceToAbsoluteTracking ## extraction of angles from rotation matrix ## to get yaw from 0 to 360 degree, axis 0 and 1 have been switched yawRad = np.arctan2(v[0][2], v[2][2]) yaw = int(round(np.degrees(yawRad))) pitchRad = np.arctan2( -v[1][2], np.sqrt(np.square(v[0][2]) + np.square(v[2][2]))) pitch = int(round(np.degrees(pitchRad))) rollRad = np.arctan2(v[1][0], v[1][1]) roll = int(round(np.degrees(rollRad))) posX = v[0][3] posY = v[1][3] posZ = v[2][3] #print(['YAW: ',yaw,' PITCH: ',pitch,'ROLL: ',roll]) #print(['X: ',round(posX,2),' Y: ',round(posY,2),'Z: ',round(posZ,2)]) # adjustment to desired global origin posZ = posZ + 0.8 if yaw < 0: yaw = 360 + yaw yaw = 360 - yaw # select filterset according to Z-value of listener Filterset = int(round(posZ / 0.25)) # 25cm resolution if Filterset > 8: Filterset = 8 elif Filterset < 0: Filterset = 0 # Build and send OSC message #channel valueOne valueTwo ValueThree valueFour valueFive ValueSix yaw = min(positionVectorSubSampled, key=lambda x: abs(x - yaw)) binSimParameters = [0, yaw, Filterset, 0, 0, 0, 0] print(' Yaw: ', yaw, ' Filterset: ', Filterset, ' PosY ', posZ) client.send_message(oscIdentifier, binSimParameters) sys.stdout.flush() time.sleep(0.02) except KeyboardInterrupt: # Break if ctrl+c is pressed # Console output print("Done")
def __init__(self, multisample=0, znear=0.1, zfar=1000, window_size=(960, 1080)): self.vr_system = openvr.init(openvr.VRApplication_Scene) w, h = self.vr_system.getRecommendedRenderTargetSize() self.render_target_size = np.array((w, h), dtype=np.float32) self.window_size = np.array(window_size, dtype=np.int64) self.multisample = multisample self.vr_framebuffers = (OpenVRFramebuffer(w, h, multisample=multisample), OpenVRFramebuffer(w, h, multisample=multisample)) self.vr_compositor = openvr.VRCompositor() if self.vr_compositor is None: raise Exception('unable to create compositor') self.vr_framebuffers[0].init_gl() self.vr_framebuffers[1].init_gl() poses_t = openvr.TrackedDevicePose_t * openvr.k_unMaxTrackedDeviceCount self.poses = poses_t() self.znear, self.zfar = znear, zfar self.projection_matrices = (np.asarray( matrixForOpenVRMatrix( self.vr_system.getProjectionMatrix(openvr.Eye_Left, znear, zfar))), np.asarray( matrixForOpenVRMatrix( self.vr_system.getProjectionMatrix( openvr.Eye_Right, znear, zfar)))) self.projection_lrbts = (np.array( self.vr_system.getProjectionRaw(openvr.Eye_Left)), np.array( self.vr_system.getProjectionRaw( openvr.Eye_Right))) self.eye_to_head_transforms = ( np.asarray( matrixForOpenVRMatrix( self.vr_system.getEyeToHeadTransform(openvr.Eye_Left))), np.asarray( matrixForOpenVRMatrix( self.vr_system.getEyeToHeadTransform(openvr.Eye_Right)))) self.eye_transforms = (np.asarray( matrixForOpenVRMatrix( self.vr_system.getEyeToHeadTransform(openvr.Eye_Left)).I), np.asarray( matrixForOpenVRMatrix( self.vr_system.getEyeToHeadTransform( openvr.Eye_Right)).I)) self.eye_matrices = (np.eye(4, dtype=np.float32), np.eye(4, dtype=np.float32)) self.camera_matrices = (np.eye(4, dtype=np.float32), np.eye(4, dtype=np.float32)) self.hmd_matrix = np.eye(4, dtype=np.float32) self.hmd_matrix_inv = np.eye(4, dtype=np.float32) self.vr_event = openvr.VREvent_t() self._nframes = 0 self._poll_for_controllers()
#!/bin/env python import sys import time import openvr openvr.init(openvr.VRApplication_Scene) # Create data structure to hold locations of tracked devices such as headsets, controllers, and lighthouses poses_t = openvr.TrackedDevicePose_t * openvr.k_unMaxTrackedDeviceCount poses = poses_t() # Print out headset transform five times a second for 20 seconds for i in range(100): openvr.VRCompositor().waitGetPoses(poses, len(poses), None, 0) hmd_pose = poses[openvr.k_unTrackedDeviceIndex_Hmd] print(hmd_pose.mDeviceToAbsoluteTracking) sys.stdout.flush() time.sleep(0.2) openvr.shutdown()
#!/bin/env python import sys import time import openvr print ("OpenVR test program") if openvr.isHmdPresent(): print ("VR head set found") if openvr.isRuntimeInstalled(): print ("Runtime is installed") vr_system = openvr.init(openvr.VRApplication_Scene) print (openvr.runtimePath()) print (vr_system.getRecommendedRenderTargetSize()) print (vr_system.isDisplayOnDesktop()) for i in range(10): xform = vr_system.getEyeToHeadTransform(openvr.Eye_Left) print (xform) sys.stdout.flush() time.sleep(0.2) openvr.shutdown()
import sys import time import openvr import math import numpy openvr.init(openvr.VRApplication_Scene) poses_t = openvr.TrackedDevicePose_t * openvr.k_unMaxTrackedDeviceCount poses = poses_t() def main(): for i in range(10000): openvr.VRCompositor().waitGetPoses(poses, len(poses), None, 0) hmd_pose = poses[openvr.k_unTrackedDeviceIndex_Hmd] #print(str(hmd_pose.mDeviceToAbsoluteTracking)) rotation = getQuaternion(hmd_pose.mDeviceToAbsoluteTracking) print(rotation.x, rotation.y, rotation.z, rotation.w) #print("one"+hmd_pose.mDeviceToAbsoluteTracking[1]) #print("two"+hmd_pose.mDeviceToAbsoluteTracking[2]) sys.stdout.flush() time.sleep(0.01) def getQuaternion(matrix): q = openvr.HmdQuaternion_t() q.w = math.sqrt( numpy.fmax(0, 1 + matrix.m[0][0] + matrix.m[1][1] + matrix.m[2][2])) / 2 q.x = math.sqrt( numpy.fmax(0,
def getBsPos(): """ Get the position of the base stations. 2019-10-02 Code for getting the base station positions taken from: https://github.com/bitcraze/crazyflie-firmware/blob/master/tools/lighthouse/get_bs_position.py """ print("Opening OpenVR") vr = openvr.init(openvr.VRApplication_Other) print("OpenVR Opened") devices = {} poses = vr.getDeviceToAbsoluteTrackingPose( openvr.TrackingUniverseStanding, 0, openvr.k_unMaxTrackedDeviceCount) if CENTER_AROUND_CONTROLLER: offset = None # Acquire offset for i in range(openvr.k_unMaxTrackedDeviceCount): if poses[i].bPoseIsValid: device_class = vr.getTrackedDeviceClass(i) if device_class == openvr.TrackedDeviceClass_Controller or \ device_class == openvr.TrackedDeviceClass_GenericTracker: pose = poses[i].mDeviceToAbsoluteTracking offset = [pose[0][3], pose[1][3], pose[2][3]] break if offset is None: print( "Controller not found, place controller at the origin of the space" ) openvr.shutdown() sys.exit(1) else: offset = [0, 0, 0] print("Origin: {}", offset) print("-------------------------------") bs_poses = [None, None] for i in range(openvr.k_unMaxTrackedDeviceCount): if poses[i].bPoseIsValid: device_class = vr.getTrackedDeviceClass(i) if (device_class == openvr.TrackedDeviceClass_TrackingReference): mode = vr.getStringTrackedDeviceProperty( i, openvr.Prop_ModeLabel_String) try: mode = mode.decode("utf-8") except: # likely already decoded pass pose = poses[i].mDeviceToAbsoluteTracking # Mode 'B' is master if mode == 'B': bs_poses[0] = pose elif mode == 'A' or mode == 'C': bs_poses[1] = pose else: print("Base station with mode {} detected.".format(mode)) print( "This script can only work with base station V1 (mode A, B or C). Exiting." ) sys.exit(1) for pose in bs_poses: if pose is None: continue position = [ pose[0][3] - offset[0], pose[1][3] - offset[1], pose[2][3] - offset[2] ] rotation = [pose[0][:3], pose[1][:3], pose[2][:3]] print("{.origin = {", end='') for i in position: print("{:0.6f}, ".format(i), end='') print("}, .mat = {", end='') for i in rotation: print("{", end='') for j in i: print("{:0.6f}, ".format(j), end='') print("}, ", end='') print("}},") openvr.shutdown() return bs_poses, offset
from openvr.color_cube_actor import ColorCubeActor from sdl_app import SdlApp import sys import time import openvr """ Minimal sdl programming example which colored OpenGL cube scene that can be closed by pressing ESCAPE. """ print("OpenVR test program") if openvr.isHmdPresent(): print("VR head set found") if openvr.isRuntimeInstalled(): print("Runtime is installed") vr_system = openvr.init(openvr.VRApplication_Scene) print(openvr.runtimePath()) print(vr_system.getRecommendedRenderTargetSize()) print(vr_system.isDisplayOnDesktop()) if __name__ == "__main__": renderer = OpenVrGlRenderer(multisample=2) renderer.append(ColorCubeActor()) with SdlApp(renderer, "sdl2 OpenVR color cube") as app: app.run_loop()
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) # Loading config file self.config = None try: with open('config.json') as json_data: self.config = json.load(json_data) except EnvironmentError: # parent of IOError, OSError *and* WindowsError where available print('config.json not found, arbitrary id will be chosen.') if self.config != None: # 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_serial = self.vr.getStringTrackedDeviceProperty( i, openvr.Prop_SerialNumber_String).decode('utf-8') for device in self.config['devices']: if device_serial == device['serial']: device_name = device['name'] self.object_names[device['type']].append( device_name) self.devices[device_name] = vr_tracked_device( self.vr, i, device['type']) else: # 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 setUp(self): self.vr_sys = openvr.init(openvr.VRApplication_Other)
def __init__(s): s.vr_system = openvr.init(openvr.VRApplication_Scene) s.vr_compositor = openvr.VRCompositor() poses_t = openvr.TrackedDevicePose_t * openvr.k_unMaxTrackedDeviceCount s.poses = poses_t() s.w, s.h = s.vr_system.getRecommendedRenderTargetSize() SDL_Init(SDL_INIT_VIDEO) s.window = SDL_CreateWindow(b"test", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 100, 100, SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL) s.context = SDL_GL_CreateContext(s.window) SDL_GL_MakeCurrent(s.window, s.context) s.depth_buffer = glGenRenderbuffers(1) s.frame_buffers = glGenFramebuffers(2) s.texture_ids = glGenTextures(2) s.textures = [None] * 2 s.eyes = [openvr.Eye_Left, openvr.Eye_Right] s.cameraToProjection = [None] * 2 s.headToCamera = [None] * 2 s.col3 = [0, 0, 0, 1] vertexShader = compileShader( shader_string(""" layout (location=0) uniform mat4 cameraToProjection; layout (location=1) uniform mat4 modelToCamera; void main() { float angle = gl_VertexID * (3.14159*2/3); vec4 modelPos = vec4(cos(angle), sin(angle), -2, 1); gl_Position = cameraToProjection * (modelToCamera * modelPos); } """), GL_VERTEX_SHADER) fragmentShader = compileShader( shader_string(""" out vec4 colour; void main() { colour = vec4(1, 0, 0, 1); } """), GL_FRAGMENT_SHADER) s.program = compileProgram(vertexShader, fragmentShader) s.vertexBuffer = glGenVertexArrays(1) for eye in range(2): glBindFramebuffer(GL_FRAMEBUFFER, s.frame_buffers[eye]) glBindRenderbuffer(GL_RENDERBUFFER, s.depth_buffer) glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, s.w, s.h) glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, s.depth_buffer) glBindTexture(GL_TEXTURE_2D, s.texture_ids[eye]) glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, s.w, s.h, 0, GL_RGBA, GL_UNSIGNED_BYTE, None) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, s.texture_ids[eye], 0) texture = openvr.Texture_t() texture.handle = int(s.texture_ids[eye]) texture.eType = openvr.TextureType_OpenGL texture.eColorSpace = openvr.ColorSpace_Gamma s.textures[eye] = texture proj = s.vr_system.getProjectionMatrix(s.eyes[eye], 0.2, 500.0) s.cameraToProjection[eye] = numpy.matrix( [[proj.m[i][j] for i in range(4)] for j in range(4)], numpy.float32) camToHead = s.vr_system.getEyeToHeadTransform(s.eyes[eye]) s.headToCamera[eye] = numpy.matrix( [[camToHead.m[i][j] for i in range(3)] + [s.col3[j]] for j in range(4)], numpy.float32).I
def init(self, near=0.2, far=500.0, root=None, submit_together=True, msaa=0, replicate=1): """ Initialize OpenVR. This method will create the rendering buffers, the cameras associated with each eyes and the various anchors in the tracked space. It will also start the tasks responsible for the correct scheduling. This method should be called only once. * near and far parameters can be used to specify the near and far planes of the cameras. * root parameter, when not None, is used as the root node to which the tracked space will attached. Otherwise the tracked space is attached to render. * submit_together specifies if each eye buffer is submitted just after being rendered or both at once. * msaa specifies the multisampling anti-aliasing level to use, set to 0 to disable. * replicate specifies which eye is replicated on the application window. 0: No replication, 1: left eye, 2: right eye. """ self.submit_together = submit_together poses_t = openvr.TrackedDevicePose_t * openvr.k_unMaxTrackedDeviceCount self.poses = poses_t() self.vr_system = openvr.init(openvr.VRApplication_Scene) width, height = self.vr_system.getRecommendedRenderTargetSize() self.compositor = openvr.VRCompositor() self.vr_input = openvr.VRInput() if self.compositor is None: raise Exception("Unable to create compositor") if root is None: root = render self.tracking_space = root.attach_new_node('tracking-space') self.hmd_anchor = self.tracking_space.attach_new_node('hmd-anchor') self.left_eye_anchor = self.hmd_anchor.attach_new_node('left-eye') self.right_eye_anchor = self.hmd_anchor.attach_new_node('right-eye') self.projection_left = self.coord_mat_inv * self.convert_mat( self.vr_system.getProjectionMatrix(openvr.Eye_Left, near, far)) self.projection_right = self.coord_mat_inv * self.convert_mat( self.vr_system.getProjectionMatrix(openvr.Eye_Right, near, far)) left_cam_node = self.create_camera('left-cam', self.projection_left) right_cam_node = self.create_camera('right-cam', self.projection_right) self.left_cam = self.left_eye_anchor.attach_new_node(left_cam_node) self.right_cam = self.right_eye_anchor.attach_new_node(right_cam_node) self.left_texture = self.create_renderer('left-buffer', self.left_cam, width, height, msaa, self.left_cb) self.right_texture = self.create_renderer('right-buffer', self.right_cam, width, height, msaa, self.right_cb) self.disable_main_cam() if replicate == 1: if self.verbose: print("Replicating left eye") self.replicate(self.left_texture) elif replicate == 2: if self.verbose: print("Replicating right eye") self.replicate(self.right_texture) else: if self.verbose: print("Eye replication disabled") self.init_action() taskMgr.add(self.update_poses_task, "openvr-update-poses", sort=-1000)
import time import openvr import cflib.crtp from cflib.crazyflie import Crazyflie from cflib.crazyflie.log import LogConfig from cflib.crazyflie.syncCrazyflie import SyncCrazyflie from cflib.crazyflie.syncLogger import SyncLogger # URI to the Crazyflie to connect to uri0 = 'radio://0/80/2M' uri1 = 'radio://0/80/2M/E7E7E7E701' print('Opening') vr = openvr.init(openvr.VRApplication_Other) print('Opened') # Find first controller or tracker controllerId = None poses = vr.getDeviceToAbsoluteTrackingPose(openvr.TrackingUniverseStanding, 0, openvr.k_unMaxTrackedDeviceCount) for i in range(openvr.k_unMaxTrackedDeviceCount): if poses[i].bPoseIsValid: device_class = vr.getTrackedDeviceClass(i) if device_class == openvr.TrackedDeviceClass_Controller or \ device_class == openvr.TrackedDeviceClass_GenericTracker: controllerId = i break if controllerId is None:
import sys import time import openvr openvr.init(openvr.VRApplication_Overlay) ids = [] leftId = openvr.VRSystem().getTrackedDeviceIndexForControllerRole( openvr.TrackedControllerRole_LeftHand) rightId = openvr.VRSystem().getTrackedDeviceIndexForControllerRole( openvr.TrackedControllerRole_RightHand) def to_percent(value): return str(value * 100)[0:2] def writefile(left, right): datafile = open("../storage/ovr.txt", "w") left = to_percent(left) right = to_percent(right) datafile.write("{:2s}.{:2s}".format(str(left), str(right))) datafile.close() while True: overlay = openvr.IVROverlay() notification = openvr.IVRNotifications() left_battery = openvr.VRSystem().getFloatTrackedDeviceProperty( leftId, openvr.Prop_DeviceBatteryPercentage_Float) right_battery = openvr.VRSystem().getFloatTrackedDeviceProperty(
def __init__(self, topic_prefix): self.vr_system = openvr.init(openvr.VRApplication_Utility) self.topic_prefix = topic_prefix self.publishers = {}
def init(self, near=0.2, far=500.0, root=None, submit_together=True, msaa=0, replicate=1, srgb=None, hidden_area_mesh=True): """ Initialize OpenVR. This method will create the rendering buffers, the cameras associated with each eyes and the various anchors in the tracked space. It will also start the tasks responsible for the correct scheduling. This method should be called only once. * near and far parameters can be used to specify the near and far planes of the cameras. * root parameter, when not None, is used as the root node to which the tracked space will attached. Otherwise the tracked space is attached to render. * submit_together specifies if each eye buffer is submitted just after being rendered or both at once. * msaa specifies the multisampling anti-aliasing level to use, set to 0 to disable. * replicate specifies which eye is replicated on the application window. 0: No replication, 1: left eye, 2: right eye. * srgb : If None, OpenVR will detect the color space from the texture format. If set to True, sRGB color space will be enforced; if set to False, linear color space will be enforced. * hidden_area_mesh : If True, a mask will be applied on each camera to cover the area not seen from the HMD This will trigger the early-z optimization on the GPU and avoid rendering unseen pixels. """ self.submit_together = submit_together if srgb is None: self.color_space = openvr.ColorSpace_Auto else: if srgb: self.color_space = openvr.ColorSpace_Gamma else: self.color_space = openvr.ColorSpace_Linear # Create a OpenVR array that will store the pose of all the tracked devices. poses_t = openvr.TrackedDevicePose_t * openvr.k_unMaxTrackedDeviceCount self.poses = poses_t() # Initialise OpenVR and retrieve the main components self.vr_system = openvr.init(openvr.VRApplication_Scene) self.vr_applications = openvr.VRApplications() width, height = self.vr_system.getRecommendedRenderTargetSize() self.compositor = openvr.VRCompositor() self.vr_input = openvr.VRInput() if self.compositor is None: raise Exception("Unable to create compositor") # Create the tracking space anchors if root is None: root = self.base.render self.tracking_space = root.attach_new_node('tracking-space') self.hmd_anchor = self.tracking_space.attach_new_node('hmd-anchor') self.left_eye_anchor = self.hmd_anchor.attach_new_node('left-eye') self.right_eye_anchor = self.hmd_anchor.attach_new_node('right-eye') # Create the projection matrices for the left and right camera. # TODO: This should be updated in the update task in the case the user update the IOD self.projection_left = self.coord_mat_inv * self.convert_mat( self.vr_system.getProjectionMatrix(openvr.Eye_Left, near, far)) self.projection_right = self.coord_mat_inv * self.convert_mat( self.vr_system.getProjectionMatrix(openvr.Eye_Right, near, far)) # Create the cameras and attach them in the tracking space left_cam_node = self.create_camera('left-cam', self.projection_left) right_cam_node = self.create_camera('right-cam', self.projection_right) self.left_cam = self.left_eye_anchor.attach_new_node(left_cam_node) self.right_cam = self.right_eye_anchor.attach_new_node(right_cam_node) # Create the renderer linked to each camera self.left_texture = self.create_renderer('left-buffer', self.left_cam, width, height, msaa, self.left_cb) self.right_texture = self.create_renderer('right-buffer', self.right_cam, width, height, msaa, self.right_cb) # The main camera is useless, so we disable it self.disable_main_cam() if hidden_area_mesh: # If the hidden area mesh is used, assign a mask on each camera to hide the opposite mesh left_cam_node.set_camera_mask(BitMask32.bit(0)) right_cam_node.set_camera_mask(BitMask32.bit(1)) self.attach_hidden_area_mesh(openvr.Eye_Left, self.left_eye_anchor, 1) self.attach_hidden_area_mesh(openvr.Eye_Right, self.right_eye_anchor, 0) if replicate == 1: if self.verbose: print("Replicating left eye") self.replicate(self.left_texture) elif replicate == 2: if self.verbose: print("Replicating right eye") self.replicate(self.right_texture) else: if self.verbose: print("Eye replication disabled") if hasattr(self, 'init_action'): print( "WARNING: init_action() is deprecated and will be removed in a future release" ) self.init_action() # Launch the main task that will synchronize Panda3D with OpenVR # TODO: The sort number should be configurable and by default be placed after the gc tasks. self.task = taskMgr.add(self.update_poses_task, "openvr-update-poses", sort=-1000)
def init(): """ Initialises openvr, returns a handle for use in all openvr calls """ return openvr.init(openvr.VRApplication_Other)
j.buttons = [ d['trigger'] == 1.0, d['trackpad_touched'], d['trackpad_pressed'], d['menu_button'], d['grip_button'] ] new_msg = prev_unPacketNum != d['unPacketNum'] return new_msg, j if __name__ == '__main__': print("===========================") print("Initializing OpenVR...") retries = 0 max_init_retries = 4 while retries < max_init_retries: try: openvr.init(openvr.VRApplication_Utility) break except openvr.OpenVRError as e: print("Error when initializing OpenVR (try {} / {})".format( retries + 1, max_init_retries)) print(e) retries += 1 time.sleep(2.0) else: print("Could not initialize OpenVR, aborting.") print("Make sure the system is correctly plugged, you can also try") print("to do:") print("killall -9 vrcompositor vrmonitor vrdashboard") print("Before running this program again.") exit(0)
#!/usr/bin/env python3 # Scripts acquiring the base-stations position from a running SteamVR system # At least one object, HDM controller or tracker, should be tracked in order # for the script to work. # # The output can be directly copy-pasted in the Crazyflie firmware lighthouse.c # lighthouse deck driver. import sys import openvr CENTER_AROUND_CONTROLLER = False print("Openning OpenVR") vr = openvr.init(openvr.VRApplication_Other) print("OpenVR Oppened") devices = {} poses = vr.getDeviceToAbsoluteTrackingPose(openvr.TrackingUniverseStanding, 0, openvr.k_unMaxTrackedDeviceCount) if CENTER_AROUND_CONTROLLER: offset = None # Acquire offset for i in range(openvr.k_unMaxTrackedDeviceCount): if poses[i].bPoseIsValid: device_class = vr.getTrackedDeviceClass(i) if device_class == openvr.TrackedDeviceClass_Controller or \ device_class == openvr.TrackedDeviceClass_GenericTracker: pose = poses[i].mDeviceToAbsoluteTracking offset = [pose[0][3], pose[1][3], pose[2][3]]
def initializePositioning(self): self.vrSystem = openvr.init(openvr.VRApplication_Other) self.baseStationController = BaseStationController(self)
def take_steamvr_images(save_dir, num_images, delay_between_images): plt.show() openvr.init(openvr.VRApplication_Scene) convert_coordinate_system = np.identity(4) convert_coordinate_system[:3, :3] = Rotation.from_euler( 'XYZ', (180, 0, 0), degrees=True).as_matrix() device = openvr.k_unTrackedDeviceIndex_Hmd num_cameras = openvr.VRSystem().getInt32TrackedDeviceProperty( device, openvr.Prop_NumCameras_Int32) camera_to_head_mat = (openvr.HmdMatrix34_t * num_cameras)() openvr.VRSystem().getArrayTrackedDeviceProperty( device, openvr.Prop_CameraToHeadTransforms_Matrix34_Array, openvr.k_unHmdMatrix34PropertyTag, camera_to_head_mat, 48 * num_cameras) cam = openvr.VRTrackedCamera() cam_handle = cam.acquireVideoStreamingService(device) width, height, buffer_size = cam.getCameraFrameSize( device, openvr.VRTrackedCameraFrameType_MaximumUndistorted) fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ax.set_xlabel('x axis - metres') ax.set_ylabel('z axis - metres') ax.set_zlabel('y axis - metres') ax.set_xlim(-0.5, 0.5) ax.set_ylim(-0.5, 0.5) ax.set_zlim(0, 1) save_dir = ColmapFolder(save_dir) db = COLMAPDatabase.connect(save_dir.database_path) db.create_tables() init_params = np.array( (420.000000, (width / num_cameras) / 2, height / 2, 0.000000)) camera_model = CAMERA_MODEL_NAMES['SIMPLE_RADIAL'] cameras = {} camera_to_head_transforms = {} for i in range(num_cameras): cam_id = db.add_camera(camera_model.model_id, width / 2, height, init_params) camera_to_head_transforms[cam_id] = hmd_matrix_to_numpy( camera_to_head_mat[i]) cameras[cam_id] = Camera(id=cam_id, model=camera_model.model_name, width=width / num_cameras, height=height, params=init_params) poses = [] # Let waitGetPoses populate the poses structure the first time cam_positions = [] images = [] for i in range(num_images): poses, game_poses = openvr.VRCompositor().waitGetPoses(poses, None) hmd_pose = poses[openvr.k_unTrackedDeviceIndex_Hmd] if not hmd_pose.bPoseIsValid: print("Pose not valid") continue world_to_head = hmd_matrix_to_numpy(hmd_pose.mDeviceToAbsoluteTracking) world_to_cams = { id_: world_to_head @ head_to_cam @ convert_coordinate_system for (id_, head_to_cam) in camera_to_head_transforms.items() } image_buffer = (ctypes.c_ubyte * buffer_size)() try: cam.getVideoStreamFrameBuffer( cam_handle, openvr.VRTrackedCameraFrameType_MaximumUndistorted, image_buffer, buffer_size) except: print("Error getting video stream buffer") continue image_array = np.array(image_buffer) image_array = image_array.reshape((height, width, 4)) image_array = image_array[:, :, 0:3] image_array = np.clip(image_array, 0, 255) for j, (cam_id, world_to_cam) in enumerate(world_to_cams.items()): image = Image.fromarray( image_array[:, int(width / num_cameras) * j:int(width / num_cameras) * (j + 1), :]) name = f"{i:03d}_cam{j}.jpg" image.save(save_dir.images_path / name) image_obj = read_write_model.Image( camera_id=cam_id, name=name, transformation_matrix=world_to_cam) images.append(image_obj) draw_axes(ax, transform_mat=world_to_cam) fig.show() fig.canvas.draw() fig.canvas.flush_events() time.sleep(delay_between_images) print(f"Picture taken :{i}") image_dict = {} print("All pictures taken") with open(save_dir.geo_reg_path, 'w') as geo_reg_file: for image in images: image_id = db.add_image(image=image) image.id = image_id image_dict[image_id] = image geo_reg_file.write( f"{name} {' '.join(map(str, image.transformation_matrix[0:3, 3]))}\n" ) read_write_model.write_model(cameras, image_dict, {}, save_dir.sparse_path, '.txt') db.commit() db.close() print("Metadata saved") openvr.shutdown() plt.show()
def vive(label, filename, video_length_in_s, process_name, autoplay_enabled, overwrite_enabled, acr): """ Obtains and saves the data captured by the HTC Vive in a JSON file. :param label: The label of the subject. :param filename: The filename of the video. :param video_length_in_s: The length of the video in s. :param process_name: The name of the process to monitor. :param autoplay_enabled: Whether automatic playback of the video is enabled or not. :param overwrite_enabled: Whether overwriting the current dataset is enabled or not. """ video_playing_started = False # Necessary for getting information about playback state of video data = {'filename': filename, 'video_length_in_s': float(video_length_in_s), 'hmd': 'vive', 'pitch_yaw_roll_data_hmd': []} if acr: data["acr"] = 0 if autoplay_enabled: # Sleep a few seconds until the video is completely loaded by Whirligig if process_name == "Whirligig64bit.exe": helpers.autoplay_sleep(float(4)) # Adjust value based on your computing power (between 4 and 6 is normal) else: print("If the player has loaded the video, press the SPACE key to start the measurement.") # Initialize OpenVR as background application, so that the player won't crash. openvr.init(openvr.VRApplication_Background) while video_playing_started == False: if autoplay_enabled: pyautogui.press("space") start_time = timer() print("Recording of Pitch/Yaw/Roll/Time data will start now..") video_playing_started = True else: if keyboard.is_pressed("space"): start_time = timer() print("Recording of Pitch/Yaw/Roll/Time data will start now...") video_playing_started = True try: pyautogui.press("r") # Press R key to assure the user starts watching the video at initial position current_playback_state = timer() - start_time pitch, yaw, roll = getPYRDataFromVive() # Define the current position of the user (very first yaw value) as initial position initial_yaw = yaw # Get Head orientation data from Vive in loop until the playback is finished while video_length_in_s > current_playback_state: pitch, yaw, roll = getPYRDataFromVive() current_playback_state = timer() - start_time # Adjust the yaw value according to the very first recorded yaw value yaw = helpers.shift_yaw(yaw, initial_yaw) if current_playback_state is not None: data["pitch_yaw_roll_data_hmd"].append({'pitch': pitch, 'yaw': yaw, 'roll': roll, 'sec': current_playback_state}) # By adjusting this value, you can set the recording frequency (currently 200Hz). time.sleep(float(0.005)) if acr: data["acr"] = helpers.get_acr_by_cmd_input() helpers.write_to_json(label, data, overwrite_enabled) openvr.shutdown() print("Measurement done. Opening the next video if available.") except KeyboardInterrupt: # Break if ctrl+c is pressed openvr.shutdown() print("Current Measurement is interrupted and will not be saved. The program will exit now.")