def main(): global wingl global wingr viz.cam.setHandler(vizcam.KeyboardCamera()) myo.init() gyrolist = [[0,0,0]] viz.setMultiSample(4) viz.fov(150) wingl = viz.addChild('basketball.osgb') wingl.setScale([10,0.3,1]) wingl.setCenter([100,100,100]) wingl.setEuler([0,90,0]) wingl.collideSphere(0.5) lStartPOS = [ 0, 2.5, 2 ] wingl.setPosition( lStartPOS ) wingr = viz.addChild('basketball.osgb') wingr.setScale([10,0.3,1]) wingr.setCenter([100,100,100]) wingr.setEuler([0,90,0]) wingr.collideSphere(0.5) rStartPOS = [ 0, 2.5, 2 ] wingr.setPosition( rStartPOS ) #viz.MainView.setPosition([0,2,-15]) hub = myo.Hub() hub.set_locking_policy(myo.locking_policy.none) hub.run(1000, Listener()) vizact.ontimer(0.01 ,updateMyo, [gy, gy2, gy3, wingl, orx, ory, orz, orw, or1x, or1y, or1z, or1w, wingr])
def set_graphics_quality(): """Vsync ON; Multisample 8, glFinish ON.""" # Just to make sure vertical sync is ON, against tearing. viz.vsync(1) # Helps reduce latency. viz.setOption('viz.glFinish', 1) viz.setMultiSample(8)
def _setup_vizard_configuration(self): """ Setup some stuff for Vizard """ viz.setMultiSample(cfg.multi_sample_level) # Disable the head light for better lighting viz.MainView.getHeadLight().disable() # Disable the mouse with controller controls. # Without deactivation, the controller would move the mouse. if cfg.control_scheme == "controller": # Trap the mouse in the graphics window. viz.mouse.setTrap(viz.ON) # Make the mouse invisible. viz.mouse.setVisible(viz.OFF) # Display models for the trackers tracker_names = ['r_hand_tracker', 'l_hand_tracker'] for tracker_name in tracker_names: controller = vizconnect.getRawTracker(tracker_name) if cfg.control_scheme == "steamvr": if not isinstance(controller, viz.VizGroup): # Display HTC Vive controller model if the controller is connected model = controller.addModel() viz.link(controller, model) elif cfg.control_scheme == "controller": # Display a sphere, when controlled with a gamepad model = vizshape.addSphere(.05, color=viz.GRAY) viz.link(controller, model)
def recordViewAnimation(): ### replace with your own application setup import viz import vizcam import vizact viz.setMultiSample(4) viz.go() vizcam.WalkNavigate() piazza = viz.addChild("piazza.osgb") ### ### Add this at the bottom ''' Create an AnimationPathRecorder and link it to any node, which needs to have it's transformation documented. If 'start' is set to True the recording will start automatically, otherwise you need to start manually. you can specify the file name under which the animation will be saved. '.txt' is automatically added. ''' rec = AnimationPathRecorder(start=False) viz.link(viz.MainView, rec) # toggle path recording and saving finished recording to a file named 'test_animation.txt' def toggleRecord(rec): if rec.isRunning(): rec.stop() rec.writeToFile("test_animation") print "Animation path saved to test_animation.txt" else: rec.start() print "Animation path recording started." vizact.onkeydown('r', toggleRecord, rec)
def __init__(self): viz.EventClass.__init__(self) self.EH = 1.2 Proj_Dist = 1.0 #front projection distance to Eye Proj_V_F = 1.115 #vertical extent of projection (m) Proj_H_F = 1.985 #1.96#horizontal extent of projection (m) Proj_HfG = .665 #Front projection height from ground. FB = Proj_HfG #FrontBottom FT = Proj_HfG + Proj_V_F #FrontTop FL = -Proj_H_F / 2 #Front Left FR = Proj_H_F / 2 #Front Right FC0 = FL, FB, Proj_Dist # Front Wall: FC0,FC1,FC2,FC3 FC1 = FR, FB, Proj_Dist FC2 = FL, FT, Proj_Dist FC3 = FR, FT, Proj_Dist self.FrontWall = vizcave.Wall(upperLeft=FC2, upperRight=FC3, lowerLeft=FC0, lowerRight=FC1, name='Front Wall') #Create front wall viz.setMultiSample(8) #set anti-aliasing #Initialize graphics window viz.go() # viz.eyeheight(1.2) #for monitor in viz.window.getMonitorList(): # print monitor.name # print ' ',monitor viz.window.setFullscreenMonitor(2) viz.window.setFullscreen(viz.ON) self.cave = vizcave.Cave(stereo=0) self.cave.addWall(self.FrontWall) #,window=self.frontWindow) # print ("1_N: ", self.cave.getNearPlane()) #default is [.1, -1.] # print ("1_F: ", self.cave.getFarPlane()) #set near and far plane. self.cave.setNearPlane(1.0) self.cave.setFarPlane(100.0) view = viz.MainView self.track = viztracker.Keyboard6DOF() #tracker object self.track.setPosition(0, self.EH, 0) viz.link(self.track, view) #linked to mainview self.cave.setTracker(pos=self.track) ##Create CaveView object for manipulating the entire cave environment ##The caveorigin is a node that can be adjusted to move the entire cave around the virtual environment, it needs a tracker object to initialise it. self.caveview = vizcave.CaveView(self.track)
def init_settings(mainSceneWindow, cameraWindow, cameraWindowView, cam, pause_screen, nunchuck_disconnect_screen, message_screen, wiimote, nunchuck_wiimote, should_it_run): viz.MainWindow.visible(viz.OFF) #Hago invisible la main window viz.setMultiSample(8) # FSAA de 8 viz.fogcolor = viz.BLACK # Color de sombra = negro viz.fog(0.15) # Agrega sombra de tipo exponencial viz.collision(viz.ON) # Habilita colisiones en el mundo viz.phys.enable() # Habilita la fisica #Desabilita mouse viz.mouse.setOverride(viz.ON) #Mouse invisible viz.mouse.setVisible(viz.OFF) #Subventana que renderea viz.MainWindow mainSceneWindow = viz.addWindow() mainSceneWindow.setSize(0.7,1) mainSceneWindow.setPosition(0,1) mainSceneWindow.fov(40, 1.3) # Coloca el FOV de la ventana principal en la actual con los valores de default (40 grados verticales, 1.3 aspect ratio) #Creando una ventana y un punto de vista para la camara cameraWindow = viz.addWindow(pos =[.7,1],size=(0.4,1)) #Creando la ventana cameraWindowView = viz.addView() #Creando un viewpoint cameraWindowView.setScene(2) #Poniendo la nueva ventana en la escena 2 cameraWindow.setView(cameraWindowView) #Ligando el viewpoint con la nueva ventana #Vincular camara web a plugin de AR cam = ar.addWebCamera(window=cameraWindow) #Agregando una camara en la ventada nueva # Configuracion de mensajes de la pantalla message_screen = viz.addTexQuad(parent=viz.SCREEN, pos=[0.5,0.5,1], scale=[12.80,10.24,1]) pause_screen = viz.add("PAUSA.png") nunchuck_disconnect_screen = viz.add("NUNCHUCK_DISCONNECTED.png") message_screen.texture(pause_screen) message_screen.visible(viz.OFF) #Cuando should_it_run sea False, viz.ON es el valor a usar. # Conecta al primer wiimote disponible wiimote = wii.addWiimote() # Prende el LED 1 del wiimote wiimote.led = wii.LED_1 # Obten el nunchuck del wiimote nunchuck_wiimote = wiimote.nunchuk #Determines wheter the program should run or not. #It will run if the Nunchuck is connected; otherwise, it won't. should_it_run = True #Ensures that the program won't run without the NUNCHUCK plug'd in. if(wiimote.getExtension() == wii.EXT_NUNCHUK): should_it_run = True else: print "Please plug-in the Wii NUNCHUCK." message_screen.texture(nunchuck_disconnect_screen) message_screen.visible(viz.ON) should_it_run = False return mainSceneWindow, cameraWindow, cameraWindowView, cam, pause_screen, nunchuck_disconnect_screen, message_screen, wiimote, nunchuck_wiimote, should_it_run
def main(): viz.vsync(viz.ON) viz.window.setFullscreenMonitor([2]) viz.setMultiSample(4) viz.MainWindow.clip(0.01, 200) viz.go(viz.FULLSCREEN) environment = viz.addChild("piazza.osgb") environment.setPosition(2.75, 0, -0.75) mocap = phasespace.Phasespace() head = mocap.get_rigidTracker("hmd") # DOES NOT ACCOUNT FOR RIGID BODY OFFSET DURING RESET # mocap.track_rigid('Resources/hmd-nvisMount.rb', center_markers=(1,2)) head.link_pose(viz.MainView) # glove = mocap.track_points([8, 9, 10]) paddle = mocap.track_rigid({17: (0, 0, 1), 19: (0, 0, 0), 20: (1, 0, 0), 22: (0, 1, 0)}) mocap.start_thread() # mocap.start_timer() def log_mocap(timer_id): # print 'glove#9 pos {0[1]:.2f} {0[1]:.2f} {0[2]:.2f}'.format(*glove.get_marker(9)) print "head pos {0[0]:.2f} {0[1]:.2f} {0[2]:.2f}, quat {1[0]:.3f} {1[1]:.3f} {1[2]:.3f} {1[3]:.3f}".format( *head.get_pose() ) print "main " + str(viz.MainView.getPosition()) # print 'paddle pos {0[0]:.2f} {0[1]:.2f} {0[2]:.2f}, quat {1[0]:.3f} {1[1]:.3f} {1[2]:.3f} {1[3]:.3f}'.format(*paddle.get_pose()) viz.callback(viz.TIMER_EVENT, log_mocap) viz.starttimer(0, 1, viz.FOREVER) def keydown(key): if key == "h": head.reset() if key == "H": head.save() elif key == "1": print "Marker Pos: " + str(mocap.get_MarkerPos(1)) viz.callback(viz.KEYDOWN_EVENT, keydown)
def __setupVizParams__(self): #Just playing here# #viz.setMultiSample(8) #viz.fov(120) #Check monitor refresh rate and set stereo mode accordingly# monitor_RefreshRate = viz.getOption('viz.monitor.refresh_rate', type=int) #if(119 <= monitor_RefreshRate): #Turn on the physics engine viz.phys.enable() viz.window.setFullscreenMonitor(2) viz.setMultiSample(8) viz.go(viz.FULLSCREEN | viz.QUAD_BUFFER) print "here"
def main(): viz.setOption('viz.fullscreen.monitor', 1) viz.setOption('viz.window.width', 2 * 640) viz.setOption('viz.window.height', 480) viz.setMultiSample(4) viz.MainWindow.clip(0.01, 500) vizconfig.register(nvis.nvisorSX111()) viz.go(viz.FULLSCREEN) piazza = viz.addChild('piazza.osgb') mocap = phasespace.Mocap('192.168.1.230') head = mocap.track_rigid('Resources/hmd-nvis.rb', center_markers=(0, 5)) head.link_pose(viz.MainView) glove = mocap.track_points([8, 9, 10]) paddle = mocap.track_rigid({ 17: (0, 0, 1), 19: (0, 0, 0), 20: (1, 0, 0), 22: (0, 1, 0), }) mocap.start_thread() #mocap.start_timer() def log_mocap(timer_id): print 'glove#9 pos {0[1]:.2f} {0[1]:.2f} {0[2]:.2f}'.format( *glove.get_marker(9)) print 'head pos {0[0]:.2f} {0[1]:.2f} {0[2]:.2f}, quat {1[0]:.3f} {1[1]:.3f} {1[2]:.3f} {1[3]:.3f}'.format( *head.get_pose()) print 'paddle pos {0[0]:.2f} {0[1]:.2f} {0[2]:.2f}, quat {1[0]:.3f} {1[1]:.3f} {1[2]:.3f} {1[3]:.3f}'.format( *paddle.get_pose()) viz.callback(viz.TIMER_EVENT, log_mocap) viz.starttimer(0, 1, viz.FOREVER) def keydown(*args): head.reset() paddle.reset() viz.callback(viz.KEYDOWN_EVENT, keydown)
def InitVive(): viz.setMultiSample(8) # Setup SteamVR HMD hmd = steamvr.HMD() if not hmd.getSensor(): sys.exit('SteamVR HMD not detected') navigationNode = viz.addGroup() viewLink = viz.link(navigationNode, viz.MainView) viewLink.preMultLinkable(hmd.getSensor()) # setting starting camera position and rotation of the view navigationNode.setEuler(180, 0, 0) navigationNode.setPosition(-0, 0.3, 3.0) # setting starting camera position and rotation viz.MainView.setEuler([180, 0, 0]) viz.MainView.setPosition([0, 1.3, 4])
def main(): viz.setOption('viz.fullscreen.monitor', 1) viz.setOption('viz.window.width', 2 * 640) viz.setOption('viz.window.height', 480) viz.setMultiSample(4) viz.MainWindow.clip(0.01, 500) vizconfig.register(nvis.nvisorSX111()) viz.go(viz.FULLSCREEN) piazza = viz.addChild('piazza.osgb') mocap = phasespace.Mocap('192.168.1.230') head = mocap.track_rigid('Resources/hmd-nvis.rb', center_markers=(0, 5)) head.link_pose(viz.MainView) glove = mocap.track_points([8, 9, 10]) paddle = mocap.track_rigid({ 17:(0, 0, 1), 19:(0, 0, 0), 20:(1, 0, 0), 22:(0, 1, 0), }) mocap.start_thread() #mocap.start_timer() def log_mocap(timer_id): print 'glove#9 pos {0[1]:.2f} {0[1]:.2f} {0[2]:.2f}'.format(*glove.get_marker(9)) print 'head pos {0[0]:.2f} {0[1]:.2f} {0[2]:.2f}, quat {1[0]:.3f} {1[1]:.3f} {1[2]:.3f} {1[3]:.3f}'.format(*head.get_pose()) print 'paddle pos {0[0]:.2f} {0[1]:.2f} {0[2]:.2f}, quat {1[0]:.3f} {1[1]:.3f} {1[2]:.3f} {1[3]:.3f}'.format(*paddle.get_pose()) viz.callback(viz.TIMER_EVENT, log_mocap) viz.starttimer(0, 1, viz.FOREVER) def keydown(*args): head.reset() paddle.reset() viz.callback(viz.KEYDOWN_EVENT, keydown)
def main(): global wingl # global wingr viz.cam.setHandler(vizcam.KeyboardCamera()) myo.init() gyrolist = [[0,0,0]] viz.setMultiSample(4) # wingl = viz.addChild('basketball.osgb') wingl.setScale([10,0.3,1]) wingl.setCenter([100,100,100]) wingl.setEuler([0,90,0]) wingl.collideSphere(0.5) lStartPOS = [ 0, 2.5, 2 ] wingl.setPosition( lStartPOS ) # wingr = viz.addChild('basketball.osgb') # wingr.setScale([10,0.3,1]) # wingr.setCenter([100,100,100]) # wingr.setEuler([0,90,0]) # wingr.collideSphere(0.5) # rStartPOS = [ 0, 2.5, 2 ] # wingr.setPosition( rStartPOS ) #viz.MainView.setPosition([0,2,-15]) hub = myo.Hub() hub.set_locking_policy(myo.locking_policy.none) hub.run(1000, Listener()) vizact.ontimer(0.01 ,updateMyo, [gy, gy2, gy3, wingl, orx, ory, orz, orw, or1x, or1y, or1z, or1w]) vizact.onkeydown('p', hub.shutdown) FileReader() initializeObjectFiles() initializeLocations() vizact.ontimer(0.1, update) vizact.onkeydown(' ', statusUpdate) vizact.onkeydown('s', hub.shutdown) # viz.AVIRecorder.maxWidth = 1920; # viz.AVIRecorder.maxHight = 1080; vizact.onkeydown('b', viz.window.startRecording, 'myo_capture.avi' ) vizact.onkeydown('e', viz.window.stopRecording )
def setUp(): global currentCondition viz.setMultiSample(8) initGlobals() currentCondition = viz.choose('Select condition:', CONDITION_CHOICES) print "CurCondition:", currentCondition setFlags() # setUpRecording() # # if YOKE_F: # setUpYoke() # # if not FLYING_F: # setUpHelicopter() # # if(not confirmStates(currentCondition)): # viz.quit() # finish() #TODO make it so that on failure no files are created. # return # # #configData() if USE_HMD_F: setUpHMD() if not FLYING_F: setHeliInitPos() else: viz.go() viz.MainView.setPosition(START_POSITION_HELI) setUpWorld() setUpChild() setUpSound()
def __init__(self, filename=''): '''Opens and interprets configuration files for running experiments. This constructor opens both the system config (as defined by the <platform>.cfg file) and the experiment config (as defined by the given filename). Both configurations must conform the specs given in SYSTEM.ini and experiment.ini respectively. It also initializes the system as specified in the system config. ''' self.exp = self.create_exp_config(filename) self.sys = self.create_sys_config() for path in self.sys['set_path']: viz.res.addPath(path) viz.window.setFullscreenMonitor(self.sys['displays']) viz.setMultiSample(self.sys['antiAliasPasses']) viz.MainWindow.clip(0.01, 200) self.writables = [] self.writer = None self.mocap = None self.body_camera = None self._setup_hmd() self._setup_recorder() self._setup_eyetracking() self._setup_phasespace() self._setup_hiball() self.writables.append(self.mocap) self.writables.append(self.body_camera) if self.sys['use_fullscreen']: viz.go(viz.FULLSCREEN) else: viz.go()
def main(): # Initialize window viz.setMultiSample(8) viz.go() # Setup SteamVR HMD hmd = steamvr.HMD() if not hmd.getSensor(): sys.exit('SteamVR HMD not detected') # Setup navigation node and link to main view navigationNode = viz.addGroup() viewLink = viz.link(navigationNode, viz.MainView) viewLink.preMultLinkable(hmd.getSensor()) # Load environment gallery = vizfx.addChild('gallery.osgb') gallery.hint(viz.OPTIMIZE_INTERSECT_HINT) gallery.disable(viz.SHADOW_CASTING) #Create skylight viz.MainView.getHeadLight().disable() sky_light = viz.addDirectionalLight(euler=(0,90,0), color=viz.WHITE) sky_light.setShadowMode(viz.SHADOW_DEPTH_MAP) #Start the Leap Motion! handGenerator = LeapListener() handGenerator.startLeap(hmd.getSensor()) # Add controllers for controller in steamvr.getControllerList(): # Create model for controller controller.model = controller.addModel(parent=navigationNode) controller.model.disable(viz.INTERSECTION) viz.link(controller, controller.model)
def display(self): """ Initialize the display Mode selection: 0 - Regular computer 1 - 3D TV 2 - Oculus rift """ if self.displayMode == 0: viz.setMultiSample(4) viz.fov(60) viz.window.setSize([1280,720]) viz.go() viz.window.setFullscreenMonitor(1) # viz.go(viz.FULLSCREEN) #viz.FULLSCREEN elif self.displayMode == 1: viz.setMultiSample(4) viz.go(viz.STEREO_HORZ | viz.FULLSCREEN) elif self.displayMode == 2: viz.go(viz.STEREO_HORZ) viz.setMultiSample(16) viz.window.setSize([1280,720]) KEYS = { 'reset' : 'r', 'camera' : 'c'} # Helps reduce latency #do not use ? makes things worse. #viz.setOption('viz.glFinish',1) elif self.displayMode == 3: viz.setMultiSample(4) viz.fov(60) viz.go(viz.FULLSCREEN) #viz.FULLSCREEN viz.window.setFullscreenMonitor(2) # Initial direction of main view viz.MainView.setEuler([0,0,0]) viz.MainView.setPosition([0,0,-3], viz.ABS_GLOBAL)
def __setupSystem(self): # Set up the wiimote ################################################################ ################################################################ ## Misc. Design specific items here. if (self.sysCfg['use_wiimote']): # Create wiimote holder self.wiimote = 0 self._connectWiiMote() #Set up the HMD if self.sysCfg['use_hmd']: self.hmd = HMD(self.sysCfg['hmd'], True) self.use_HMD = True else: self.hmd = HMD(self.sysCfg['hmd'], False) self.use_HMD = False viz.window.setFullscreenMonitor(self.sysCfg['displays']) viz.setMultiSample(self.sysCfg['antiAliasPasses']) viz.MainWindow.clip(0.01, 200) viz.vsync(1) viz.setOption("viz.glfinish", 1) viz.setOption("viz.dwm_composition", 0) #Set up recording if self.sysCfg['use_DVR'] == 1: self.use_DVR = True else: self.use_DVR = False self.writer = None #Will get initialized later when the system starts #Set up the eye tracking callibration/configuration (eyeTrackingCal) if self.sysCfg['use_eyetracking']: self.use_eyeTracking = True if self.sysCfg['hmd']['type'] == 'nvis': import EyeTrackerCalibrationNVIS_MT self.eyeTrackingCal = EyeTrackerCalibrationNVIS_MT.EyeTrackerCalibrationNVIS( self.sysCfg['eyetracker']['settingsDir']) self.eyeTrackingCal.changeDisplayNum( self.sysCfg['displays'][0]) print "Eye tracking enabled using NVIS visor" else: print "Error in VRLabConfig: Eye-tracking not setup for this HMD." sys.exit(1) else: self.use_eyeTracking = False self.eyeTrackingCal = None self.mocap = None self.bodyCam = None if self.sysCfg['use_phasespace']: from mocapInterface import phasespaceInterface self.mocap = phasespaceInterface(self.sysCfg) self.use_phasespace = True else: self.use_phasespace = False if self.sysCfg['use_virtualPlane']: isAFloor = self.sysCfg['virtualPlane']['isAFloor'] planeName = self.sysCfg['virtualPlane']['planeName'] planeCornerFile = self.sysCfg['virtualPlane']['planeCornerFile'] self.virtualPlane = virtualPlane.virtualPlane( self, planeName, isAFloor, planeCornerFile) if self.sysCfg['use_virtualPlane']: viz.go(viz.FULLSCREEN | viz.QUAD_BUFFER) elif self.sysCfg['use_fullscreen']: viz.go(viz.FULLSCREEN) else: viz.go()
def __setupSystem(self): # Set up the wiimote ################################################################ ################################################################ ## Misc. Design specific items here. if( self.sysCfg['use_wiimote']): # Create wiimote holder self.wiimote = 0 self._connectWiiMote() #Set up the HMD if self.sysCfg['use_hmd']: self.hmd = HMD(self.sysCfg['hmd'], True) self.use_HMD = True else: self.hmd = HMD(self.sysCfg['hmd'], False) self.use_HMD = False viz.window.setFullscreenMonitor(self.sysCfg['displays']) viz.setMultiSample(self.sysCfg['antiAliasPasses']) viz.MainWindow.clip(0.01 ,200) viz.vsync(1) viz.setOption("viz.glfinish", 1) viz.setOption("viz.dwm_composition", 0) #Set up recording if self.sysCfg['use_DVR'] == 1: self.use_DVR = True else: self.use_DVR = False self.writer = None #Will get initialized later when the system starts #Set up the eye tracking callibration/configuration (eyeTrackingCal) if self.sysCfg['use_eyetracking']: self.use_eyeTracking = True if self.sysCfg['hmd']['type'] == 'nvis': import EyeTrackerCalibrationNVIS_MT self.eyeTrackingCal = EyeTrackerCalibrationNVIS_MT.EyeTrackerCalibrationNVIS(self.sysCfg['eyetracker']['settingsDir']) self.eyeTrackingCal.changeDisplayNum(self.sysCfg['displays'][0]) print "Eye tracking enabled using NVIS visor" else: print "Error in VRLabConfig: Eye-tracking not setup for this HMD." sys.exit(1) else: self.use_eyeTracking = False self.eyeTrackingCal = None #self.writables.append(self.eyeTrackingCal) self.mocap = None self.bodyCam = None if self.sysCfg['use_phasespace']: from mocapInterface import phasespaceInterface self.mocap = phasespaceInterface(self.sysCfg); self.use_phasespace = True else: self.use_phasespace = False if self.sysCfg['use_hiball']: from HiBallCameraMT import HiBallCamera #self.mocap = HiBallCamera(self.sysCfg['hiball']['origin'], self.sysCfg['hiball']['scale'], None, None, self.sysCfg, None); self.mocap = HiBallCamera(self.sysCfg['hiball']['origin'], particle=None, sensorNum=self.sysCfg['hiball']['headCam'], attachTo=viz.MainView, preTrans = self.sysCfg['hiball']['preTransHead']) if self.sysCfg['hiball']['bodyCam'] != -1: self.bodyCam = HiBallCamera(self.sysCfg['hiball']['origin'], particle=None, sensorNum=self.sysCfg['hiball']['bodyCam'], attachTo=None, preTrans = self.sysCfg['hiball']['preTransBody']) else: self.bodyCam = None self.use_hiball = True else: self.use_hiball = False self.writables.append(self.mocap) self.writables.append(self.bodyCam) if self.sysCfg['use_fullscreen']: viz.go(viz.FULLSCREEN) else: viz.go() self._setWinPriority(priority=5)
#world_axes = vizshape.addAxes() #X = viz.addText3D('X',pos=[1.1,0,0],color=viz.RED,scale=[0.3,0.3,0.3],parent=world_axes) #Y = viz.addText3D('Y',pos=[0,1.1,0],color=viz.GREEN,scale=[0.3,0.3,0.3],align=viz.ALIGN_CENTER_BASE,parent=world_axes) #Z = viz.addText3D('Z',pos=[0,0,1.1],color=viz.BLUE,scale=[0.3,0.3,0.3],align=viz.ALIGN_CENTER_BASE,parent=world_axes) # add a stencil buffer for the outline highlight if __name__ == "__main__": viz.setOption('viz.display.stencil', 8) #vizconnect.go('./vizconnect_config.py') vizconnect.go('./xylo_vizconnect_config2017.py') for tracker in vizconnect.ConfigurationManager.get().getDict('tracker'): print(tracker) # get the quality setting of the demo if specified DEMO_QUALITY_SETTING = max( 0, viz.getOption('DEMO_QUALITY_SETTING', default=4, type=int)) viz.setMultiSample(DEMO_QUALITY_SETTING * 2) # disable the head lamps since we're doing lighting ourselves for window in viz.getWindowList(): window.getView().getHeadLight().disable() else: vizconnect.go('./multiscript_vizconnect_config.py') # Add the local events (events specific to this demo) #vizconnect.go('vizconnect_config_local_events.py') # Load the vizconnect configuration. File: base_vizconnect_config2016.py vizfx.addDirectionalLight(euler=(0, 90, 0)) # Add a viewpoint so the user starts at [0,0,0]. vp = vizconnect.addViewpoint(pos=[0, 0, 0], posMode=vizconnect.VIEWPOINT_MATCH_BASE)
self._avatar.setBodyColor(bodyColor) self._avatar.setShadeColor(shadeColor) # self._avatar.setTracker(self._player_matrix) self._avatar.setTracker(viz.link(self._view, viz.NullLinkable,offset=[0,-0.25,0])) self._view.collision(viz.ON) self._view.eyeheight(eyeH) # add the representation on the map self._mapAva = viz.addTexQuad(size=.75) #self._mapAva = vizshape.addSphere(.5,10,10) self._mapAva.texture(viz.addTexture('textures/mapAva_icon.png'),'',0) self._mapAva.color(bodyColor) self._updateFunc = vizact.onupdate(0, self.UpdatePlayer) def UpdatePlayer(self): # self._view.setPosition([self._view.getPosition()[0], 1.82, self._view.getPosition()[2]]) pos = self._view.getPosition(viz.VIEW_ORI) eul = self._view.getEuler(viz.VIEW_ORI) # quat= self._view.getQuat(viz.VIEW_ORI) # self._player_matrix.setPosition(pos) # self._player_matrix.setQuat(quat) self._mapAva.setPosition(pos[0], 0, pos[2]) self._mapAva.setEuler(eul[0], 90, eul[2]) #self._player_matrix = self._view.getMatrix(viz.VIEW_ORI) if __name__ == '__main__': viz.setMultiSample(2) viz.go() ground = viz.addChild('ground.osgb')
''' Project Jourdan Kerl & Bisoye Olaleye Performer plays music as the crowd dances ''' import viz import vizshape import vizact from random import randint viz.setMultiSample(4)#Enable full screen anti-aliasing (FSAA) to smooth edges viz.go() #starts an empty world viz.MainWindow.fov(60)#Increase the Field of View #viz.MainView.move([0,0,7]) #X,Z,Y viz.MainView.setPosition([-0,0,-15]) #viz.MainView.setEuler([0,30,0]) piazza = viz.addChild('piazza.osgb') #adds the plazza sound = viz.addAudio('Panda.mp3') sound.loop(viz.ON) sound.play() platform = viz.addChild('platform.osg') platform.setPosition([0, .2, -11]) micStand = viz.addChild('pole.wrl',parent=platform) micStand.setPosition([0, 0, .5]) micStand.setScale([0.5,0.36,0.5]) micStand.color(1,1,1) mic = viz.addChild('pole.wrl') mic.setPosition([0, 1.6, -10.5])
def __setupSystem(self): # Set up the wiimote ################################################################ ################################################################ ## Misc. Design specific items here. if (self.sysCfg['use_wiimote']): # Create wiimote holder self.wiimote = 0 self._connectWiiMote() ################################################################ ## HMD #Set up the HMD if self.sysCfg['use_hmd']: self.hmd = HMD(self.sysCfg['hmd'], True, displayList=self.sysCfg['displays']) self.use_HMD = True else: self.hmd = HMD(self.sysCfg['hmd'], False) self.use_HMD = False viz.setMultiSample(self.sysCfg['antiAliasPasses']) viz.MainWindow.clip(0.01, 200) #viz.vsync(1) viz.setOption("viz.glfinish", 1) viz.setOption("viz.dwm_composition", 0) ################################################################ ## Recording if self.sysCfg['use_DVR'] == 1: self.use_DVR = True else: self.use_DVR = False self.writer = None #Will get initialized later when the system starts #Set up the eye tracking callibration/configuration (eyeTrackingCal) ################################################################ ## Eyetracking if self.sysCfg['use_eyetracking']: self.use_eyeTracking = True if self.sysCfg['hmd']['type'] == 'nvis': import EyeTrackerCalibrationNVIS_MT self.eyeTrackingCal = EyeTrackerCalibrationNVIS_MT.EyeTrackerCalibrationNVIS( self.sysCfg['eyetracker']['settingsDir']) self.eyeTrackingCal.changeDisplayNum( self.sysCfg['displays'][0]) print "Eye tracking enabled using NVIS visor" else: print "Error in VRLabConfig: Eye-tracking not setup for this HMD." sys.exit(1) else: self.use_eyeTracking = False self.eyeTrackingCal = None ################################################################ ## Mocap #self.writables.append(self.eyeTrackingCal) self.mocap = None self.bodyCam = None if self.sysCfg['use_phasespace']: #from mocapInterface import phasespaceInterface #self.mocap = phasespaceInterface(self.sysCfg); from mocapInterface import phasespaceInterface self.mocap = phasespaceInterface(self.sysCfg) self.use_phasespace = True else: self.use_phasespace = False if self.sysCfg['use_hiball']: from HiBallCameraMT import HiBallCamera #self.mocap = HiBallCamera(self.sysCfg['hiball']['origin'], self.sysCfg['hiball']['scale'], None, None, self.sysCfg, None); self.mocap = HiBallCamera( self.sysCfg['hiball']['origin'], particle=None, sensorNum=self.sysCfg['hiball']['headCam'], attachTo=viz.MainView, preTrans=self.sysCfg['hiball']['preTransHead']) if self.sysCfg['hiball']['bodyCam'] != -1: self.bodyCam = HiBallCamera( self.sysCfg['hiball']['origin'], particle=None, sensorNum=self.sysCfg['hiball']['bodyCam'], attachTo=None, preTrans=self.sysCfg['hiball']['preTransBody']) else: self.bodyCam = None self.use_hiball = True else: self.use_hiball = False self.writables.append(self.mocap) self.writables.append(self.bodyCam) if self.sysCfg['use_fullscreen']: viz.go(viz.FULLSCREEN) else: viz.go()
# print 'Tracker position',headTracker.getPosition() # print 'Tracker euler',headTracker.getEuler() # print 'Hand Tracker position',handTracker.getPosition() #just added this # print 'Hand Tracker euler',handTracker.getEuler() #and this # print 'Viewpoint position',viewpoint.getPosition() # print 'Movable position',movable.getPosition(),'\n' #vizact.ontimer(5, printData) ## Setup tracking if this is the main script #if __name__ == "__main__": # import viztracker # viztracker.DEFAULT_HANDS = True # viztracker.go() #so far so good viz.setMultiSample(4) viz.fov(60) viz.go() #Add a world axis with X,Y,Z labels world_axes = vizshape.addAxes() X = viz.addText3D('X',pos=[1.1,0,0],color=viz.RED,scale=[0.3,0.3,0.3],parent=world_axes) Y = viz.addText3D('Y',pos=[0,1.1,0],color=viz.GREEN,scale=[0.3,0.3,0.3],align=viz.ALIGN_CENTER_BASE,parent=world_axes) Z = viz.addText3D('Z',pos=[0,0,1.1],color=viz.BLUE,scale=[0.3,0.3,0.3],align=viz.ALIGN_CENTER_BASE,parent=world_axes) #grids are good grid = vizshape.addGrid(color=[0.2]*3) viz.clearcolor(viz.GRAY) #Create proximity manager manager = vizproximity.Manager() manager.setDebug(viz.ON)
This script will query a single marker, the Marker 'E', for it's position. Keys and their corresponding marker positions: 1 - Top left 2 - Top right 3 - Bottom left 4 - Bottom right 5 - Print in WEnvironment.py1 format 6 - Refresh (Delete) recorded positions """ import viz import vizshape from mocapInterface import mocapInterface viz.setMultiSample(8) viz.fov(60) viz.go() import vizact from mocapInterface import mocapInterface phaseSpaceIP = '192.168.1.230' owlParamMarkerCount = 25 # Dir where textures and rb files are located phaseSpaceFilePath = 'MocapResources/' # Rb files in phaseSpaceFilePath rigidFileNames_ridx = []
def displayHeatmap(project=True): ''' - Load accumulated view textures - Add cube projector with given textures and shader converting intensities to heat map colors - Let projector affect scene - auto_update = True will set the shader uniforms automatically each frame ''' import viz import vizact import vizcam viz.setMultiSample(4) viz.go() #vizcam.WalkNavigate() if project: piazza = viz.addChild('piazza.osgb') cube_textures = { viz.POSITIVE_X: viz.addTexture('accumulated_p_x.bmp'), viz.NEGATIVE_X: viz.addTexture('accumulated_n_x.bmp'), viz.POSITIVE_Y: viz.addTexture('accumulated_p_y.bmp'), viz.NEGATIVE_Y: viz.addTexture('accumulated_n_y.bmp'), viz.POSITIVE_Z: viz.addTexture('accumulated_p_z.bmp'), viz.NEGATIVE_Z: viz.addTexture('accumulated_n_z.bmp') } heat_projector = HeatmapVisualizer(cube_textures, auto_update=True) heat_projector.setPosition(viz.MainView.getPosition()) heat_projector.affect(piazza) ## GUI for manipulation of the output heatmap i_slider = viz.addSlider() i_x = 1.0 - i_slider.getBoundingBox().width / 2.0 i_y = 0.0 + i_slider.getBoundingBox().height / 2.0 i_slider.setPosition([i_x, i_y, 0]) i_slider.set(0.5) i_text = viz.addText('intensity scale', parent=viz.SCREEN) i_text.setPosition([ i_x - i_text.getBoundingBox().width / 2 - i_slider.getBoundingBox().width / 2, 0.01, 0.0 ]) i_text.setScale([0.4, 0.4, 1.0]) def onSlider(obj, pos): if obj == i_slider: heat_projector.setIntensityScale(pos + 0.5) viz.callback(viz.SLIDER_EVENT, onSlider) else: import vizshape env = viz.addEnvironmentMap( 'accumulated.bmp', faces=['_p_x', '_n_x', '_p_y', '_n_y', '_p_z', '_n_z']) sb = vizshape.addSkyBox() sb.texture(env)
MSAAVal = 0 MSAA = viz.choose("Multisample Anti-Aliasing", ['16','8','4','2','None']) if MSAA == 0: MSAAVal = 16 elif MSAA == 1: MSAAVal = 8 elif MSAA == 2: MSAAVal = 4 elif MSAA == 3: MSAAVal = 2 elif MSAA == 4: MSAAVal = 0 viz.setMultiSample(MSAAVal) print ("MSAA: " + str(MSAAVal)) del MSAAVal VSync = viz.choose("Vertical Sync", ['False', 'True']) if VSync == 0: viz.vsync(0) else: viz.vsync(1) print ("VSync: " + str(VSync)) # Input questions/variables: Asked at program launch subjectno = viz.input('subject number?' , value='99') age = viz.input('Age number?' , value='-1') gender = viz.choose("Gender?", ["Male","Female","Not Given"]) footSize = 0
import viz import viztracker import vizinput import vizshape import vizproximity import vizinfo # Enable full screen anti-aliasing (FSAA) to smooth edges viz.setMultiSample(1) #Kommentar entfernen fuer 3D-Labor """ # connect to tracker vrpn7 = viz.add('vrpn7.dle') hostname = '141.82.50.174' # connect eye tracker pptEyes = vrpn7.addTracker('PPT0@'+hostname,0) link = viz.link(pptEyes, viz.Mainview) """ # Display viz.setOption('viz.fullscreen',1) viz.fov(40.0,1.333) #viz.setOption('viz.stereo',viz.QUAD_BUFFER) viz.mouse.setVisible(True) # increase the Field of View viz.MainWindow.fov(60)
def captureViewIntensity(): ### replace with your own application setup import viz import vizact import vizcam viz.setMultiSample(4) viz.go() piazza = viz.addChild("piazza.osgb") ### Add this at the bottom ''' - Load an animation file, which encapsulates the view rotation for a given time span. - Samples per second determines how many samples are taken along the animation path over the duration of loaded animation. - While the loaded animation path is playing the accumulator will accumulate view intensity values. - After the animation player finished playing these intensities will be saved to a cubemap - The intensity images is then used for final heatmap computation ''' # load animation path loader = AnimationPathLoader("test_animation.txt") player = AnimationPathPlayer(path=loader.getAnimationPath()) path_link = viz.link(loader.getAnimationPath(), viz.MainView) global accumulator accumulator = ViewAccumulatorCube(frame_weight=0.5, aperture_scale=0.5) accumulator.setPosition(viz.MainView.getPosition()) global _capture_done _capture_done = False cube_textures = { viz.POSITIVE_X: accumulator.getOutputTexture(viz.POSITIVE_X), viz.NEGATIVE_X: accumulator.getOutputTexture(viz.NEGATIVE_X), viz.POSITIVE_Y: accumulator.getOutputTexture(viz.POSITIVE_Y), viz.NEGATIVE_Y: accumulator.getOutputTexture(viz.NEGATIVE_Y), viz.POSITIVE_Z: accumulator.getOutputTexture(viz.POSITIVE_Z), viz.NEGATIVE_Z: accumulator.getOutputTexture(viz.NEGATIVE_Z) } heat_projector = HeatmapVisualizer(cube_textures, auto_update=True) heat_projector.setPosition(viz.MainView.getPosition()) heat_projector.affect(piazza) # update function capturing accumulating view intensity def updateFct(player, accumulator): global _capture_done if not player.isPlaying(): if not _capture_done: accumulator.saveAll() _capture_done = True print "Intensity capture done." elif accumulator != None: accumulator.remove() accumulator = None path_link.remove() update = vizact.onupdate(1, updateFct, player, accumulator)
def preVizGo(): viz.setMultiSample(4) return True
[.70, .30],#RB [.30, .50],#LC [.50, .30],#CB [.70, .50],#RC [.50, .70]]#CT sphere_size = .015 depth = 2 # m confidence_level = .2 # initialize window viz.setMultiSample(8) viz.fov(60) viz.go() # setup SteamVR HMD hmd = steamvr.HMD() if not hmd.getSensor(): sys.exit('SteamVR HMD not detected') # setup navigation node and link to main view navigationNode = viz.addGroup() viewLink = viz.link(navigationNode, viz.MainView) viewLink.preMultLinkable(hmd.getSensor())
import GodRay import WaterParticles import scavengerhunt import transport_vhil import vizshape import globals_oa from globals_oa import * import schooling import worldvizcode import algae_blend import vizinput import datacollection viz.setMultiSample(4) # Use NVIDIA Control Panel instead. # viz.setMultiSample(4) # Use NVIDIA Control Panel instead. headLight = viz.MainView.getHeadLight() headLight.disable() #setting up my own transport and event triggers transport_vhil.setUp() #the statement below should be called after the user's initial consent page response is received, but before the zones are loaded, for the selection will be based off of globals_oa.sfLevel datacollection.tribeca2016Init() #transport_vhil.user.setEuler( [180,0,0]) if globals_oa.RENDER_ENV == globals_oa.RENDER_ENV_CHOICES['VHIL']: viz.window.setSize(1900,1000) ####################################################### # Add environments.
import viz import vizinfo import vizact import math import vizshape from config import * viz.setMultiSample(4) viz.fov(60) viz.go() viz.MainView.move([5, 0, -25]) #sphere = vizshape.addSphere(radius=1); #sphere.setPosition([0, 0, 0]); ar = viz.add('./ar/artoolkit.dle') camera = ar.addWebCamera() marker = camera.addMatrixMarker(47, width=1000) #id works for 0-63 endMarker = camera.addMatrixMarker(40, width=1000) #id works for 0-63 current = 1 def main(): triangle = viz.addChild('thesis/triangle_1.dae') triangle2 = viz.addChild('thesis/triangle_1.dae')
import viz import vizact import vizfx import vizcam import vizinfo import time import vizdlg import viztask viz.setMultiSample(16) viz.fov(60) viz.go() viz.clearcolor(viz.SKYBLUE) view = viz.MainView viz.MainView.move([-30,4,-40]) viz.MainView.setEuler([0,0,0]) viz.MainView.gravity(0.0) #road between two fire fire1=viz.addChild('fire2.dae') fire1.setPosition(40,15,05) fire1.setScale(.5,.5,.5) fire2=viz.addChild('fire2.dae') fire2.setPosition(45,25,60) fire2.setScale(.5,.5,.5) #black building