def GiantViewer(raw_filename, cal_filename): '''Generate a 3D view of an x2d file, using the calibration.''' raw_frames = {100: None} print 'loading calibration' camera_info = GiantReader.readCal(cal_filename) camera_ids = None print "Camera IDs:\n{}".format(camera_ids) print 'loading 2d' raw_dict = GiantReader.readAsciiRaw(raw_filename) raw_frames = raw_dict['frames'] print 'num frames', raw_dict['numFrames'] mats = [ Calibrate.makeMat(camera['MAT'], camera['DISTORTION'], (512, 440)) for camera in camera_info['Cameras'] ] track3d = Label.Track3D(mats) primitives = QGLViewer.makePrimitives(vertices=[], altVertices=[]) primitives2D = QGLViewer.makePrimitives2D(([], [0])) cb = functools.partial(intersectRaysCB, raw_frames=raw_frames, mats=mats, primitives=primitives, primitives2D=primitives2D, track3d=track3d) QGLViewer.makeViewer(primitives=primitives, primitives2D=primitives2D, timeRange=(1, max(raw_frames.keys()), 1, 100.0), callback=cb, mats=mats, camera_ids=camera_ids) # , callback=intersectRaysCB
def main(): appIn = QtGui.QApplication(sys.argv) appIn.setStyle('plastique') global win win = QApp.QApp() win.setWindowTitle('Imaginarium MoCap Software') win.updateMenus() Runtime.addOpMenu(win) win.dirtyCB = dirtyCB Runtime.setCallbacks(win) RenderCallback.Factory(win, Runtime) appIn.connect(appIn, QtCore.SIGNAL('lastWindowClosed()'), appIn.quit) QGLViewer.makeViewer(timeRange=(0, 1400), callback=setFrame, appIn=appIn, win=win, pickCallback=Runtime.picked)
def addCameras(self, mats, camera_ids=None, movies=None): if camera_ids is None: camera_ids = range(len(mats)) if movies is None: movies = [None]*len(mats) for mat, cid, md in zip(mats, camera_ids, movies): camera = QGLViewer.Camera(cid) camera.setP(mat[2], distortion=mat[3], store=True) if md is not None: camera.setImageData(md['vbuffer'],md['vheight'],md['vwidth'],3) self.view().addCamera(camera) cams = GLCameras(camera_ids, mats) self.view().primitives.append(cams) return cams
def __init__(self, parent=None, mainView=None): super(CameraPanel, self).__init__(parent=parent) self.view = QGLViewer.QGLView() if mainView is not None: self.view.cameras = mainView.cameras self.view.camera = mainView.cameras[0] # self.view.primitives = mainView.primitives self.view.primitives2D = mainView.primitives2D camPanel = QGLPanel(self.view, parent=mainView) self.layout().addWidget(camPanel) self.view.updateGL()
anim_dict = extract_animation(fbx, skel_dict) #print skel_dict['jointNames'] skel_mesh = GLMeshes(**skelDictToMesh(skel_dict)) global g_anim_dict, g_skel_dict g_anim_dict = anim_dict g_skel_dict = skel_dict #State.setKey('/doc',payload) #fbx = decode(payload) #State.setKey('/fbx',fbx) #for k,v in fbx.iteritems(): State.setKey(k,v) from UI import QApp, QGLViewer, GLMeshes, GLPoints3D app, win = QGLViewer.makeApp(appName='Imaginarium FBX') #outliner = QApp.app.qobjects #for gi,(key,value) in enumerate(fbx.items()): # outliner.addItem(str(key)+'='+repr(value)[:200], data=str(key), index=gi) display_nodes = skel_to_nodes(skel_dict) #print zip(*display_nodes)[1] #for gi,(disp,key) in enumerate(display_nodes): outliner.addItem(disp, data='_OBJ_'+key, index=gi) #global g_fields QApp.fields = dict([(k, sorted(v.items())) for k, v in g_fields.iteritems()]) for gi, (k, v) in enumerate(fbx['objs'].items()): State.setKey('/fbx/' + str(k), v) QApp.app.qoutliner.set_root('/fbx') #for gi,key in enumerate(sorted(State.allKeys())): outliner.addItem(key+'='+repr(State.getKey(key))[:80], data=key, index=gi)
size = len(template_vs) geo_vs = np.zeros((size,3), dtype=np.float32) geo_fs = [] geo_ts = np.array([[1,0,0,0],[0,1,0,1000],[0,0,1,0]], dtype=np.float32) geo_vts = [[0,0]]*size img_vs = [[-1000,-1000,0],[1000,-1000,0],[1000,1000,0],[-1000,1000,0]] img_fs = [[0,1,2,3]] img_ts = np.array([[1,0,0,0],[0,1,0,1000],[0,0,1,0]], dtype=np.float32) img_vts = [[0,1],[1,1],[1,0],[0,0]] geo_mesh = GLMeshes(names=['geo_mesh'],verts=[geo_vs],faces=[geo_fs],transforms=[geo_ts],bones=[geo_bs], vts=[geo_vts], colour=[1,0,0,1]) image_mesh = GLMeshes(names=['image_mesh'],verts=[img_vs],faces=[img_fs],transforms=[img_ts],bones = [[]], vts=[img_vts]) layers = {'image_mesh':image_mesh,'geo_mesh':geo_mesh} if 0: ref_vs = np.zeros((size,3), dtype=np.float32) ref_vs[:,:2] = template_vs ref_mesh = GLMeshes(names=['ref_mesh'],verts=[ref_vs],faces=[geo_fs],transforms=[geo_ts],bones=[geo_bs], vts=[geo_vts], colour=[0,1,0,1]) layers['ref_mesh'] = ref_mesh app,win = QGLViewer.makeApp(appName='Imaginarium FaceTrack') QApp.app.addMenuItem({'menu':'&File','item':'Import &movie','tip':'Import a movie file','cmd':import_movie_cb}) QApp.app.qoutliner.set_root('') #for gi,geo in enumerate(layers.keys()): outliner.addItem(geo, data='_OBJ_'+geo, index=gi) global g_aam_model_indices,g_aam_model_weights g_aam_model_indices,g_aam_model_weights = Face.make_sample_model(template_vs, ref_fs, grid_size=1.0) QGLViewer.makeViewer(timeRange=(0,8000), callback=set_frame_cb2, keyCallback=keyCB, layers=layers)
QApp.app.select(name) elif isinstance(p,GLTool): p.setComponent(pi) QApp.app.updateGL() from UI import GLMeshes # TODO move this colin from UI import QApp from GCore import State from PySide import QtGui import sys appIn = QtGui.QApplication(sys.argv) appIn.setStyle('plastique') win = QApp.QApp() win.setWindowTitle('Imaginarium Maya File Browser') from UI import QGLViewer primitives = [] #QApp.fields = fields #outliner = QApp.app.qobjects #for i,(o,v) in enumerate(dobjs): # outliner.insertItem(i,o) # outliner.item(i).setData(1,'_OBJ_'+v['name']) vs = np.array([[[-1,-1,-1],[-1,-1,1],[-1,1,-1],[-1,1,1],[1,-1,-1],[1,-1,1],[1,1,-1],[1,1,1]]],dtype=np.float32)*100.0 faces = np.array([[[0,1,3,2],[4,6,7,5],[2,3,7,6],[1,0,4,5],[3,1,5,7],[0,2,6,4]]],dtype=np.int32) transforms = [np.array([[1,0,0,0],[0,1,0,1000],[0,0,1,0]],dtype=np.float32)] p = GLMeshes(names=['my mesh'], verts=vs, faces=faces, transforms=transforms) q = GLTool() q.setTool('3D rotation', transform = transforms[0], component=None) r = GLTool() r.setTool('3D translation', transform = transforms[0], component=None) primitives = [p,q,r] QGLViewer.makeViewer(primitives=primitives, timeRange = (1,100), callback=setFrameCB, pickCallback=pickedCB, appIn=appIn, win=win)
md['vwidth'], 3) h, w = md['vheight'] / 2, md['vwidth'] / 2 img_vs = [[-w, -h, 0], [w, -h, 0], [w, h, 0], [-w, h, 0]] img_fs = [[0, 1, 2, 3]] img_ts = np.array([[1, 0, 0, 0], [0, 1, 0, 1000], [0, 0, 1, 0]], dtype=np.float32) img_vts = [[0, 1], [1, 1], [1, 0], [0, 0]] image_mesh = GLMeshes(names=['image_mesh'], verts=[img_vs], faces=[img_fs], transforms=[img_ts], bones=[[]], vts=[img_vts]) image_mesh.setImage(img) QGLViewer.makeViewer(timeRange=(0, md['vmaxframe'], 1, md['fps']), callback=set_frame_cb, layers={'image_mesh': image_mesh}) exit() #'Imaginarium Movie Playback Tool' if len(sys.argv) > 1: import cv2 appname = sys.argv.pop(0) filename = sys.argv.pop(0) rotate = False if filename == '-r180': rotate = True filename = sys.argv.pop(0) md1 = open_file(filename, audio=False) img1 = np.frombuffer(md1['vbuffer'], dtype=np.uint8).reshape(md1['vheight'], md1['vwidth'], 3)
def main(): from UI import QGLViewer from UI import GLMeshes, GLPoints3D global g_setting_frame g_setting_frame = False # static data global g_webcam, g_md, g_rbfn, g_predictor, g_head_pan_shape, g_head_tilt_shape # runtime options and state global g_prev_smooth_shape, g_prev_vs, g_hmc_boot, g_neutral_corrective_shape, g_settle, g_head_pan_tilt_roll, g_smooth_pose global g_directory, g_TIS_server, g_mode, g_frame g_TIS_server = SocketServer.SocketServer() g_mode, g_frame = 0,{} grip_dir = os.environ['GRIP_DATA'] g_directory = grip_dir g_webcam,g_md = None,None g_prev_vs, g_prev_smooth_shape = None,None g_hmc_boot = None #clear_neutral() g_neutral_corrective_shape = IO.load(os.path.join(g_directory,'neutral.out'))[1] g_settle = -1 g_head_pan_tilt_roll = None g_smooth_pose = {} aam = IO.load(os.path.join(g_directory,'aam.out'))[1] if 0: svt = np.float32(aam['shapes']).reshape(-1,140) svt = np.dot(aam['shapes_u'],aam['shapes_s'].reshape(-1,1)*aam['shapes_vt']) svt = aam['shapes_s'].reshape(-1,1)*aam['shapes_vt'] tmp = svt.reshape(svt.shape[0],-1,2) Sx,Sy = tmp[:,:,0],tmp[:,:,1] tmp = np.dot(np.dot(Sy.T,np.dot(Sx,Sx.T)),Sy) u,s,vt = np.linalg.svd(tmp, full_matrices=False) print s g_head_pan_shape = np.zeros((svt.shape[1]/2,2),dtype=np.float32) g_head_tilt_shape = np.zeros((svt.shape[1]/2,2),dtype=np.float32) g_head_pan_shape[:,0] = g_head_tilt_shape[:,1] = vt[0] print np.sum(g_head_pan_shape * aam['shapes_vt'][0].reshape(-1,2)) print np.sum(g_head_tilt_shape * aam['shapes_vt'][1].reshape(-1,2)) g_head_pan_shape = aam['shapes_vt'][0].reshape(-1,2) g_head_tilt_shape = aam['shapes_vt'][1].reshape(-1,2) g_head_tilt_shape = g_head_pan_shape[:,::-1]*np.float32([1,-1]) print np.sum(g_head_pan_shape*g_head_tilt_shape) g_head_pan_shape *= np.linalg.norm(g_head_pan_shape)**-0.5 g_head_tilt_shape *= np.linalg.norm(g_head_tilt_shape)**-0.5 if np.sum(g_head_pan_shape[:,0] < 1): g_head_pan_shape = -g_head_pan_shape if np.sum(g_head_tilt_shape[:,1] > 1): g_head_tilt_shape = -g_head_tilt_shape #print np.sum(g_head_pan_shape * g_head_tilt_shape) #print np.dot(g_head_pan_shape[:,0],g_head_tilt_shape[:,1]) g_predictor = Face.load_predictor(os.path.join(g_directory,'train.out')) rbfn_filename = os.path.join(g_directory,'rbfn.out') g_rbfn = IO.load(rbfn_filename)[1] #g_rbfn = convert_rbfn(rbfn_in_filename) #IO.save(rbfn_filename, g_rbfn) ref_shape = g_predictor['ref_shape'] cx,cy = np.mean(ref_shape,axis=0) vx,vy = (np.var(ref_shape,axis=0)**0.5) * 2.5 geo_bs = [] ref_fs = Face.triangulate_2D(ref_shape) for p0,p1,p2 in ref_fs: geo_bs.append((p0,p1)) geo_bs.append((p1,p2)) geo_bs.append((p2,p0)) geo_vs = np.zeros((len(ref_shape),3), dtype=np.float32) geo_fs = [] geo_ts = np.float32([[1,0,0,0],[0,1,0,1000],[0,0,1,0]]) geo_vts = np.zeros_like(ref_shape) img_vs = np.float32([[-1000,-1000,0],[1000,-1000,0],[1000,1000,0],[-1000,1000,0]]) img_fs = np.int32([[0,1,2,3]]) img_ts = np.float32([[1,0,0,0],[0,1,0,1000],[0,0,1,0]]) img_vts = np.float32([[0,1],[1,1],[1,0],[0,0]]) markup_mesh = GLPoints3D(vertices=geo_vs, edges=np.int32(geo_bs), names=[], colour=[0,1,0,1],edgeColour=[1,1,1,1]) geo_mesh = GLMeshes(names=['geo_mesh'],verts=[geo_vs],faces=[geo_fs],transforms=[geo_ts],bones=[geo_bs], vts=[geo_vts], colour=[1,0,0,1]) image_mesh = GLMeshes(names=['image_mesh'],verts=[img_vs],faces=[img_fs],transforms=[img_ts],vts=[img_vts]) global g_bs_vs, g_bs_shape_mat, g_bs_fs, g_bs_vts, g_bs_shape_mat_T bs_dict = IO.load(os.path.join(g_directory,'harpy_ma.out'))[1]['blendShapes']['Harpy_cFace_GEOShape'] obj_scale = 10.0 g_bs_vs = np.float32(bs_dict['vs']*obj_scale) bs_dict['pts'] = [b*obj_scale for b in bs_dict['pts']] g_bs_fs = bs_dict['fs'] # warning: mix of quads and triangles :-( assert bs_dict['vts'].keys() == range(len(bs_dict['vts'].keys())) g_bs_vts = bs_dict['vts'].values() g_bs_ts = np.float32([[1,0,0,800],[0,1,0,-600],[0,0,1,300]]) bs_mesh = GLMeshes(names=['bs_mesh'],verts=[g_bs_vs],faces=[g_bs_fs],transforms=[g_bs_ts],vts=[g_bs_vts],visible=False) rbfn_groups, rbfn_slider_splits, rbfn_slider_names, rbfn_marker_names = extract_groups(g_rbfn) slider_names = [(x[8:-2]+'.translateY' if x.startswith('get_ty') else x) for x in bs_dict['wt_names']] try: slider_order = [slider_names.index(x) for x in rbfn_slider_names] except Exception as e: print 'error',e slider_order = [] g_bs_shape_mat = bs_dict['matrix'] = np.zeros((len(bs_dict['pts']), len(bs_dict['vs']), 3),dtype=np.float32) for m,ct,pt in zip(g_bs_shape_mat,bs_dict['cts'],bs_dict['pts']): m[ct] = pt g_bs_shape_mat = g_bs_shape_mat[slider_order] g_bs_shape_mat_T = g_bs_shape_mat.transpose(1,2,0).copy() layers = {'image_mesh':image_mesh,'geo_mesh':geo_mesh,'bs_mesh':bs_mesh,'markup_mesh':markup_mesh} app,win = QGLViewer.makeApp() outliner = win.qoutliner #for gi,geo in enumerate(layers.keys()): outliner.addItem(geo, data='_OBJ_'+geo, index=gi) State.setKey('ui',{'type':'ui','attrs':{\ 'harpy_xoffset':300.0,'show_harpy':True,'rotate':0,'mirroring':False,'unreal':True,'streaming_TIS':False,\ 'using_webcam':False,'HMC_mode':True,'booting':True,'filtering':True,'setting_neutral':True,'debugging':False, \ 'webcam_index':0,'cam_offset':700,'cam_fps':50,'cam_width':1280,'cam_height':720, 'movie_filename':''}}) if True: # running on deployed face machine at 720p50 State.setKey('/root/ui',{'type':'ui','attrs':{\ 'harpy_xoffset':300.0,'show_harpy':False,'rotate':1,'mirroring':False,'unreal':True,'streaming_TIS':False,\ 'using_webcam':True,'HMC_mode':True,'booting':True,'filtering':True,'setting_neutral':True,'debugging':False, \ 'webcam_index':0,'cam_offset':700,'cam_fps':50,'cam_width':1280,'cam_height':720, 'movie_filename':''}}) win.setFields('ui', [ ('show_harpy', 'show_harpy','Whether to display the Harpy','bool', False), ('harpy_xoffset', 'xoffset', 'Pixels to offset Harpy to right', 'float', 300.0), ('rotate', 'rotation','Rotate image 0=up,1=left,2=down,3=right,-1=any angle','int', 0), ('mirroring', 'mirror', 'Show reversed', 'bool', False), ('unreal', 'unreal', 'Whether to connect to unreal', 'bool', True), #('streaming_TIS', 'streaming_TIS', 'Whether currently streaming', 'bool', False), ('using_webcam', 'webcam', 'Whether using the webcam', 'bool', False), ('HMC_mode', 'HMC_mode','Boot every frame', 'bool', True), ('booting', 'boot', 'Boot at next chance', 'bool', True), ('filtering', 'filter', 'Whether to filter noise', 'bool', True), ('setting_neutral', 'neutral', 'Set neutral at next chance', 'bool', False), ('debugging', 'debug', 'Show rbfn input for debugging', 'bool', False), ('webcam_index', 'camindex', 'The index of the webcam', 'int', 0), ('cam_offset', 'camoffset','The offset of the webcam', 'int', 700), ('cam_fps', 'fps', 'The frame rate of the webcam', 'int', 50), ('cam_width', 'width', 'The width of the webcam image', 'int', 1280), ('cam_height', 'height', 'The height of the webcam image', 'int', 720), ('movie_filename', 'movie', 'The filename of the movie', 'string', ''), ]) slider_names = sorted(g_rbfn['slider_names']) win.setFields('sliders', [(sn,sn,'Slider %d'%si,'float',0.0) for si,sn in enumerate(slider_names)]) State.setKey('/root/sliders', {'type':'sliders','attrs':{sn:0.0 for sn in slider_names}}) outliner.set_root('/root') #outliner.addItem('sliders', data='sliders', index=1) win.outliner.raise_() #win.select('ui') QApp.app.dirtyCB = dirty_cb QApp.app.addMenuItem({'menu':'&File','item':'Import &movie','tip':'Import a movie file','cmd':import_movie}) QApp.app.addMenuItem({'menu':'&Edit','item':'Retrain rbfn','tip':'Train the rbfn','cmd':retrain_RBFN}) QApp.app.addMenuItem({'menu':'&Edit','item':'Retrain rbfn (no linear)','tip':'Train the rbfn with no linear part','cmd':retrain_RBFN_no_linear}) QApp.app.addMenuItem({'menu':'&Edit','item':'Retrack refresh rbfn','tip':'Refresh the rbfn','cmd':retrack_refresh_rbfn}) QApp.app.addMenuItem({'menu':'&Edit','item':'Retrack remap rbfn','tip':'Rebuild the rbfn','cmd':retrack_remap_rbfn}) QApp.app.addMenuItem({'menu':'&File','item':'Export rbfn','tip':'Export the rbfn','cmd':export_rbfn}) State.clearUndoStack() QGLViewer.makeViewer(appName='StreamVideoTrack',timeRange=(0,100), callback=setFrame_cb, keyCallback=keypress_cb, layers=layers, mats=[Calibrate.makeMat(Calibrate.composeRT(np.eye(3)*[10,10,1],[0,1000,6000],1000),[0,0],[1920,1080])], camera_ids=['RBFN']) # Ensure the server has stopped when program terminates g_TIS_server.Stop()
def main(): grip_dir = os.environ['GRIP_DATA'] global g_model g_model = IO.load(os.path.join(grip_dir, 'aam.new.io'))[1] global g_predictor, reference_3d, geo_vs, geo_vts, rect rect = None pred_fn = os.path.join(grip_dir, 'pred.new.io') g_predictor = Face.load_predictor(pred_fn) #, cutOff=15) reference_shape = g_predictor['ref_shape'] size = reference_shape.shape[0] geo_vs = np.zeros((size, 3), dtype=np.float32) geo_vs[:size, :2] = reference_shape geo_vts = np.zeros((size, 2), dtype=np.float32) geo_vts[:size] = reference_shape + 0.5 geo_ts = np.array([[1, 0, 0, 0], [0, 1, 0, 1000], [0, 0, 1, 0]], dtype=np.float32) geo_fs = Face.triangulate_2D(reference_shape) geo_bs = [] for p0, p1, p2 in geo_fs: geo_bs.append((p0, p1)) geo_bs.append((p1, p2)) geo_bs.append((p2, p0)) reference_3d = np.zeros((reference_shape.shape[0], 3), dtype=np.float32) reference_3d[:, :2] = reference_shape * [100, 100] img_vs = np.array([[0, 0, 0], [640, 0, 0], [640, 480, 0], [0, 480, 0]], dtype=np.float32) img_vts = np.array([[0, 1], [1, 1], [1, 0], [0, 0]], dtype=np.float32) img_fs = np.array([[0, 1, 2, 3]], dtype=np.int32) img_ts = np.array([[1, 0, 0, 0], [0, 1, 0, 1000], [0, 0, 1, 0]], dtype=np.float32) geo_mesh = GLMeshes(names=['geo_mesh'], verts=[geo_vs], faces=[geo_fs], transforms=[geo_ts], bones=[geo_bs], vts=[geo_vts]) img_mesh = GLMeshes(names=['img_mesh'], verts=[img_vs], faces=[img_fs], transforms=[img_ts], bones=[None], vts=[img_vts]) kinect = freenect.init() tilt, roll = 0, 0 if 1: kdev = freenect.open_device(kinect, 0) freenect.set_led(kdev, 0) # turn off LED freenect.set_tilt_degs(kdev, 25) kstate = freenect.get_tilt_state(kdev) freenect.update_tilt_state(kdev) tilt_angle, tilt_status = kstate.tilt_angle, kstate.tilt_status ax, ay, az = kstate.accelerometer_x, kstate.accelerometer_y, kstate.accelerometer_z #bottom facing down: (85, 743, 369, 52, 0) #right side down: (916, 71, 96, 112, 0) #front side down: (52, 63, -863, -128, 0) freenect.close_device(kdev) y_axis = np.array((ax, ay, az), dtype=np.float32) y_axis = y_axis / np.linalg.norm(y_axis) roll = np.degrees(np.arctan2(ax, ay)) tilt = -np.degrees(np.arctan2(az, (ax**2 + ay**2)**0.5)) fovX = 62.0 pan_tilt_roll = (0, tilt, roll) tx_ty_tz = (0, 1000, 6000) P = Calibrate.composeP_fromData((fovX, ), (pan_tilt_roll), (tx_ty_tz), 0) global g_camera_rays, g_camera_mat h, w = 480 // 2, 640 // 2 coord, pix_coord = make_coords(h, w) #P = np.eye(3,4,dtype=np.float32) #P[0,0] = P[1,1] = 2.0 k1, k2 = 0, 0 g_camera_mat = Calibrate.makeMat(P, (k1, k2), [w, h]) K, RT, P, ks, T, wh = g_camera_mat coord_undist = coord.copy() Calibrate.undistort_points_mat(coord.reshape(-1, 2), g_camera_mat, coord_undist.reshape(-1, 2)) g_camera_rays = np.dot(coord_undist, RT[:2, :3]) # ray directions (unnormalized) g_camera_rays -= np.dot([-K[0, 2], -K[1, 2], K[0, 0]], RT[:3, :3]) g_camera_rays /= (np.sum(g_camera_rays**2, axis=-1)**0.5).reshape( h, w, 1) # normalized ray directions names = ['kinect'] vs = [np.zeros((h * w, 3), dtype=np.float32)] ts = [np.eye(3, 4, dtype=np.float32)] vts = [pix_coord * (1.0 / w, 1.0 / h)] faces = [make_faces(h, w)] mats = None geom_mesh = GLMeshes(names=names, verts=vs, faces=faces, transforms=ts, vts=vts) layers = { 'geom_mesh': geom_mesh, 'geo_mesh': geo_mesh, 'img_mesh': img_mesh } QGLViewer.makeViewer(layers=layers, mats=mats, callback=cb, timeRange=(0, 10000))
def main(): global State, mats, movieFilenames, primitives global movies, primitives2D, deinterlacing, detectingWands import IO import sys, os deinterlacing = False detectingWands = False detectingTiara = False dot_detections = None detections_filename = None frame_offsets = None firstFrame, lastFrame = 0, 5000 drawDotSize = 4.0 fovX, (ox, oy), pan_tilt_roll, tx_ty_tz, distortion = 50., (0, 0), (0, 0, 0), (0, 1250, 0), (0, 0) mats = [] grip_directory = os.environ['GRIP_DATA'] if 0: fovX, (ox, oy), pan_tilt_roll, tx_ty_tz, distortion = 37.9, (0, 0), ( -66.0, 3.5, -0.2), (4850, 1330, 3280), (0, 0) # roughed in K, RT = Calibrate.composeK(fovX, ox, oy), Calibrate.composeRT( Calibrate.composeR(pan_tilt_roll), tx_ty_tz, 0) mat0 = [ K[:3, :3], RT[:3, :4], np.dot(K, RT)[:3, :], distortion, -np.dot(RT[:3, :3].T, RT[:3, 3]), [1920, 1080] ] fovX, (ox, oy), pan_tilt_roll, tx_ty_tz, distortion = 55.8, (0, 0), ( -103.6, 3.5, -0.3), (2980, 1380, -2180), (0, 0) # roughed in K, RT = Calibrate.composeK(fovX, ox, oy), Calibrate.composeRT( Calibrate.composeR(pan_tilt_roll), tx_ty_tz, 0) mat1 = [ K[:3, :3], RT[:3, :4], np.dot(K, RT)[:3, :], distortion, -np.dot(RT[:3, :3].T, RT[:3, 3]), [1920, 1080] ] fovX, (ox, oy), pan_tilt_roll, tx_ty_tz, distortion = 49.3, (0, 0), ( 27.9, 4.0, -0.2), (-5340, 1150, 5030), (0, 0) # roughed in K, RT = Calibrate.composeK(fovX, ox, oy), Calibrate.composeRT( Calibrate.composeR(pan_tilt_roll), tx_ty_tz, 0) mat2 = [ K[:3, :3], RT[:3, :4], np.dot(K, RT)[:3, :], distortion, -np.dot(RT[:3, :3].T, RT[:3, 3]), [1920, 1080] ] fovX, (ox, oy), pan_tilt_roll, tx_ty_tz, distortion = 50.6, (0, 0), ( -156.6, 4.9, 0.2), (-105, 1400, -4430), (0, 0) # roughed in K, RT = Calibrate.composeK(fovX, ox, oy), Calibrate.composeRT( Calibrate.composeR(pan_tilt_roll), tx_ty_tz, 0) mat3 = [ K[:3, :3], RT[:3, :4], np.dot(K, RT)[:3, :], distortion, -np.dot(RT[:3, :3].T, RT[:3, 3]), [1920, 1080] ] mats = [mat0, mat1, mat2, mat3] xcp_filename = '154535_Cal168_Floor_Final.xcp' directory = os.path.join(grip_directory, 'REFRAME') movieFilenames = [ '001E0827_01.MP4', '001F0813_01.MP4', '001G0922_01.MP4', '001H0191_01.MP4' ] #mats,movieFilenames = mats[:1],movieFilenames[:1] # restrict to single-view frame_offsets = [119 + 160, 260, 339, 161] small_blur, large_blur = 1, 25 min_dot_size = 1.0 max_dot_size = 20.0 circularity_threshold = 3.0 threshold_bright, threshold_dark_inv = 250, 250 #135,135 elif 0: xcp_filename = '201401211653-4Pico-32_Quad_Dialogue_01_Col_wip_01.xcp' detections_filename = 'detections.dat' detectingTiara = True pan_tilt_roll = (0, 0, 90) distortion = (0.291979, 0.228389) directory = os.path.join(os.environ['GRIP_DATA'], 'ted') movieFilenames = [ '201401211653-4Pico-32_Quad_Dialogue_01_%d.mpg' % xi for xi in range(1) ] firstFrame = 511 small_blur, large_blur = 1, 20 min_dot_size = 1.0 max_dot_size = 16.0 circularity_threshold = 3.0 threshold_bright, threshold_dark_inv = 0, 170 elif 1: xcp_filename = '50_Grip_RoomCont_AA_02.xcp' detections_filename = 'detections.dat' pan_tilt_roll = (0, 0, 0) distortion = (0.291979, 0.228389) directory = os.path.join(os.environ['GRIP_DATA'], '151110') movieFilenames = ['50_Grip_RoomCont_AA_02.v2.mov'] firstFrame = 0 small_blur, large_blur = 1, 20 min_dot_size = 1.0 max_dot_size = 16.0 circularity_threshold = 3.0 threshold_bright, threshold_dark_inv = 170, 170 attrs = dict([(v, eval(v)) for v in [ 'small_blur', 'large_blur', 'threshold_bright', 'threshold_dark_inv', 'circularity_threshold', 'min_dot_size', 'max_dot_size' ]]) primitives2D = QGLViewer.makePrimitives2D(([], []), ([], [])) primitives = [] if len(movieFilenames) is 1: # TODO: time_base, timecode K, RT = Calibrate.composeK(fovX, ox, oy), Calibrate.composeRT( Calibrate.composeR(pan_tilt_roll), tx_ty_tz, 0) mats = [[ K[:3, :3], RT[:3, :4], np.dot(K, RT)[:3, :], distortion, -np.dot(RT[:3, :3].T, RT[:3, 3]), [1920, 1080] ]] camera_ids = ['video'] movies = [ MovieReader.open_file(os.path.join(directory, movieFilenames[0]), audio=False) ] else: # hard coded cameras if xcp_filename.endswith('.xcp'): if detectingTiara: # gruffalo c3d_filename = os.path.join( directory, '201401211653-4Pico-32_Quad_Dialogue_01_Col_wip_02.c3d') from IO import C3D c3d_dict = C3D.read(c3d_filename) global c3d_frames c3d_frames, c3d_fps, c3d_labels = c3d_dict['frames'], c3d_dict[ 'fps'], c3d_dict['labels'] c3d_subject = '' #'TedFace' which = np.where( [s.startswith(c3d_subject) for s in c3d_labels])[0] c3d_frames = c3d_frames[:, which, :] c3d_labels = [c3d_labels[i] for i in which] print len(c3d_frames) xcp, xcp_data = ViconReader.loadXCP( os.path.join(directory, xcp_filename)) mats.extend(xcp) elif xcp_filename.endswith('.cal'): from IO import OptitrackReader xcp, xcp_data = OptitrackReader.load_CAL( os.path.join(directory, xcp_filename)) mats = xcp print 'mats', len(mats), len(movieFilenames) assert (len(mats) == len(movieFilenames)) camera_ids = [] movies = [] for ci, mf in enumerate(movieFilenames): fo = 0 if frame_offsets is None else frame_offsets[ci] movies.append( MovieReader.open_file(os.path.join(directory, mf), audio=False, frame_offset=fo)) camera_ids = ['cam_%d' % ci for ci in xrange(len(mats))] print len(mats), len(movies), len(camera_ids) primitives.append(GLPoints3D([])) primitives.append(GLPoints3D([])) primitives.append(GLPoints3D([])) primitives[0].colour = (0, 1, 1, 0.5) # back-projected "cyan" points primitives[1].colour = (0, 0, 1, 0.5) primitives[1].pointSize = 5 primitives[2].colour = (1, 0, 0, 0.99) if len(movieFilenames) != 1 and detections_filename != None: try: dot_detections = IO.load(detections_filename)[1] except: numFrames = len(c3d_frames) # TODO HACK HACK dot_detections = movies_to_detections(movies, range(numFrames), deinterlacing, attrs) IO.save(detections_filename, dot_detections) if detectingTiara: x3ds_seq = {} for fi in dot_detections.keys(): frame = c3d_frames[(fi - 55) % len(c3d_frames)] which = np.array(np.where(frame[:, 3] == 0)[0], dtype=np.int32) x3ds_seq[fi] = np.concatenate((VICON_tiara_x3ds + np.array([150,-100,0],dtype=np.float32),frame[which,:3])), \ np.concatenate((np.arange(len(VICON_tiara_x3ds),dtype=np.int32),which+len(VICON_tiara_x3ds))) dot_labels = get_labels(dot_detections.keys(), x3ds_seq, dot_detections, mats, x2d_threshold=0.05) calibration_fi = 546 - 2 - 6 RT = tighten_calibration(x3ds_seq[calibration_fi], dot_labels[calibration_fi], mats) for v in c3d_frames: v[:, :3] = np.dot(v[:, :3], RT[:3, :3].T) + RT[:, 3] if True: dot_detections = IO.load(detections_filename)[1] x3ds_seq = {} for fi in dot_detections.keys(): frame = c3d_frames[(fi - 55) % len(c3d_frames)] which = np.array(np.where(frame[:, 3] == 0)[0], dtype=np.int32) x3ds_seq[fi] = np.concatenate((VICON_tiara_x3ds + np.array([0,1000,0],dtype=np.float32),frame[which,:3])), \ np.concatenate((np.arange(len(VICON_tiara_x3ds),dtype=np.int32),which+len(VICON_tiara_x3ds))) #dot_labels = get_labels(dot_detections.keys(), x3ds_seq, dot_detections, mats, x2d_threshold = 0.05) if detectingTiara: primitives.append(GLPoints3D(VICON_tiara_x3ds + [0, 1000, 0])) primitives[-1].pointSize = 5 global track3d, prev_frame, booting, trackGraph track3d = Label.Track3D(mats[:len(movies)], x2d_threshold=0.03, x3d_threshold=5.0, min_rays=3, boot_interval=2) #tilt_threshold = 0.01, gruffalo trackGraph = Label.TrackGraph() prev_frame = 0 booting = 1 from UI import QApp from PySide import QtGui from GCore import State # Modified the options parameter for fields to be the range of acceptable values for the box # Previously would crash if small_blur got too low QApp.fields = { 'image filter': [ ('small_blur', 'Small blur radius', 'This is part of the image filter which controls the size of smallest detected features.', 'int', small_blur, { "min": 0, "max": None }), ('large_blur', 'Large blur radius', 'This is part of the image filter which controls the size of largest detected features.', 'int', large_blur, { "min": 0, "max": None }), ('threshold_bright', 'threshold_bright', 'This is part of the image filter which controls the size of smallest detected features.', 'int', threshold_bright, { "min": 0, "max": 255 }), ('threshold_dark_inv', 'threshold_dark_inv', 'This is part of the image filter which controls the size of largest detected features.', 'int', threshold_dark_inv, { "min": 0, "max": 255 }), ('circularity_threshold', 'circularity_threshold', 'How circular?.', 'float', circularity_threshold, { "min": 0, "max": 100 }), ('min_dot_size', 'min_dot_size', 'min_dot_size smallest detected features.', 'float', min_dot_size, { "min": 0, "max": 100 }), ('max_dot_size', 'max_dot_size', 'max_dot_size largest detected features.', 'float', max_dot_size, { "min": 0, "max": 100 }), ] } State.addKey('dotParams', {'type': 'image filter', 'attrs': attrs}) State.setSel('dotParams') appIn = QtGui.QApplication(sys.argv) appIn.setStyle('plastique') win = QApp.QApp() win.setWindowTitle('Imaginarium Dots Viewer') QGLViewer.makeViewer(primitives=primitives, primitives2D=primitives2D, timeRange=(firstFrame, lastFrame), callback=setFrame, mats=mats, camera_ids=camera_ids, movies=movies, pickCallback=picked, appIn=appIn, win=win)
if __name__ == '__main__': import UI from UI import QApp, QGLViewer from UI import GLMeshes import os, sys if len(sys.argv) > 1: filename = sys.argv[1] geom_dict = flatten_OBJ_and_x10(read_OBJ(filename)) ted_geom = GLMeshes(['ted'], [geom_dict['v']], [geom_dict['tris']], vts=[geom_dict['vt']], transforms=[np.eye(3, 4)]) primitives = [ted_geom] QGLViewer.makeViewer(primitives=primitives) exit() from GCore import Calibrate import MovieReader import C3D global ted_geom, ted_geom2, ted_shape, tony_geom, tony_shape, tony_geom2, tony_obj, ted_obj, diff_geom, c3d_frames global tony_shape_vector, tony_shape_mat, ted_lo_rest, ted_lo_mat, c3d_points global md, movies ted_dir = os.path.join(os.environ['GRIP_DATA'], 'ted') wavFilename = os.path.join(ted_dir, '32T01.WAV') md = MovieReader.open_file(wavFilename)
def main(x2d_filename, xcp_filename, c3d_filename=None): '''Generate a 3D view of an x2d file, using the calibration.''' global x2d_frames, mats, Ps, c3d_frames, primitives, primitives2D, track3d, prev_frame, track_orn, orn_graph, boot, orn_mapper, mar_mapper prev_frame = None c3d_frames = None if c3d_filename != None: c3d_dict = C3D.read(c3d_filename) c3d_frames, c3d_fps, c3d_labels = c3d_dict['frames'], c3d_dict[ 'fps'], c3d_dict['labels'] mats, xcp_data = ViconReader.loadXCP(xcp_filename) camera_ids = [int(x['DEVICEID']) for x in xcp_data] print 'loading 2d' x2d_dict = ViconReader.loadX2D(x2d_filename) x2d_frames = x2d_dict['frames'] cameras_info = ViconReader.extractCameraInfo(x2d_dict) print 'num frames', len(x2d_frames) Ps = [m[2] / (m[0][0, 0]) for m in mats] track3d = Label.Track3D(mats) primitives = QGLViewer.makePrimitives(vertices=[], altVertices=[]) primitives2D = QGLViewer.makePrimitives2D(([], [0])) global g_all_skels, md directory = os.path.join(os.environ['GRIP_DATA'], '151110') _, orn_skel_dict = IO.load(os.path.join(directory, 'orn.skel')) movie_fn = os.path.join(directory, '50_Grip_RoomCont_AA_02.v2.mov') md = MovieReader.open_file(movie_fn, audio=True, frame_offset=0, volume_ups=10) asf_filename = os.path.join(directory, 'Martha.asf') amc_filename = os.path.join(directory, 'Martha.amc') asf_dict = ASFReader.read_ASF(asf_filename) mar_skel_dict = ASFReader.asfDict_to_skelDict(asf_dict) mar_skel_dict['anim_dict'] = ASFReader.read_AMC(amc_filename, asf_dict) for k in ('geom_Vs', 'geom_vsplits', 'geom_Gs'): mar_skel_dict[k] = orn_skel_dict[k].copy() mar_skel_dict['shape_weights'] = orn_skel_dict['shape_weights'] mar_skel_dict['geom_dict'] = orn_skel_dict['geom_dict'] orn_vss = ViconReader.loadVSS(os.path.join(directory, 'Orn.vss')) orn_vss_chan_mapping = [ orn_vss['chanNames'].index(n) for n in orn_skel_dict['chanNames'] ] orn_anim_dict = orn_skel_dict['anim_dict'] orn_vss_anim = np.zeros( (orn_anim_dict['dofData'].shape[0], orn_vss['numChans']), dtype=np.float32) orn_vss_anim[:, orn_vss_chan_mapping] = orn_anim_dict['dofData'] orn_anim_dict['dofData'] = orn_vss_anim orn_vss['anim_dict'] = orn_anim_dict for x in [ 'geom_dict', 'geom_Vs', 'geom_vsplits', 'geom_Gs', 'shape_weights' ]: orn_vss[x] = orn_skel_dict[x] orn_skel_dict = orn_vss g_all_skels = {} orn_mesh_dict, orn_skel_mesh, orn_geom_mesh = orn_t = Character.make_geos( orn_skel_dict) g_all_skels['orn'] = (orn_skel_dict, orn_t) orn_skel_dict['chanValues'][:] = 0 Character.updatePoseAndMeshes(orn_skel_dict, orn_skel_mesh, orn_geom_mesh) mar_mesh_dict, mar_skel_mesh, mar_geom_mesh = mar_t = Character.make_geos( mar_skel_dict) g_all_skels['mar'] = (mar_skel_dict, mar_t) #ted_mesh_dict, ted_skel_mesh, ted_geom_mesh = ted_t = Character.make_geos(ted_skel_dict) #g_all_skels['ted'] = (ted_skel_dict, ted_t) #ted_skel_dict['chanValues'][0] += 1000 #Character.updatePoseAndMeshes(ted_skel_dict, ted_skel_mesh, ted_geom_mesh) mnu = orn_skel_dict['markerNamesUnq'] mns = orn_skel_dict['markerNames'] effectorLabels = np.array([mnu.index(n) for n in mns], dtype=np.int32) orn_graph = Label.graph_from_skel(orn_skel_dict, mnu) boot = -10 track_orn = Label.TrackModel(orn_skel_dict, effectorLabels, mats) #ted = GLSkel(ted_skel_dict['Bs'], ted_skel_dict['Gs']) #, mvs=ted_skel_dict['markerOffsets'], mvis=ted_skel_dict['markerParents']) #ted = GLSkeleton(ted_skel_dict['jointNames'],ted_skel_dict['jointParents'], ted_skel_dict['Gs'][:,:,3]) #ted.setName('ted') #ted.color = (1,1,0) #orn = GLSkeleton(orn_skel_dict['jointNames'],orn_skel_dict['jointParents'], orn_skel_dict['Gs'][:,:,3]) #orn.setName('orn') #orn.color = (0,1,1) #square = GLMeshes(names=['square'],verts=[[[0,0,0],[1000,0,0],[1000,1000,0],[0,1000,0]]],vts=[[[0,0],[1,0],[1,1],[0,1]]],faces=[[[0,1,2,3]]],fts=[[[0,1,2,3]]]) #square.setImageData(np.array([[[0,0,0],[255,255,255]],[[255,255,255],[0,0,0]]],dtype=np.uint8)) #orn_geom_mesh.setImageData(np.array([[[0,0,0],[255,255,255]],[[255,255,255],[0,0,0]]],dtype=np.uint8)) P = Calibrate.composeP_fromData((60.8, ), (-51.4, 14.7, 3.2), (6880, 2860, 5000), 0) # roughed in camera for 151110 ks = (0.06, 0.0) mat = Calibrate.makeMat(P, ks, (1080, 1920)) orn_mapper = Opengl.ProjectionMapper(mat) orn_mapper.setGLMeshes(orn_geom_mesh) orn_geom_mesh.setImage((md['vbuffer'], (md['vheight'], md['vwidth'], 3))) mar_mapper = Opengl.ProjectionMapper(mat) mar_mapper.setGLMeshes(mar_geom_mesh) mar_geom_mesh.setImage((md['vbuffer'], (md['vheight'], md['vwidth'], 3))) global g_screen g_screen = Opengl.make_quad_distortion_mesh() QGLViewer.makeViewer(mat=mat,md=md,layers = {\ #'ted':ted, 'orn':orn, #'ted_skel':ted_skel_mesh,'ted_geom':ted_geom_mesh,\ #'square':square, 'orn_skel':orn_skel_mesh,'orn_geom':orn_geom_mesh,\ 'mar_skel':mar_skel_mesh,'mar_geom':mar_geom_mesh,\ }, primitives=primitives, primitives2D=primitives2D, timeRange=(0, len(x2d_frames) - 1, 4, 25.0), callback=intersectRaysCB, mats=mats,camera_ids=camera_ids)
ref_mesh = GLPoints3D(vertices=ref_vs, edges=State.getKey('/edges', None), edgeColour=[0.0, 1.0, 0.0, 0.5], colour=[0.0, 1.0, 1.0, 0.5]) image_mesh = GLMeshes(names=['image_mesh'], verts=[img_vs], faces=[img_fs], transforms=[img_ts], bones=[[]], vts=[img_vts]) layers = { 'image_mesh': image_mesh, 'markup_mesh': markup_mesh, 'ref_mesh': ref_mesh } app, win = QGLViewer.makeApp(appName='Imaginarium FaceMark') outliner = QApp.app.qoutliner outliner.set_root('') QApp.app.addMenuItem({ 'menu': '&Edit', 'item': '&Retrain', 'tip': 'Retrain the face model (1 hour)', 'cmd': retrain }) QApp.app.addMenuItem({ 'menu': '&Edit', 'item': '&Train', 'tip': 'Train the face model (1 day)', 'cmd': train }) QApp.app.addMenuItem({
def __init__(self): QtGui.QMainWindow.__init__(self) global app assert(app is None) app = self self.value_is_adjusting = False self.dirtyCB = None self.filename = None self.menus = {} self.move(0,0) self.resize(640, 480) self.setWindowTitle(State.appName()) self.setFocusPolicy(QtCore.Qt.StrongFocus) # get keyboard events self.blockUpdate = False self.set_widget = {} self.trigger_calls = {} self.preLoadCB = None self.loadCB = None self.saveCB = None self.addMenuItem({'menu':'&File','item':'&New','tip':'New scene','cmd':self.new}) self.addMenuItem({'menu':'&File','item':'&Open','shortcut':'Ctrl+O','tip':'Open state','cmd':self.load}) self.addMenuItem({'menu':'&File','item':'&Save','shortcut':'Ctrl+S','tip':'Save state','cmd':self.save}) self.addMenuItem({'menu':'&File','item':'Save &As','tip':'Save state as','cmd':self.saveAs}) self.addMenuItem({'menu':'&File','item':'&Quit','shortcut':'Ctrl+Q','tip':'Exit application','cmd':self.quit}) self.undoItem = self.addMenuItem({'menu':'&Edit','item':'&Undo','shortcut':'Ctrl+Z','tip':'Undo last command','cmd':self.undo}) self.redoItem = self.addMenuItem({'menu':'&Edit','item':'Re&do','shortcut':'Ctrl+Shift+Z','tip':'Redo last command','cmd':self.redo}) self.clearUndoItem = self.addMenuItem({'menu':'&Edit','item':'&Clear undo','tip':'Clear the undo stack','cmd':self.clearUndo}) self.getOrCreateMenu('&View') #self.addMenuItem({'menu':'&Create','item':'&Image','tip':'Create image','cmd':self.loadImage}) self.qglview = QGLViewer.QGLView() self.qview = QGLPanel(self.qglview, parent=self) self.qfields = QFields.QFieldsEditor(self) self.qoutliner = QStateTreeView.QStateTreeView() self.qoutliner.selectionModel().currentChanged.connect(functools.partial(self.selectCB2, caller=self.qoutliner)) # Add Ops list self.qnodes = UI.QCore.QNodeWidget(parent=self) self.qnodes.item_selected.connect(functools.partial(self.selectCB, caller=self.qnodes)) self.qnodes.data_changed.connect(self.dataChangedCB) self.runtime = None self.cameraPanels = None # Add Python Console self.qpython = UI.QCore.PythonConsole() #self.qlayers = Qlayers.Qlayers(self) self.qtimeline = UI.QTimeline(self) self.setCentralWidget(self.qview) ar = (QtCore.Qt.LeftDockWidgetArea | QtCore.Qt.RightDockWidgetArea | QtCore.Qt.BottomDockWidgetArea | QtCore.Qt.TopDockWidgetArea) self.attributeEditor = self.addDock('Attribute Editor', self.qfields, ar, QtCore.Qt.RightDockWidgetArea) # Add docks and tab the Ops, outliner, and script together self.opNodes = self.addDock('Ops', self.qnodes, ar, QtCore.Qt.RightDockWidgetArea) self.outliner = self.addDock('Outliner', self.qoutliner, ar, QtCore.Qt.RightDockWidgetArea) self.pythonDock = self.addDock('Console', self.qpython, ar, QtCore.Qt.BottomDockWidgetArea) self.tabifyDockWidget(self.opNodes, self.outliner) self.tabifyDockWidget(self.outliner, self.pythonDock) self.timelineDock = self.addDock('Timeline', self.qtimeline, ar, QtCore.Qt.BottomDockWidgetArea) self.setTabPosition(QtCore.Qt.TopDockWidgetArea, QtGui.QTabWidget.North) self.setTabPosition(QtCore.Qt.RightDockWidgetArea,QtGui.QTabWidget.East ) self.setTabPosition(QtCore.Qt.LeftDockWidgetArea, QtGui.QTabWidget.West ) self.setTabPosition(QtCore.Qt.BottomDockWidgetArea, QtGui.QTabWidget.North) self.updateMenus() # Set the ops dock as the default visible one (enable this when everyone is happy to proceed) self.opNodes.show() self.opNodes.raise_() # self.outliner.show() # self.outliner.raise_() self.setAcceptDrops(True)
#for fi,dofs in enumerate(dofData): #dofs[:6] = 0.0 #Character.pose_skeleton(skelDict['Gs'], skelDict, dofs) #data[fi] = skelDict['Gs'][:,:,3] def setFrame(fi): QGLViewer.timeline.frameStep = 1 drawing_skel2 = True global animDict dofs = animDict['dofData'][(fi - animDict['frameNumbers'][0]) % len(animDict['frameNumbers'])].copy() #dofs[[2,5]] = dofData[0,[2,5]] Character.pose_skeleton(skelDict['Gs'], skelDict, dofs) QGLViewer.skel.setPose(skelDict['Gs']) if drawing_skel2: dofs = skelDict2['dofData'][(fi - skelDict2['frameNumbers'][0]) % len(skelDict2['frameNumbers'])].copy() Character.pose_skeleton(skelDict2['Gs'], skelDict2, dofs) QGLViewer.skel2.setPose(skelDict['Gs']) QGLViewer.view.updateGL() timeRange = (animDict['frameNumbers'][0], animDict['frameNumbers'][-1]) from UI import QGLViewer QGLViewer.makeViewer([], timeRange=timeRange, callback=setFrame, skelDict=skelDict, altSkelDict=skelDict)
x_0[:] = tony_shape_vectors[fi] = fitLoResShapeMat( ted_lo_rest, ted_lo_mat, x3ds, indices=which, bounds=bnds, x_0=x_0) print '\rfitting', fi, sys.stdout.flush() IO.save(tsv_filename, tony_shape_vectors) primitives = [ head_points, c3d_points, surface_points, ted_geom, ted_geom2, tony_geom ] primitives.extend(geos) ted_glskel = GLSkel(ted_skel['Bs'], ted_skel['Gs']) if ted_skel else None if ted_glskel: primitives.append(ted_glskel) ted_cameras = GLCameras([x['USERID'] for x in ted_xcp_data], ted_xcp_mats) if ted_xcp_mats else None if ted_cameras: primitives.append(ted_cameras) QGLViewer.makeViewer(timeRange=(0, len(c3d_frames) - 1), mats=mats, camera_ids=camera_ids, movies=movies, callback=animateHead, primitives=primitives) exit()