def simple_renderer(rn, verts, faces, yrot=np.radians(120), color=colors['light_pink']): rn.set(v=verts, f=faces, vc=color, bgcolor=np.ones(3)) albedo = rn.vc rn.vc = LambertianPointLight(f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=_rotateY( np.array([-200, -100, -100]), yrot), vc=albedo, light_color=np.array([1, 1, 1])) # Construct Left Light rn.vc += LambertianPointLight(f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=_rotateY(np.array([800, 10, 300]), yrot), vc=albedo, light_color=np.array([1, 1, 1])) # Construct Right Light rn.vc += LambertianPointLight(f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=_rotateY( np.array([-500, 500, 1000]), yrot), vc=albedo, light_color=np.array([.7, .7, .7])) return rn.r
def render_color_model_with_lighting(w, h, v, vn, vc, f, u, sh_comps=None, light_c=ch.ones(3), vlight_pos=None, vlight_color=None, bg_img=None): """renders colored model with lighting effect""" assert(sh_comps is not None or vlight_pos is not None) V = ch.array(v) A = np.zeros_like(v) # SH lighting if sh_comps is not None: A += vc * SphericalHarmonics(vn=vn, components=sh_comps, light_color=light_c) # single point lighting (grey light) if vlight_color is not None and vlight_pos is not None \ and len(vlight_pos.shape) == 1: A += LambertianPointLight(f=f, v=v, num_verts=len(v), light_pos=vlight_pos, light_color=vlight_color, vc=vc) # multiple point lighting (grey light) if vlight_color is not None and vlight_pos is not None \ and len(vlight_pos.shape) == 2: for vlp in vlight_pos: A += LambertianPointLight(f=f, v=v, num_verts=len(v), light_pos=vlp, light_color=vlight_color, vc=vc) black_img = np.array(np.zeros((w, h, 3)), dtype=np.float32) bg_img_ = bg_img if bg_img is not None else black_img rn = ColoredRenderer(camera=u, v=V, f=f, vc=A, background_image=bg_img_, frustum={'width': w, 'height': h, 'near': 0.1, 'far': 20}) return rn.r
def _update_model(self, id): print(id) self.model = None self.model_type = model_type_list[id] self._update_canvas = False self.light = LambertianPointLight(vc=np.array([0.98, 0.98, 0.98]), light_color=np.array([1., 1., 1.])) self.rn.set(glMode='glfw', bgcolor=np.ones(3), frustum=self.frustum, camera=self.camera, vc=self.light, overdraw=False) self._init_model() self.model.pose[0] = np.pi self._init_camera(update_camera=True) self._reset_shape() self._reset_expression() self._reset_pose() self._reset_position() self._update_canvas = True self.draw()
def __init__(self): super(self.__class__, self).__init__() self.setupUi(self) self._moving = False self._rotating = False self._mouse_begin_pos = None self._loaded_gender = None self._update_canvas = False self.camera = ProjectPoints(rt=np.zeros(3), t=np.zeros(3)) self.joints2d = ProjectPoints(rt=np.zeros(3), t=np.zeros(3)) self.frustum = {'near': 0.1, 'far': 1000., 'width': 100, 'height': 30} self.light = LambertianPointLight(vc=np.array([0.94, 0.94, 0.94]), light_color=np.array([1., 1., 1.])) self.rn = ColoredRenderer(bgcolor=np.ones(3), frustum=self.frustum, camera=self.camera, vc=self.light, overdraw=False) self.model = None self._init_model('f') self.model.pose[0] = np.pi self.camera_widget = Ui_CameraWidget(self.camera, self.frustum, self.draw) self.btn_camera.clicked.connect(lambda: self._show_camera_widget()) for key, shape in self._shapes(): shape.valueChanged[int].connect(lambda val, k=key: self._update_shape(k, val)) for key, pose in self._poses(): pose.valueChanged[int].connect(lambda val, k=key: self._update_pose(k, val)) self.pos_0.valueChanged[float].connect(lambda val: self._update_position(0, val)) self.pos_1.valueChanged[float].connect(lambda val: self._update_position(1, val)) self.pos_2.valueChanged[float].connect(lambda val: self._update_position(2, val)) self.radio_f.pressed.connect(lambda: self._init_model('f')) self.radio_m.pressed.connect(lambda: self._init_model('m')) self.reset_pose.clicked.connect(self._reset_pose) self.reset_shape.clicked.connect(self._reset_shape) self.reset_postion.clicked.connect(self._reset_position) self.canvas.wheelEvent = self._zoom self.canvas.mousePressEvent = self._mouse_begin self.canvas.mouseMoveEvent = self._move self.canvas.mouseReleaseEvent = self._mouse_end self.action_save.triggered.connect(self._save_config_dialog) self.action_open.triggered.connect(self._open_config_dialog) self.action_save_screenshot.triggered.connect(self._save_screenshot_dialog) self.action_save_mesh.triggered.connect(self._save_mesh_dialog) self.view_joints.triggered.connect(self.draw) self.view_joint_ids.triggered.connect(self.draw) self.view_bones.triggered.connect(self.draw) self._update_canvas = True
def _simple_renderer(rn, meshes, yrot=0, texture=None): mesh = meshes[0] if texture is not None: if not hasattr(mesh, 'ft'): mesh.ft = copy(mesh.f) vt = copy(mesh.v[:, :2]) vt -= np.min(vt, axis=0).reshape((1, -1)) vt /= np.max(vt, axis=0).reshape((1, -1)) mesh.vt = vt mesh.texture_filepath = rn.texture_image # Set camers parameters if texture is not None: rn.set(v=mesh.v, f=mesh.f, vc=mesh.vc, ft=mesh.ft, vt=mesh.vt, bgcolor=np.ones(3)) else: rn.set(v=mesh.v, f=mesh.f, vc=mesh.vc, bgcolor=np.ones(3)) for next_mesh in meshes[1:]: _stack_with(rn, next_mesh, texture) # Construct Back Light (on back right corner) albedo = rn.vc rn.vc = LambertianPointLight(f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=rotateY( np.array([-200, -100, -100]), yrot), vc=albedo, light_color=np.array([1, 1, 1])) # Construct Left Light rn.vc += LambertianPointLight(f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=rotateY(np.array([800, 10, 300]), yrot), vc=albedo, light_color=np.array([1, 1, 1])) # Construct Right Light rn.vc += LambertianPointLight(f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=rotateY( np.array([-500, 500, 1000]), yrot), vc=albedo, light_color=np.array([.7, .7, .7])) return rn.r
def simple_renderer(rn, meshes, yrot=np.radians(120)): from opendr.lighting import LambertianPointLight mesh = meshes[0] if hasattr(rn, 'texture_image'): if not hasattr(mesh, 'ft'): mesh.ft = copy(mesh.f) vt = copy(mesh.v[:, :2]) vt -= np.min(vt, axis=0).reshape((1, -1)) vt /= np.max(vt, axis=0).reshape((1, -1)) mesh.vt = vt # mesh.texture_filepath = rn.texture_image rn.set(v=mesh.v, f=mesh.f, vc=mesh.vc, ft=mesh.ft, vt=mesh.vt, bgcolor=np.ones(3)) else: rn.set(v=mesh.v, f=mesh.f, vc=mesh.vc, bgcolor=np.ones(3)) for next_mesh in meshes[1:]: stack_with(rn, next_mesh) albedo = rn.vc # Construct Back Light (on back right corner) rn.vc = LambertianPointLight(f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=rotateY( np.array([-200, -100, -100]), yrot), vc=albedo, light_color=np.array([1, 1, 1])) # Construct Left Light rn.vc += LambertianPointLight(f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=rotateY(np.array([800, 10, 300]), yrot), vc=albedo, light_color=np.array([1, 1, 1])) # Construct Right Light rn.vc += LambertianPointLight(f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=rotateY( np.array([-500, 500, 1000]), yrot), vc=albedo, light_color=np.array([.7, .7, .7])) return rn.r
def standard_render(self): ## Create OpenDR renderer rn = ColoredRenderer() ## Assign attributes to renderer w, h = (640, 480) rn.camera = ProjectPoints(v=self.m, rt=np.zeros(3), t=np.array([0, 0, 2.]), f=np.array([w, w]) / 2., c=np.array([w, h]) / 2., k=np.zeros(5)) rn.frustum = {'near': 1., 'far': 10., 'width': w, 'height': h} rn.set(v=self.m, f=self.m.f, bgcolor=np.zeros(3)) ## Construct point light source rn.vc = LambertianPointLight(f=self.m.f, v=rn.v, num_verts=len(self.m), light_pos=np.array([-1000, -1000, -2000]), vc=np.ones_like(self.m) * .9, light_color=np.array([1., 1., 1.])) ## Show it using OpenCV import cv2 cv2.imshow('render_SMPL', rn.r) print('..Print any key while on the display window') cv2.waitKey(0) cv2.destroyAllWindows()
def render(verts, faces, w=640, h=480): # Frontal view verts[:, 1:3] = -verts[:, 1:3] # Create OpenDR renderer rn = ColoredRenderer() # Assign attributes to renderer rn.camera = ProjectPoints(v=verts, rt=np.zeros(3), t=np.array([0., 0., 2.]), f=np.array([w, h]) / 2., c=np.array([w, h]) / 2., k=np.zeros(5)) rn.frustum = {'near': 1., 'far': 10., 'width': w, 'height': h} rn.set(v=verts, f=faces, bgcolor=np.zeros(3)) # Construct point light source rn.vc = LambertianPointLight(f=rn.f, v=rn.v, num_verts=len(verts), light_pos=np.array([1000, -1000, -2000]), vc=np.ones_like(verts) * .9, light_color=np.array([1., 1., 1.])) return rn.r
def Render(): verts = np.load('../../resault/verts.npy') faces = np.load('../../resault/faces.npy') rn = ColoredRenderer() w, h = (640, 480) rn.camera = ProjectPoints(v=verts, rt=np.zeros(3), t=np.array([0, 0, 2.]), f=np.array([w, w]) / 2., c=np.array([w, h]) / 2., k=np.zeros(5)) rn.frustum = {'near': 0.8, 'far': 16., 'width': w, 'height': h} rn.set(v=verts, f=faces, bgcolor=np.array([255, 255, 255])) rn.vc = LambertianPointLight(f=faces, v=rn.v, num_verts=len(verts), light_pos=np.array([-1000, -1000, -2000]), vc=np.ones_like(verts) * .9, light_color=np.array([1., 1., 1.])) # import cv2 # # cv2.imshow('render_SMPL', rn.r) # cv2.waitKey(0) import matplotlib.pyplot as plt plt.ion() plt.axis('off') plt.imshow(rn.r) raw_input() plt.show()
def main(mesh_list, out_list, scale=1.0, move_scale=True): assert len(mesh_list) == len(out_list) for mesh_file, out_file in zip(mesh_list, out_list): mesh = load_obj_data_binary(mesh_file) if move_scale: # move to center and scale to unit bounding box mesh['v'] = (mesh['v'] - np.array([128, -192, 128]) + 0.5) * voxel_size if not ('vn' in mesh and mesh['vn'] is not None): mesh['vn'] = np.array(VertNormals(f=mesh['f'], v=mesh['v'])) V = ch.array(mesh['v']) * scale V -= trans C = np.ones_like(mesh['v']) C *= np.array([186, 212, 255], dtype=np.float32) / 255.0 # C *= np.array([158, 180, 216], dtype=np.float32) / 250.0 C = np.minimum(C, 1.0) A = np.zeros_like(mesh['v']) A += LambertianPointLight(f=mesh['f'], v=V, vn=-mesh['vn'], num_verts=len(V), light_pos=np.array([0, -50, -50]), light_color=np.array([1.0, 1.0, 1.0]), vc=C) cam_t, cam_r = ch.array((0, 0, 0)), ch.array((3.14, 0, 0)) U = ProjectPoints(v=V, f=[flength, flength], c=[w / 2., h / 2.], k=ch.zeros(5), t=cam_t, rt=cam_r) rn = ColoredRenderer(camera=U, v=V, f=mesh['f'], vc=A, bgcolor=np.array([1.0, 0.0, 0.0]), frustum={ 'width': w, 'height': h, 'near': 0.1, 'far': 20 }) img = np.asarray(rn)[:, :, (2, 1, 0)] msk = np.sum(np.abs(img - np.array([[[0, 0, 1.0]]], dtype=np.float32)), axis=-1, keepdims=True) msk[msk > 0] = 1 img = cv.resize(img, (img.shape[1] // 2, img.shape[0] // 2)) msk = cv.resize(msk, (msk.shape[1] // 2, msk.shape[0] // 2), interpolation=cv.INTER_AREA) msk[msk < 1] = 0 msk = msk[:, :, np.newaxis] img = np.concatenate([img, msk], axis=-1) cv.imshow('render3', img) cv.waitKey(3) cv.imwrite(out_file, np.uint8(img * 255))
def renderBody(m): from opendr.camera import ProjectPoints from opendr.renderer import ColoredRenderer from opendr.lighting import LambertianPointLight # Create OpenDR renderer rn = ColoredRenderer() # Assign attributes to renderer w, h = (640, 480) rn.camera = ProjectPoints(v=m, rt=np.zeros(3), t=np.array([0, 0, 2.]), f=np.array([w, w]) / 2., c=np.array([w, h]) / 2., k=np.zeros(5)) rn.frustum = {'near': 1., 'far': 10., 'width': w, 'height': h} rn.set(v=m, f=m.f, bgcolor=np.zeros(3)) # Construct point light source rn.vc = LambertianPointLight(f=m.f, v=rn.v, num_verts=len(m), light_pos=np.array([-1000, -1000, -2000]), vc=np.ones_like(m) * .9, light_color=np.array([1., 1., 1.])) plt.ion() plt.imshow(np.fliplr(rn.r)) # FLIPPED! plt.show() plt.xticks([]) plt.yticks([])
def simple_renderer(rn, verts, faces, yrot=np.radians(120), color=colors['light_pink']): # Rendered model color rn.set(v=verts, f=faces, vc=color, bgcolor=np.ones(3)) albedo = rn.vc # Construct Back Light (on back right corner) rn.vc = LambertianPointLight(f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=_rotateY( np.array([-200, -100, -100]), yrot), vc=albedo, light_color=np.array([1, 1, 1])) # Construct Left Light rn.vc += LambertianPointLight(f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=_rotateY(np.array([800, 10, 300]), yrot), vc=albedo, light_color=np.array([1, 1, 1])) # Construct Right Light rn.vc += LambertianPointLight(f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=_rotateY( np.array([-500, 500, 1000]), yrot), vc=albedo, light_color=np.array([.7, .7, .7])) flipXRotation = np.array([[1.0, 0.0, 0.0, 0.0], [0.0, -1.0, 0., 0.0], [0.0, 0., -1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]) rn.camera.openglMat = flipXRotation # this is from setupcamera in utils rn.glMode = 'glfw' rn.sharedWin = None rn.overdraw = True rn.nsamples = 8 rn.msaa = True # Without anti-aliasing optimization often does not work. rn.initGL() rn.debug = False return rn.r
def __init__(self, m): self.m = m self.m.betas[:] = np.random.rand(m.betas.size) * .3 # m.pose[:] = np.random.rand(m.pose.size) * .2 self.m.pose[:3] = [0., 0., 0.] self.m.pose[3:] = np.zeros(45) # m.pose[3:] = [-0.42671473, -0.85829819, -0.50662164, +1.97374622, -0.84298473, -1.29958491] self.m.pose[0] = np.pi # compute inverse components to map from fullpose spec to coefficients hands_components = np.asarray(m.hands_components) self.hands_components_inv = np.linalg.inv(hands_components) # rendering components # Assign attributes to renderer w, h = (640, 480) # Create OpenDR renderer self.rn = ColoredRenderer() self.rn.camera = ProjectPoints(v=m, rt=np.zeros(3), t=np.array([-0.03, -0.04, 0.20]), f=np.array([w, w]) / 2., c=np.array([w, h]) / 2., k=np.zeros(5)) self.rn.frustum = {'near': 0.01, 'far': 2., 'width': w, 'height': h} self.rn.set(v=m, f=m.f, bgcolor=np.zeros(3)) # Construct point light source self.rn.vc = LambertianPointLight(f=m.f, v=self.rn.v, num_verts=len(m), light_pos=np.array( [-1000, -1000, -2000]), vc=np.ones_like(m) * .9, light_color=np.array([1., 1., 1.])) self.rn.vc += LambertianPointLight(f=m.f, v=self.rn.v, num_verts=len(m), light_pos=np.array( [+2000, +2000, +2000]), vc=np.ones_like(m) * .9, light_color=np.array([1., 1., 1.])) self.mvs = MeshViewers(window_width=2000, window_height=800, shape=[1, 3])
def simple_renderer(rn, verts, faces, vc=None, yrot=np.radians(120), lighting=False): # Rendered model color if vc is None: color = colors['neutral'] else: color = vc rn.set(v=verts, f=faces, vc=color, bgcolor=np.zeros(3)) #Construct Back Light (on back right corner) #No light if lighting: albedo = rn.vc rn.vc = LambertianPointLight(f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=_rotateY( np.array([-200, -100, -100]), yrot), vc=albedo, light_color=np.array([1, 1, 1])) # Construct Left Light rn.vc += LambertianPointLight(f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=_rotateY( np.array([800, 10, 300]), yrot), vc=albedo, light_color=np.array([1, 1, 1])) # Construct Right Light rn.vc += LambertianPointLight(f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=_rotateY( np.array([-500, 500, 1000]), yrot), vc=albedo, light_color=np.array([.7, .7, .7])) return rn
def simple_renderer(rn, verts, faces, yrot=np.radians(120), color=colors["light_pink"]): # Rendered model color # print("faces-------------") # print(faces.type()) # print(verts.shape) rn.set(v=verts, f=faces, vc=color, bgcolor=np.ones(3)) albedo = rn.vc # Construct Back Light (on back right corner) rn.vc = LambertianPointLight( f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=_rotateY(np.array([-200, -100, -100]), yrot), vc=albedo, light_color=np.array([0.5, 0.5, 0.5]), ) # Construct Left Light rn.vc += LambertianPointLight( f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=_rotateY(np.array([800, 10, 300]), yrot), vc=albedo, light_color=np.array([0.5, 0.5, 0.5]), ) # Construct Right Light rn.vc = LambertianPointLight( f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=np.array([0, 0, 1000]), vc=albedo, light_color=np.array([1, 1, 1]), ) return rn.r
def simple_renderer(rn, verts, faces, vert_colors = None, yrot = np.radians(120), color = colors['light_pink']): # Rendered model color if vert_colors is None: rn.set(v=verts, f=faces, vc=color, bgcolor=np.ones(3)) else: rn.set(v=verts, f=faces, vc=vert_colors, bgcolor=np.ones(3)) albedo = rn.vc # Construct Back Light (on back right corner) rn.vc = LambertianPointLight( f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=_rotateY(np.array([-200, -100, -100]), yrot), vc=albedo, light_color=np.array([1, 1, 1])) # Construct Left Light rn.vc += LambertianPointLight( f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=_rotateY(np.array([800, -200, 300]), yrot), vc=albedo, light_color=np.array([1, 1, 1])) # Construct Right Light rn.vc += LambertianPointLight( f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=_rotateY(np.array([-500, -200, 1000]), yrot), vc=albedo, light_color=np.array([.7, .7, .7])) return rn.r
def simple_renderer(rn, verts, faces, yrot=np.radians(120), color=colors['light_pink']): t0 = time.time() # Rendered model color rn.set(v=verts, f=faces, vc=color, bgcolor=np.ones(3)) albedo = rn.vc # Construct Back Light (on back right corner) rn.vc = LambertianPointLight( f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=_rotateY(np.array([-200, -100, -100]), yrot), vc=albedo, light_color=np.array([1, 1, 1])) # Construct Left Light rn.vc += LambertianPointLight( f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=_rotateY(np.array([800, 10, 300]), yrot), vc=albedo, light_color=np.array([1, 1, 1])) # Construct Right Light rn.vc += LambertianPointLight( f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=_rotateY(np.array([-500, 500, 1000]), yrot), vc=albedo, light_color=np.array([.7, .7, .7])) #t0 = time.time() #rend_img = rn.r #print('Render:', time.time() - t0) return rn.r
def mesh2Image(vertices, faces, batch, path, name, height, width, vertices_num=6890): # Create OpenDR renderer rn = ColoredRenderer() rt_1 = np.zeros(3) rn.camera = ProjectPoints( v=vertices, # vertices # v=m, rt=rt_1, # x, y, z translation of the camera, z>=0 0 0 2 t=np.array([0, 0, 0]), # f=np.array([w,w])/2, # focus length? just scaling the picture # c=np.array([w,h])/2, # just move the picture along top-left axis? not sure f=np.array([1, 1]), c=np.array([0, 0]), k=np.zeros(5)) rn.frustum = {'near': 1, 'far': 15, 'width': width, 'height': height} rn.set(v=vertices, f=faces, bgcolor=np.zeros(3)) # Construct point light source rn.vc = LambertianPointLight( f=faces, # face v=vertices, # v=rn.v, #vertex? num_verts=len(vertices), light_pos=np.array([-1000, -1000, -2000]), # point light position vc=np.ones_like(vertices) * .9, # albedo per vertex light_color=np.array([1., 1., 1.])) # Blue, Green, Red; light intensity # make the image binary(black and white); these are actually magic steps rn.change_col(np.ones((vertices_num, 3))) #mask = rn.r.copy() # takes lots of time mask = rn.r * 255 import cv2 if batch == 1: cv2.imwrite('%s/%s.png' % (path, name), mask) else: cv2.imwrite('%s/%s_%d.png' % (path, name, i), mask) '''
def computeGlobalAndPointLighting(v, vn, vc, light_pos, globalConstant, light_color): # Construct point light source rangeMeshes = range(len(vn)) vc_list = [] for mesh in rangeMeshes: l1 = LambertianPointLight(v=v[mesh], vn=vn[mesh], num_verts=len(v[mesh]), light_pos=light_pos, vc=vc[mesh], light_color=light_color) vcmesh = vc[mesh] * (l1 + globalConstant) vc_list = vc_list + [vcmesh] return vc_list
def render_smpl(m): # Create OpenDR renderer rn = ColoredRenderer() # Assign attributes to renderer w, h = (640, 480) rn.camera = ProjectPoints(v=m, rt=np.zeros(3), t=np.array( [0, 0, 2.]), f=np.array([w, w])/2., c=np.array([w, h])/2., k=np.zeros(5)) rn.frustum = {'near': 1., 'far': 10., 'width': w, 'height': h} rn.set(v=m, f=m.f, bgcolor=np.zeros(3)) # Construct point light source rn.vc = LambertianPointLight( f=m.f, v=rn.v, num_verts=len(m), light_pos=np.array([-1000, -1000, -2000]), vc=np.ones_like(m)*.9, light_color=np.array([1., 1., 1.])) image = rn.r * 255 return image
def render_smpl(par, theta, beta, img_out_file, model_path, front_view=False): m = load_model(model_path) ## Assign the given pose m.pose[:] = theta m.betas[:] = beta # Define specific parameters for showing a front view of the rendering if front_view: m.pose[:3] = np.array([np.pi, 0, 0], dtype=np.float32) rt = np.zeros(3) light_source = np.array([-1000, -1000, -2000]) else: rt = np.array([3.14, 0, 0]) light_source = np.array([1000, 1000, 2000]) ## Create OpenDR renderer rn = ColoredRenderer() ## Assign attributes to renderer w, h = (640, 480) rn.camera = ProjectPoints(v=m, rt=rt, t=np.array([0, 0, 2.]), f=np.array([w, w]) / 2., c=np.array([w, h]) / 2., k=np.zeros(5)) rn.frustum = {'near': 1., 'far': 10., 'width': w, 'height': h} rn.set(v=m, f=m.f, bgcolor=np.zeros(3)) ## Construct point light source rn.vc = LambertianPointLight( f=m.f, v=rn.v, num_verts=len(m), #light_pos=np.array([-1000,-1000,-2000]), light_pos=light_source, vc=np.ones_like(m) * .9, light_color=np.array([1., 1., 1.])) cv2.imwrite(img_out_file, rn.r * 255.0)
def computeGlobalAndPointLighting(v, vn, vc, light_pos, globalConstant, light_color): # [In]: v list(np.array) # [In]: vn list(np.array) # [In]: vc list(np.array) # [In]: light_pos np.array([x, y, y]) # [In]: globalConstant np.array([r, g, b]) # [In]: light_color np.array([r, g, b]) # Construct point light source rangeMeshes = range(len(vn)) vc_list = [] for mesh in rangeMeshes: l1 = LambertianPointLight(v=v[mesh], vn=vn[mesh], num_verts=len(v[mesh]), light_pos=light_pos, vc=vc[mesh], light_color=light_color) vcmesh = vc[mesh] * (l1 + globalConstant) vc_list = vc_list + [vcmesh] return vc_list
rn = ColoredRenderer() # Assign attributes to renderer w, h = (640, 480) rn.camera = ProjectPoints(v=smpl, rt=np.zeros(3), t=np.array([0, 0, 3.]), f=np.array([w, w]), c=np.array([w, h]) / 2., k=np.zeros(5)) rn.frustum = {'near': 1., 'far': 10., 'width': w, 'height': h} rn.set(v=smpl, f=smpl.f, bgcolor=np.zeros(3)) # Construct point light source rn.vc = LambertianPointLight(f=smpl.f, v=rn.v, num_verts=len(smpl), light_pos=np.array([-1000, -1000, -2000]), vc=np.ones_like(smpl) * .9, light_color=np.array([1., 1., 1.])) # Show it using OpenCV import cv2 cv2.imshow('render_SMPL', rn.r) print('..Print any key while on the display window') cv2.waitKey(0) cv2.destroyAllWindows()
def render(self, cam_intrinsics, dist=None, M=None, img_shape=None, render_mask=False): from opendr.camera import ProjectPoints from utils.renderer import ColoredRenderer if dist is None: dist = np.zeros(5) dist = dist.flatten() if M is None: M = np.eye(4) # get R, t from M (has to be world2cam) R = M[:3, :3] ax, angle = t3d.axangles.mat2axangle(R) rt = ax*angle rt = rt.flatten() t = M[:3, 3] w, h = (320, 320) if img_shape is not None: w, h = img_shape[1], img_shape[0] pp = np.array([cam_intrinsics[0, 2], cam_intrinsics[1, 2]]) f = np.array([cam_intrinsics[0, 0], cam_intrinsics[1, 1]]) # Create OpenDR renderer rn = ColoredRenderer() # Assign attributes to renderer rn.camera = ProjectPoints(rt=rt, t=t, # camera translation f=f, # focal lengths c=pp, # camera center (principal point) k=dist) # OpenCv distortion params rn.frustum = {'near': 0.1, 'far': 5., 'width': w, 'height': h} V, F = self._get_verts_faces() rn.set(v=V, f=F, bgcolor=np.zeros(3)) if render_mask: rn.vc = np.ones_like(V) #for segmentation mask like rendering else: colors = np.ones_like(V) # Construct point light sources rn.vc = LambertianPointLight(f=F, v=V, num_verts=V.shape[0], light_pos=np.array([-1000, -1000, -2000]), vc=0.8 * colors, light_color=np.array([1., 1., 1.])) rn.vc += LambertianPointLight(f=F, v=V, num_verts=V.shape[0], light_pos=np.array([1000, 1000, -2000]), vc=0.25 * colors, light_color=np.array([1., 1., 1.])) rn.vc += LambertianPointLight(f=F, v=V, num_verts=V.shape[0], light_pos=np.array([2000, 2000, 2000]), vc=0.1 * colors, light_color=np.array([1., 1., 1.])) rn.vc += LambertianPointLight(f=F, v=V, num_verts=V.shape[0], light_pos=np.array([-2000, -2000, 2000]), vc=0.1 * colors, light_color=np.array([1., 1., 1.])) # render img = (np.array(rn.r) * 255).astype(np.uint8) return img
def render(self, vertices, faces=None, img=None, camera_t=np.zeros([3], dtype=np.float32), camera_rot=np.zeros([3], dtype=np.float32), camera_center=None, use_bg=False, bg_color=(0.0, 0.0, 0.0), body_color=None, focal_length=5000, disp_text=False, gt_keyp=None, pred_keyp=None, **kwargs): if img is not None: height, width = img.shape[:2] else: height, width = self.height, self.width if faces is None: faces = self.faces if camera_center is None: camera_center = np.array([width * 0.5, height * 0.5]) self.renderer.camera = ProjectPoints(rt=camera_rot, t=camera_t, f=focal_length * np.ones(2), c=camera_center, k=np.zeros(5)) dist = np.abs(self.renderer.camera.t.r[2] - np.mean(vertices, axis=0)[2]) far = dist + 20 self.renderer.frustum = { 'near': 1.0, 'far': far, 'width': width, 'height': height } if img is not None: if use_bg: self.renderer.background_image = img else: self.renderer.background_image = np.ones_like(img) * np.array( bg_color) if body_color is None: color = self.colors['blue'] else: color = self.colors[body_color] if isinstance(self.renderer, TexturedRenderer): color = [1., 1., 1.] self.renderer.set(v=vertices, f=faces, vc=color, bgcolor=np.ones(3)) albedo = self.renderer.vc # Construct Back Light (on back right corner) yrot = np.radians(120) self.renderer.vc = LambertianPointLight( f=self.renderer.f, v=self.renderer.v, num_verts=self.renderer.v.shape[0], light_pos=rotateY(np.array([-200, -100, -100]), yrot), vc=albedo, light_color=np.array([1, 1, 1])) # Construct Left Light self.renderer.vc += LambertianPointLight( f=self.renderer.f, v=self.renderer.v, num_verts=self.renderer.v.shape[0], light_pos=rotateY(np.array([800, 10, 300]), yrot), vc=albedo, light_color=np.array([1, 1, 1])) # Construct Right Light self.renderer.vc += LambertianPointLight( f=self.renderer.f, v=self.renderer.v, num_verts=self.renderer.v.shape[0], light_pos=rotateY(np.array([-500, 500, 1000]), yrot), vc=albedo, light_color=np.array([.7, .7, .7])) return self.renderer.r
def main(keypoint_file, masks_file, camera_file, out, model_file, prior_file, resize, body_height, nohands, display): # load data with open(model_file, 'rb') as fp: model_data = pkl.load(fp, encoding='latin1') with open(camera_file, 'rb') as fp: camera_data = pkl.load(fp, encoding='latin1') with open(prior_file, 'rb') as fp: prior_data = pkl.load(fp, encoding='latin1') if 'basicModel_f' in model_file: regs = np.load( 'vendor/smplify/models/regressors_locked_normalized_female.npz') b2m = np.load('assets/b2m_f.npy') else: regs = np.load( 'vendor/smplify/models/regressors_locked_normalized_male.npz') b2m = np.load('assets/b2m_m.npy') keypoints = h5py.File(keypoint_file, 'r')['keypoints'] masks = h5py.File(masks_file, 'r')['masks'] num_frames = masks.shape[0] # init base_smpl = Smpl(model_data) base_smpl.trans[:] = np.array([0, 0, 3]) base_smpl.pose[0] = np.pi base_smpl.pose[3:] = prior_data['mean'] camera = ProjectPoints(t=np.zeros(3), rt=np.zeros(3), c=camera_data['camera_c'] * resize, f=camera_data['camera_f'] * resize, k=camera_data['camera_k'], v=base_smpl) frustum = { 'near': 0.1, 'far': 1000., 'width': int(camera_data['width'] * resize), 'height': int(camera_data['height'] * resize) } if display: debug_cam = ProjectPoints(v=base_smpl, t=camera.t, rt=camera.rt, c=camera.c, f=camera.f, k=camera.k) debug_light = LambertianPointLight(f=base_smpl.f, v=base_smpl, num_verts=len(base_smpl), light_pos=np.zeros(3), vc=np.ones(3), light_color=np.ones(3)) debug_rn = ColoredRenderer(camera=debug_cam, v=base_smpl, f=base_smpl.f, vc=debug_light, frustum=frustum) else: debug_rn = None # generic frame loading function def create_frame(i, smpl, copy=True): f = FrameData() f.smpl = copy_smpl(smpl, model_data) if copy else smpl f.camera = ProjectPoints(v=f.smpl, t=camera.t, rt=camera.rt, c=camera.c, f=camera.f, k=camera.k) f.keypoints = np.array(keypoints[i]).reshape(-1, 3) * np.array( [resize, resize, 1]) f.J = joints_coco(f.smpl) f.J_proj = ProjectPoints(v=f.J, t=camera.t, rt=camera.rt, c=camera.c, f=camera.f, k=camera.k) f.mask = cv2.resize(np.array(masks[i], dtype=np.float32), (0, 0), fx=resize, fy=resize, interpolation=cv2.INTER_NEAREST) f.collision_obj = collision_obj(f.smpl, regs) f.pose_prior_obj = pose_prior_obj(f.smpl, prior_data) f.pose_obj = (f.J_proj - f.keypoints[:, :2]) * f.keypoints[:, 2].reshape(-1, 1) return f base_frame = create_frame(0, base_smpl, copy=False) # get betas from 5 frames log.info('Initial fit') num_init = 5 indices_init = np.ceil(np.arange(num_init) * num_frames * 1. / num_init).astype(np.int) init_frames = [base_frame] for i in indices_init[1:]: init_frames.append(create_frame(i, base_smpl)) init(init_frames, body_height, b2m, debug_rn) # get pose frame by frame with h5py.File(out, 'w') as fp: last_smpl = None poses_dset = fp.create_dataset("pose", (num_frames, 72), 'f', chunks=True, compression="lzf") trans_dset = fp.create_dataset("trans", (num_frames, 3), 'f', chunks=True, compression="lzf") betas_dset = fp.create_dataset("betas", (10, ), 'f', chunks=True, compression="lzf") for i in xrange(num_frames): if i == 0: current_frame = base_frame else: current_frame = create_frame(i, last_smpl) log.info('Fit frame {}'.format(i)) # re-init if necessary reinit_frame(current_frame, prior_data['mean'], nohands, debug_rn) # final fit fit_pose(current_frame, last_smpl, frustum, nohands, debug_rn) poses_dset[i] = current_frame.smpl.pose.r trans_dset[i] = current_frame.smpl.trans.r if i == 0: betas_dset[:] = current_frame.smpl.betas.r last_smpl = current_frame.smpl log.info('Done.')
def render(self, image, cam, K, verts, face): ## Create OpenDR renderer rn = ColoredRenderer() ## Assign attributes to renderer w, h = (224 * self.ratio, 224 * self.ratio) f = np.array([K[0, 0], K[1, 1]]) * float(self.ratio) c = np.array([K[0, 2], K[1, 2]]) * float(self.ratio) t = np.array([cam[1], cam[2], 2 * K[0, 0] / (224. * cam[0] + 1e-9)]) rn.camera = ProjectPoints(v=verts, rt=np.zeros(3), t=t, f=f, c=c, k=np.zeros(5)) rn.frustum = {'near': 1., 'far': 100., 'width': w, 'height': h} albedo = np.ones_like(verts)*.9 if self.color is not None: color0 = self.color color1 = self.color color2 = self.color else: # white color0 = np.array([1, 1, 1]) color1 = np.array([1, 1, 1]) color2 = np.array([0.7, 0.7, 0.7]) rn.set(v=verts, f=face, bgcolor=np.zeros(3)) yrot = np.radians(120) rn.vc = LambertianPointLight( f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=rotateY(np.array([-200, -100, -100]), yrot), vc=albedo, light_color=color0) # Construct Left Light rn.vc += LambertianPointLight( f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=rotateY(np.array([800, 10, 300]), yrot), vc=albedo, light_color=color1) # Construct Right Light rn.vc += LambertianPointLight( f=rn.f, v=rn.v, num_verts=len(rn.v), light_pos=rotateY(np.array([-500, 500, 1000]), yrot), vc=albedo, light_color=color2) img_orig = np.transpose(image, (1, 2, 0)) img_resized = resize(img_orig, (img_orig.shape[0] * self.ratio, img_orig.shape[1] * self.ratio), anti_aliasing=True) img_smpl = img_resized.copy() img_smpl[rn.visibility_image != 4294967295] = rn.r[rn.visibility_image != 4294967295] rn.set(v=rotateY(verts, np.radians(90)), f=face, bgcolor=np.zeros(3)) render_smpl = rn.r render_smpl_rgba = np.zeros((render_smpl.shape[0], render_smpl.shape[1], 4)) render_smpl_rgba[:, :, :3] = render_smpl render_smpl_rgba[:, :, 3][rn.visibility_image != 4294967295] = 255 return img_orig, img_resized, img_smpl, render_smpl_rgba
mesh[:, 2] = 10.0 + (mesh[:, 2] - np.mean(mesh[:, 2])) mesh[:, :2] = mesh[:, :2] * np.expand_dims(mesh[:, 2], 1) rn.camera = ProjectPoints(v=mesh, rt=np.zeros(3), t=np.array([0, 0, 0]), f=np.array([1, 1]), c=np.array([0, 0]), k=np.zeros(5)) rn.frustum = {'near': 1., 'far': 20., 'width': w, 'height': h} rn.set(v=mesh, f=m.f, bgcolor=np.zeros(3)) rn.vc = LambertianPointLight(f=m.f, v=mesh, num_verts=len(m), light_pos=np.array([0, 0, 0]), vc=np.ones_like(m) * .9, light_color=np.array([1., 1., 1.])) mod = i % bg_number bg = misc.imread(os.path.join(bg_pth, '%d.png' % (mod))) rn.change_col(np.ones((778, 3))) mask = rn.r.copy() mask = mask[:, :, 0].astype(np.uint8) rn.change_col(colors[random.randint(0, 26)]) hand = rn.r.copy() * 255. image = (1 - np.expand_dims(mask, 2)) * bg + np.expand_dims(mask, 2) * hand
rn1.camera = ProjectPoints(v=m1, rt=np.zeros(3), t=np.array([0, 0, 2.]), f=np.array([w, w]) / 2., c=np.array([w, h]) / 2., k=np.zeros(5)) rn1.frustum = {'near': 1., 'far': 10., 'width': w, 'height': h} rn1.set(v=m1, f=m1.f, bgcolor=np.zeros(3)) rn2.camera = ProjectPoints(v=m2, rt=np.zeros(3), t=np.array([0, 0, 2.]), f=np.array([w, w]) / 2., c=np.array([w, h]) / 2., k=np.zeros(5)) rn2.frustum = {'near': 1., 'far': 10., 'width': w, 'height': h} rn2.set(v=m2, f=m2.f, bgcolor=np.zeros(3)) ## Construct point light source rn1.vc = LambertianPointLight( f=m1.f, v=rn1.v, num_verts=len(m1), light_pos=np.array([-1000, -1000, -2000]), vc=np.ones_like(m1) * .9, light_color=np.array([1., 1., 1.])) rn2.vc = LambertianPointLight( f=m2.f, v=rn2.v, num_verts=len(m2), light_pos=np.array([-1000, -1000, -2000]), vc=np.ones_like(m2) * .9, light_color=np.array([1., 1., 1.])) ###################### Finish of Initialization of SMPL body model ############# ########## path of the input file Result_path = '/data/Guha/GR/Output/TestSet/13/'
class Ui_MainWindow(QtWidgets.QMainWindow, Ui_MainWindow_Base): def __init__(self): super(self.__class__, self).__init__() self.setupUi(self) self._moving = False self._rotating = False self._mouse_begin_pos = None self._loaded_gender = None self._update_canvas = False self.camera = ProjectPoints(rt=np.zeros(3), t=np.zeros(3)) self.joints2d = ProjectPoints(rt=np.zeros(3), t=np.zeros(3)) self.frustum = {'near': 0.1, 'far': 1000., 'width': 100, 'height': 30} self.light = LambertianPointLight(vc=np.array([0.94, 0.94, 0.94]), light_color=np.array([1., 1., 1.])) self.rn = ColoredRenderer(bgcolor=np.ones(3), frustum=self.frustum, camera=self.camera, vc=self.light, overdraw=False) self.model = None self._init_model('f') self.model.pose[0] = np.pi self.camera_widget = Ui_CameraWidget(self.camera, self.frustum, self.draw) self.btn_camera.clicked.connect(lambda: self._show_camera_widget()) for key, shape in self._shapes(): shape.valueChanged[int].connect(lambda val, k=key: self._update_shape(k, val)) for key, pose in self._poses(): pose.valueChanged[int].connect(lambda val, k=key: self._update_pose(k, val)) self.pos_0.valueChanged[float].connect(lambda val: self._update_position(0, val)) self.pos_1.valueChanged[float].connect(lambda val: self._update_position(1, val)) self.pos_2.valueChanged[float].connect(lambda val: self._update_position(2, val)) self.radio_f.pressed.connect(lambda: self._init_model('f')) self.radio_m.pressed.connect(lambda: self._init_model('m')) self.reset_pose.clicked.connect(self._reset_pose) self.reset_shape.clicked.connect(self._reset_shape) self.reset_postion.clicked.connect(self._reset_position) self.canvas.wheelEvent = self._zoom self.canvas.mousePressEvent = self._mouse_begin self.canvas.mouseMoveEvent = self._move self.canvas.mouseReleaseEvent = self._mouse_end self.action_save.triggered.connect(self._save_config_dialog) self.action_open.triggered.connect(self._open_config_dialog) self.action_save_screenshot.triggered.connect(self._save_screenshot_dialog) self.action_save_mesh.triggered.connect(self._save_mesh_dialog) self.view_joints.triggered.connect(self.draw) self.view_joint_ids.triggered.connect(self.draw) self.view_bones.triggered.connect(self.draw) self._update_canvas = True def showEvent(self, event): self._init_camera() super(self.__class__, self).showEvent(event) def resizeEvent(self, event): self._init_camera() super(self.__class__, self).resizeEvent(event) def closeEvent(self, event): self.camera_widget.close() super(self.__class__, self).closeEvent(event) def draw(self): if self._update_canvas: img = np.array(self.rn.r) if self.view_joints.isChecked() or self.view_joint_ids.isChecked() or self.view_bones.isChecked(): img = self._draw_annotations(img) self.canvas.setScaledContents(False) self.canvas.setPixmap(self._to_pixmap(img)) def _draw_annotations(self, img): self.joints2d.set(t=self.camera.t, rt=self.camera.rt, f=self.camera.f, c=self.camera.c, k=self.camera.k) if self.view_bones.isChecked(): kintree = self.model.kintree_table[:, 1:] for k in range(kintree.shape[1]): cv2.line(img, (int(self.joints2d.r[kintree[0, k], 0]), int(self.joints2d.r[kintree[0, k], 1])), (int(self.joints2d.r[kintree[1, k], 0]), int(self.joints2d.r[kintree[1, k], 1])), (0.98, 0.98, 0.98), 3) if self.view_joints.isChecked(): for j in self.joints2d.r: cv2.circle(img, (int(j[0]), int(j[1])), 5, (0.38, 0.68, 0.15), -1) if self.view_joint_ids.isChecked(): for k, j in enumerate(self.joints2d.r): cv2.putText(img, str(k), (int(j[0]), int(j[1])), cv2.FONT_HERSHEY_DUPLEX, 0.6, (0.3, 0.23, 0.9), 2) return img def _init_model(self, g): pose = None betas = None trans = None if self.model is not None: pose = self.model.pose.r betas = self.model.betas.r trans = self.model.trans.r if g == 'f': self.model = load_model('smpl/models/basicModel_f_lbs_10_207_0_v1.0.0.pkl') else: self.model = load_model('smpl/models/basicmodel_m_lbs_10_207_0_v1.0.0.pkl') self._loaded_gender = g if pose is not None: self.model.pose[:] = pose self.model.betas[:] = betas self.model.trans[:] = trans self.light.set(v=self.model, f=self.model.f, num_verts=len(self.model)) self.rn.set(v=self.model, f=self.model.f) self.camera.set(v=self.model) self.joints2d.set(v=self.model.J_transformed) self.draw() def _init_camera(self): w = self.canvas.width() h = self.canvas.height() if w != self.frustum['width'] and h != self.frustum['height']: self.camera.set(rt=np.array([self.camera_widget.rot_0.value(), self.camera_widget.rot_1.value(), self.camera_widget.rot_2.value()]), t=np.array([self.camera_widget.pos_0.value(), self.camera_widget.pos_1.value(), self.camera_widget.pos_2.value()]), f=np.array([w, w]) * self.camera_widget.focal_len.value(), c=np.array([w, h]) / 2., k=np.array([self.camera_widget.dist_0.value(), self.camera_widget.dist_1.value(), self.camera_widget.dist_2.value(), self.camera_widget.dist_3.value(), self.camera_widget.dist_4.value()])) self.frustum['width'] = w self.frustum['height'] = h self.light.set(light_pos=Rodrigues(self.camera.rt).T.dot(self.camera.t) * -10.) self.rn.set(frustum=self.frustum, camera=self.camera) self.draw() def _save_config_dialog(self): filename, _ = QtWidgets.QFileDialog.getSaveFileName(self, 'Save config', None, 'Config File (*.ini)') if filename: with open(str(filename), 'w') as fp: config = ConfigParser.ConfigParser() config.add_section('Model') config.set('Model', 'gender', self._loaded_gender) config.set('Model', 'shape', ','.join(str(s) for s in self.model.betas.r)) config.set('Model', 'pose', ','.join(str(p) for p in self.model.pose.r)) config.set('Model', 'translation', ','.join(str(p) for p in self.model.trans.r)) config.add_section('Camera') config.set('Camera', 'translation', ','.join(str(t) for t in self.camera.t.r)) config.set('Camera', 'rotation', ','.join(str(r) for r in self.camera.rt.r)) config.set('Camera', 'focal_length', self.camera_widget.focal_len.value()) config.set('Camera', 'center', '{},{}'.format(self.camera_widget.center_0.value(), self.camera_widget.center_1.value())) config.set('Camera', 'distortion', ','.join(str(r) for r in self.camera.k.r)) config.write(fp) def _open_config_dialog(self): filename, _ = QtWidgets.QFileDialog.getOpenFileName(self, 'Load config', None, 'Config File (*.ini)') if filename: config = ConfigParser.ConfigParser() config.read(str(filename)) self._update_canvas = False self._init_model(config.get('Model', 'gender')) shapes = np.fromstring(config.get('Model', 'shape'), dtype=np.float64, sep=',') poses = np.fromstring(config.get('Model', 'pose'), dtype=np.float64, sep=',') position = np.fromstring(config.get('Model', 'translation'), dtype=np.float64, sep=',') for key, shape in self._shapes(): val = shapes[key] / 5.0 * 50.0 + 50.0 shape.setValue(val) for key, pose in self._poses(): if key == 0: val = (poses[key] - np.pi) / np.pi * 50.0 + 50.0 else: val = poses[key] / np.pi * 50.0 + 50.0 pose.setValue(val) self.pos_0.setValue(position[0]) self.pos_1.setValue(position[1]) self.pos_2.setValue(position[2]) cam_pos = np.fromstring(config.get('Camera', 'translation'), dtype=np.float64, sep=',') cam_rot = np.fromstring(config.get('Camera', 'rotation'), dtype=np.float64, sep=',') cam_dist = np.fromstring(config.get('Camera', 'distortion'), dtype=np.float64, sep=',') cam_c = np.fromstring(config.get('Camera', 'center'), dtype=np.float64, sep=',') cam_f = config.getfloat('Camera', 'focal_length') print cam_c self.camera_widget.set_values(cam_pos, cam_rot, cam_f, cam_c, cam_dist) self._update_canvas = True self.draw() def _save_screenshot_dialog(self): filename, _ = QtWidgets.QFileDialog.getSaveFileName(self, 'Save screenshot', None, 'Images (*.png *.jpg *.ppm)') if filename: img = np.array(self.rn.r) if self.view_joints.isChecked() or self.view_joint_ids.isChecked() or self.view_bones.isChecked(): img = self._draw_annotations(img) cv2.imwrite(str(filename), np.uint8(img * 255)) def _save_mesh_dialog(self): filename, _ = QtWidgets.QFileDialog.getSaveFileName(self, 'Save mesh', None, 'Mesh (*.obj)') if filename: with open(filename, 'w') as fp: for v in self.model.r: fp.write('v %f %f %f\n' % (v[0], v[1], v[2])) for f in self.model.f + 1: fp.write('f %d %d %d\n' % (f[0], f[1], f[2])) def _zoom(self, event): delta = -event.angleDelta().y() / 1200.0 self.camera_widget.pos_2.setValue(self.camera_widget.pos_2.value() + delta) def _mouse_begin(self, event): if event.button() == 1: self._moving = True elif event.button() == 2: self._rotating = True self._mouse_begin_pos = event.pos() def _mouse_end(self, event): self._moving = False self._rotating = False def _move(self, event): if self._moving: delta = event.pos() - self._mouse_begin_pos self.camera_widget.pos_0.setValue(self.camera_widget.pos_0.value() + delta.x() / 500.) self.camera_widget.pos_1.setValue(self.camera_widget.pos_1.value() + delta.y() / 500.) self._mouse_begin_pos = event.pos() elif self._rotating: delta = event.pos() - self._mouse_begin_pos self.camera_widget.rot_0.setValue(self.camera_widget.rot_0.value() + delta.y() / 300.) self.camera_widget.rot_1.setValue(self.camera_widget.rot_1.value() - delta.x() / 300.) self._mouse_begin_pos = event.pos() def _show_camera_widget(self): self.camera_widget.show() self.camera_widget.raise_() def _update_shape(self, id, val): val = (val - 50) / 50.0 * 5.0 self.model.betas[id] = val self.draw() def _reset_shape(self): self._update_canvas = False for key, shape in self._shapes(): shape.setValue(50) self._update_canvas = True self.draw() def _update_pose(self, id, val): val = (val - 50) / 50.0 * np.pi if id == 0: val += np.pi self.model.pose[id] = val self.draw() def _reset_pose(self): self._update_canvas = False for key, pose in self._poses(): pose.setValue(50) self._update_canvas = True self.draw() def _update_position(self, id, val): self.model.trans[id] = val self.draw() def _reset_position(self): self._update_canvas = False self.pos_0.setValue(0) self.pos_1.setValue(0) self.pos_2.setValue(0) self._update_canvas = True self.draw() def _poses(self): return enumerate([ self.pose_0, self.pose_1, self.pose_2, self.pose_3, self.pose_4, self.pose_5, self.pose_6, self.pose_7, self.pose_8, self.pose_9, self.pose_10, self.pose_11, self.pose_12, self.pose_13, self.pose_14, self.pose_15, self.pose_16, self.pose_17, self.pose_18, self.pose_19, self.pose_20, self.pose_21, self.pose_22, self.pose_23, self.pose_24, self.pose_25, self.pose_26, self.pose_27, self.pose_28, self.pose_29, self.pose_30, self.pose_31, self.pose_32, self.pose_33, self.pose_34, self.pose_35, self.pose_36, self.pose_37, self.pose_38, self.pose_39, self.pose_40, self.pose_41, self.pose_42, self.pose_43, self.pose_44, self.pose_45, self.pose_46, self.pose_47, self.pose_48, self.pose_49, self.pose_50, self.pose_51, self.pose_52, self.pose_53, self.pose_54, self.pose_55, self.pose_56, self.pose_57, self.pose_58, self.pose_59, self.pose_60, self.pose_61, self.pose_62, self.pose_63, self.pose_64, self.pose_65, self.pose_66, self.pose_67, self.pose_68, self.pose_69, self.pose_70, self.pose_71, ]) def _shapes(self): return enumerate([ self.shape_0, self.shape_1, self.shape_2, self.shape_3, self.shape_4, self.shape_5, self.shape_6, self.shape_7, self.shape_8, self.shape_9, ]) @staticmethod def _to_pixmap(im): if im.dtype == np.float32 or im.dtype == np.float64: im = np.uint8(im * 255) if len(im.shape) < 3 or im.shape[-1] == 1: im = cv2.cvtColor(im, cv2.COLOR_GRAY2RGB) else: im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB) qimg = QtGui.QImage(im, im.shape[1], im.shape[0], im.strides[0], QtGui.QImage.Format_RGB888) return QtGui.QPixmap(qimg)