def __init__(self, grid_processor: GridProcessor): Renderer.__init__(self) self.grid_processor: GridProcessor = grid_processor shader_settings: List[ShaderSetting] = [] shader_settings.extend([ShaderSetting("grid_point", ["grid/grid.vert", "basic/discard_screen_color.frag"], ["screen_width", "screen_height"]), ShaderSetting("grid_cube", ["grid/grid_impostor.vert", "basic/screen_color.frag", "grid/point_to_cube_impostor.geom"], ["screen_width", "screen_height"]) ]) self.set_shader(shader_settings) self.data_handler: OverflowingVertexDataHandler = OverflowingVertexDataHandler( [], [(self.grid_processor.grid_position_buffer, 0), (self.grid_processor.grid_density_buffer, 1)]) def generate_element_count_func(gp: GridProcessor) -> Callable: buffered_gp: GridProcessor = gp def element_count_func(buffer: int): return buffered_gp.grid_density_buffer.get_objects() - buffered_gp.grid_slice_size return element_count_func self.render_funcs["grid_point"] = generate_render_function(OGLRenderFunction.ARRAYS, GL_POINTS, 10.0, depth_test=True) self.render_funcs["grid_cube"] = generate_render_function(OGLRenderFunction.ARRAYS, GL_POINTS, depth_test=True) self.element_count_funcs["grid_point"] = generate_element_count_func(grid_processor) self.element_count_funcs["grid_cube"] = generate_element_count_func(grid_processor) self.create_sets(self.data_handler)
def __init__(self): self._SAVE_FILE_PATH = 'save.plsf' self._done = False self._event_dispatcher = UserEventDispatcher(self) self._renderer = Renderer(GameSettings.Screen.WIDTH, GameSettings.Screen.HEIGHT) self._timer = GameTimer() self._city = self.load_game() self._ui = UI(self) self._state = NormalState()
def draw_detections_3D(image, detections, cam, model_map): """Draws 6D detections onto resized image Parameters ---------- image: Numpy array, normalized to [0-1] detections: A list of detections for this image, coming from SSD.detect() in the form [l, t, r, b, name, confidence, 6D_pose0, ..., 6D_poseN] cam: Intrinsics for rendering model_map: Mapping of model name to Model3D instance {'obj': model3D} """ if not detections: return np.copy(image) ren = Renderer((image.shape[1], image.shape[0]), cam) ren.clear() out = np.copy(image) for det in detections: model = model_map[det[4]] for pose in det[6:]: ren.draw_model(model, pose) ren.draw_boundingbox(model, pose) col, dep = ren.finish() # Copy the rendering over into the scene mask = np.dstack((dep, dep, dep)) > 0 out[mask] = col[mask] return out
def draw_detections_3D(image, detections, cam, model_map): """Draws 6D detections onto resized image Parameters ---------- image: Numpy array, normalized to [0-1] detections: A list of detections for this image, coming from SSD.detect() in the form [l, t, r, b, name, confidence, 6D_pose0, ..., 6D_poseN] cam: Intrinsics for rendering model_map: Mapping of model name to Model3D instance {'obj': model3D} """ if not detections: return np.copy(image) ren = Renderer((image.shape[1], image.shape[0]), cam) ren.clear() out = np.copy(image) for det in detections: model = model_map[det[4]] for pose in det[6:]: ren.draw_model(model, pose) ren.draw_boundingbox(model, pose) col, dep = ren.finish() # Copy the rendering over into the scene mask = np.dstack((dep, dep, dep)) > 0 out[mask] = col[mask] return out
def mainRender(args): #Import this module only in render mode, as it needs pygame and PyOpenGL from rendering.renderer import Renderer lastUpdate = getCurrentTimeMillis() running = True loops = 0 ######## queue = Manager().Queue() killSim = Value('i', 0) simProcess = Process(target=simLoop, args=(queue, killSim,)) simProcess.start() random.setSeed(args.seedValue) #Initialize the renderer initialData = queue.get(block=True) numPersons = initialData[0] gridSize = initialData[1] gridData = initialData[2] theRenderer = Renderer(numPersons) theRenderer.initPlaceBuffer(gridSize, gridData) #Get the first simulation datum simData = queue.get(block=True) simPersons = simData[1] simNow = simData[0] nowOb = time.Timestamp(simNow) ######## while running: now = getCurrentTimeMillis() deltaTime = now - lastUpdate running = theRenderer.fetchEvents(deltaTime) if not queue.empty(): simData = queue.get(block=False) simPersons = simData[1] simNow = simData[0] theRenderer.render(simPersons, deltaTime, simNow) nowOb = time.Timestamp(simNow) loops += 1 if loops % 100 == 0: print("Simulation time: {0}:{1}:{2}".format(nowOb.day(), nowOb.hourOfDay(), nowOb.minuteOfHour())) if args.numDays > 0 and nowOb.day() >= args.numDays: running = False theRenderer.quit() killSim.value = 1 while(not queue.empty()): queue.get(block=False) simProcess.join()
def precompute_projections(dataset, views, cam, model_map, models): """Precomputes the projection information needed for 6D pose construction """ save_path = f"output/{dataset}" # save the rendered images if not os.path.exists(save_path): os.makedirs(save_path) w, h = 640, 480 ren = Renderer((w, h), cam) for model_name in models: count = 0 # 图片计数 scene_camera = {} scene_gt = {} model_path = os.path.join(save_path, model_name[-6:]) rgb_dir = os.path.join(model_path, 'rgb') depth_dir = os.path.join(model_path, 'mask') ensure_dir(rgb_dir) ensure_dir(depth_dir) for i in tqdm(range(len(views))): pose = create_pose(views[i], angle_deg=0) pose[:3, 3] = [0, 0, 0.5] # zr = 0.5 model = model_map[model_name] # 随机选出一个模型 ren.clear() ren.draw_model(model, pose) # ren.draw_boundingbox(model, pose) col, dep = ren.finish() # dep 缩放因子是0.001 col *= 255 dep[dep > 0] = 255 # cam2d = project(model.fps, pose, cam) # ys, xs = np.nonzero(dep > 0) # xs_min = xs_original.min() # ys_min = ys_original.min() # xs_max = xs_original.max() # ys_max = ys_original.max() scene_camera[str(i)] = { 'cam_K': cam.flatten().tolist(), 'depth_scale': 1, 'view_level': 4, } scene_gt[str(i)] = [{ 'cam_R_m2c': pose[:3, :3].flatten().tolist(), 'cam_t_m2c': pose[:3, 3].flatten().tolist(), 'obj_id': int(model_name[-2:]) }] # draw fps # for i_p, point in enumerate(cam2d): # if i_p == 0: # col = cv2.circle(col, (point[0], point[1]), 3, (0, 255, 0), thickness=-1) # else: # col = cv2.circle(col, (point[0], point[1]), 3, (0, 0, 255), thickness=-1) cv2.imwrite(os.path.join(rgb_dir, str(count).zfill(6) + '.png'), col) cv2.imwrite(os.path.join(depth_dir, str(count).zfill(6) + '_000000' + '.png'), dep) count += 1 save_json(os.path.join(model_path, 'scene_camera.json'), scene_camera) save_json(os.path.join(model_path, 'scene_gt.json'), scene_gt)
def __init__(self, node_processor: NodeProcessor, grid: Grid): Renderer.__init__(self) self.node_processor = node_processor self.grid = grid shader_settings: List[ShaderSetting] = [] shader_settings.extend([ShaderSetting("node_point", ["node/sample.vert", "basic/discard_screen_color.frag"], ["screen_width", "screen_height"]), ShaderSetting("node_sphere", ["node/sample_impostor.vert", "node/point_to_sphere_impostor_phong.frag", "node/point_to_sphere_impostor.geom"], ["node_object_radius", "node_importance_threshold"]), ShaderSetting("node_transparent_sphere", ["node/sample_impostor.vert", "node/point_to_sphere_impostor_transparent.frag", "node/point_to_sphere_impostor.geom"], ["node_object_radius", "node_base_opacity", "node_importance_opacity", "node_depth_opacity", "node_opacity_exponent", "node_importance_threshold"]) ]) self.set_shader(shader_settings) self.data_handler: VertexDataHandler = VertexDataHandler([(self.node_processor.node_buffer, 0)]) def generate_element_count_func(np: NodeProcessor) -> Callable: buffered_np: NodeProcessor = np def element_count_func(): return buffered_np.get_buffer_points() return element_count_func self.render_funcs["node_point"] = generate_render_function(OGLRenderFunction.ARRAYS, GL_POINTS, 10.0, depth_test=True) self.render_funcs["node_sphere"] = generate_render_function(OGLRenderFunction.ARRAYS, GL_POINTS, depth_test=True) self.render_funcs["node_transparent_sphere"] = generate_render_function(OGLRenderFunction.ARRAYS, GL_POINTS, add_blending=True) self.element_count_funcs["node_point"] = generate_element_count_func(node_processor) self.element_count_funcs["node_sphere"] = generate_element_count_func(node_processor) self.element_count_funcs["node_transparent_sphere"] = generate_element_count_func(node_processor) self.create_sets(self.data_handler)
def verify_6D_poses(detections, model_map, cam, image): """For one image, select for each detection the best pose from the 6D pool # Arguments detections: List of predictions for one image. Each prediction is: [xmin, ymin, xmax, ymax, label, confidence, (pose00), ..., (poseNM)] where poseXX is a 4x4 matrix model_map: Mapping of model name to Model3D instance {'obj': model3D} cam: Intrinsics to use for backprojection image: The scene color image # Returns filtered: List of predictions for one image. Each prediction has the form: [xmin, ymin, xmax, ymax, label, confidence, pose] where pose is a 4x4 matrix """ def compute_grads_and_mags(color): gray = cv2.cvtColor(color, cv2.COLOR_BGR2GRAY) grads = np.dstack( (cv2.Sobel(gray, cv2.CV_32F, 1, 0, ksize=5), cv2.Sobel(gray, cv2.CV_32F, 0, 1, ksize=5))) mags = np.sqrt(np.sum(grads**2, axis=2)) + 0.001 # To avoid div/0 grads /= np.dstack((mags, mags)) mask = mags < 5 mags[mask] = 0 grads[np.dstack((mask, mask))] = 0 return grads, mags scene_grads, scene_mags = compute_grads_and_mags(image) scene_grads = np.reshape(scene_grads, (-1, 2)) #cv2.imshow('mags', scene_mags) ren = Renderer((image.shape[1], image.shape[0]), cam) filtered = [] for det in detections: model = model_map[det[4]] scores = [] for pose in det[6:]: ren.clear() ren.draw_model(model, pose) ren_grads, ren_mags = compute_grads_and_mags(ren.finish()[0]) ren_grads = np.reshape(ren_grads, (-1, 2)) dot = np.sum( np.abs(ren_grads[:, 0] * scene_grads[:, 0] + ren_grads[:, 1] * scene_grads[:, 1])) sum = np.sum(ren_mags > 0) scores.append(dot / sum) new_det = det[:6] new_det.append( det[6 + np.argmax(np.asarray(scores))]) # Put best pose first filtered.append(new_det) return filtered
def precompute_projections(views, inplanes, cam, model3D): """Precomputes the projection information needed for 6D pose construction # Arguments views: List of 3D viewpoint positions inplanes: List of inplane angles in degrees cam: Intrinsics to use for translation estimation model3D: Model3D instance # Returns data: a 3D list with precomputed entities with shape (views, inplanes, (4x4 pose matrix, 3) ) """ w, h = 640, 480 ren = Renderer((w, h), cam) data = [] if model3D.vertices is None: return data for v in tqdm(range(len(views))): data.append([]) for i in inplanes: pose = create_pose(views[v], angle_deg=i) pose[:3, 3] = [0, 0, 0.5] # zr = 0.5 # Render object and extract tight 2D bbox and projected 2D centroid ren.clear() ren.draw_model(model3D, pose) box = np.argwhere( ren.finish()[1]) # Deduct bbox from depth rendering box = [ box.min(0)[1], box.min(0)[0], box.max(0)[1] + 1, box.max(0)[0] + 1 ] centroid = np.matmul(pose[:3, :3], model3D.centroid) + pose[:3, 3] centroid_x = cam[0, 2] + centroid[0] * cam[0, 0] / centroid[2] centroid_y = cam[1, 2] + centroid[1] * cam[1, 1] / centroid[2] # Compute 2D centroid position in normalized, box-local reference frame box_w, box_h = (box[2] - box[0]), (box[3] - box[1]) norm_centroid_x = (centroid_x - box[0]) / box_w norm_centroid_y = (centroid_y - box[1]) / box_h # Compute normalized diagonal box length lr = np.sqrt((box_w / w)**2 + (box_h / h)**2) data[-1].append((pose, [norm_centroid_x, norm_centroid_y, lr])) return data
def verify_6D_poses(detections, model_map, cam, image): """For one image, select for each detection the best pose from the 6D pool # Arguments detections: List of predictions for one image. Each prediction is: [xmin, ymin, xmax, ymax, label, confidence, (pose00), ..., (poseNM)] where poseXX is a 4x4 matrix model_map: Mapping of model name to Model3D instance {'obj': model3D} cam: Intrinsics to use for backprojection image: The scene color image # Returns filtered: List of predictions for one image. Each prediction has the form: [xmin, ymin, xmax, ymax, label, confidence, pose] where pose is a 4x4 matrix """ def compute_grads_and_mags(color): gray = cv2.cvtColor(color, cv2.COLOR_BGR2GRAY) grads = np.dstack((cv2.Sobel(gray, cv2.CV_32F, 1, 0, ksize=5), cv2.Sobel(gray, cv2.CV_32F, 0, 1, ksize=5))) mags = np.sqrt(np.sum(grads**2, axis=2)) + 0.001 # To avoid div/0 grads /= np.dstack((mags, mags)) mask = mags < 5 mags[mask] = 0 grads[np.dstack((mask, mask))] = 0 return grads, mags scene_grads, scene_mags = compute_grads_and_mags(image) scene_grads = np.reshape(scene_grads, (-1, 2)) #cv2.imshow('mags', scene_mags) ren = Renderer((image.shape[1], image.shape[0]), cam) filtered = [] for det in detections: model = model_map[det[4]] scores = [] for pose in det[6:]: ren.clear() ren.draw_model(model, pose) ren_grads, ren_mags = compute_grads_and_mags(ren.finish()[0]) ren_grads = np.reshape(ren_grads, (-1, 2)) dot = np.sum(np.abs(ren_grads[:, 0]*scene_grads[:, 0] + ren_grads[:, 1]*scene_grads[:, 1])) sum = np.sum(ren_mags>0) scores.append(dot / sum) new_det = det[:6] new_det.append(det[6 + np.argmax(np.asarray(scores))]) # Put best pose first filtered.append(new_det) return filtered
def precompute_projections(views, inplanes, cam, model3D): """Precomputes the projection information needed for 6D pose construction # Arguments views: List of 3D viewpoint positions inplanes: List of inplane angles in degrees cam: Intrinsics to use for translation estimation model3D: Model3D instance # Returns data: a 3D list with precomputed entities with shape (views, inplanes, (4x4 pose matrix, 3) ) """ w, h = 640, 480 ren = Renderer((w, h), cam) data = [] if model3D.vertices is None: return data for v in tqdm(range(len(views))): data.append([]) for i in inplanes: pose = create_pose(views[v], angle_deg=i) pose[:3, 3] = [0, 0, 0.5] # zr = 0.5 # Render object and extract tight 2D bbox and projected 2D centroid ren.clear() ren.draw_model(model3D, pose) box = np.argwhere(ren.finish()[1]) # Deduct bbox from depth rendering box = [box.min(0)[1], box.min(0)[0], box.max(0)[1] + 1, box.max(0)[0] + 1] centroid = np.matmul(pose[:3, :3], model3D.centroid) + pose[:3, 3] centroid_x = cam[0, 2] + centroid[0] * cam[0, 0] / centroid[2] centroid_y = cam[1, 2] + centroid[1] * cam[1, 1] / centroid[2] # Compute 2D centroid position in normalized, box-local reference frame box_w, box_h = (box[2] - box[0]), (box[3] - box[1]) norm_centroid_x = (centroid_x - box[0]) / box_w norm_centroid_y = (centroid_y - box[1]) / box_h # Compute normalized diagonal box length lr = np.sqrt((box_w / w) ** 2 + (box_h / h) ** 2) data[-1].append((pose, [norm_centroid_x, norm_centroid_y, lr])) return data
def __init__(self, cfg): self.cfg = cfg self.rgb_topic = cfg['rgb_topic'] self.depth_topic = cfg['depth_topic'] self.camK = np.array(cfg['cam_K']).reshape(3, 3) self.im_width = int(cfg['im_width']) self.im_height = int(cfg['im_height']) self.inlier_th = float(cfg['inlier_th']) self.ransac_th = float(cfg['ransac_th']) self.model_params = inout.load_json(cfg['norm_factor_fn']) self.detection_labels = cfg[ 'obj_labels'] #labels of corresponding detections if (icp): self.ren = Renderer((self.im_width, self.im_height), self.camK) n_objs = int(cfg['n_objs']) self.target_objs = cfg['target_obj_name'] self.colors = np.random.randint(0, 255, (n_objs, 3)) if (detect_type == "rcnn"): #Load mask r_cnn ''' standard estimation parameter for Mask R-CNN (identical for all dataset) ''' self.config = BopInferenceConfig(dataset="ros", num_classes=n_objs + 1, im_width=self.im_width, im_height=self.im_height) self.config.DETECTION_MIN_CONFIDENCE = 0.3 self.config.DETECTION_MAX_INSTANCES = 30 self.config.DETECTION_NMS_THRESHOLD = 0.5 self.detection_model = modellib.MaskRCNN(mode="inference", config=self.config, model_dir="/") self.detection_model.load_weights(cfg['path_to_detection_weights'], by_name=True) self.obj_models = [] self.obj_bboxes = [] self.obj_pix2pose = [] pix2pose_dir = cfg['path_to_pix2pose_weights'] th_outlier = cfg['outlier_th'] self.model_scale = cfg['model_scale'] for t_id, target_obj in enumerate(self.target_objs): weight_fn = os.path.join( pix2pose_dir, "{:02d}/inference.hdf5".format(target_obj)) print("Load pix2pose weights from ", weight_fn) model_param = self.model_params['{}'.format(target_obj)] obj_param = bop_io.get_model_params(model_param) recog_temp = recog.pix2pose(weight_fn, camK=self.camK, res_x=self.im_width, res_y=self.im_height, obj_param=obj_param, th_ransac=self.ransac_th, th_outlier=th_outlier, th_inlier=self.inlier_th) self.obj_pix2pose.append(recog_temp) ply_fn = os.path.join(self.cfg['model_dir'], self.cfg['ply_files'][t_id]) if (icp): obj_model = Model3D() obj_model.load(ply_fn, scale=cfg['model_scale']) self.obj_models.append(obj_model) else: obj_model = inout.load_ply(ply_fn) self.obj_bboxes.append(self.get_3d_box_points( obj_model['pts'])) rospy.init_node('pix2pose', anonymous=True) self.detect_pub = rospy.Publisher("/pix2pose/detected_object", ros_image) #self.pose_pub = rospy.Publisher("/pix2pose/object_pose", Pose) self.pose_pub = rospy.Publisher("/pix2pose/object_pose", ros_image) self.sub = rospy.Subscriber(self.rgb_topic, ros_image, self.callback) self.graph = tf.get_default_graph()
ref_gt = inout.load_scene_gt( os.path.join("/home/kiru/media/hdd/bop/tless/train_render_reconst/000001", "scene_gt.json")) ref_camera = inout.load_scene_camera( os.path.join("/home/kiru/media/hdd/bop/tless/train_render_reconst/000001", "scene_camera.json")) #bop_dir,source_dir,model_plys,model_info,model_ids,rgb_files,depth_files,mask_files,gts,cam_param_global = bop_io.get_dataset('hb',train=True) #bop_dir,source_dir,model_plys,model_info,model_ids,rgb_files,depth_files,mask_files,gts,cam_param_global = bop_io.get_dataset('itodd',train=True) bop_dir, source_dir, model_plys, model_info, model_ids, rgb_files, depth_files, mask_files, gts, cam_param_global = bop_io.get_dataset( 'ycbv', train=True) im_width, im_height = cam_param_global['im_size'] camK = cam_param_global['K'] cam_K_list = np.array(camK).reshape(-1) ren = Renderer((im_width, im_height), camK) source_dir = bop_dir + "/train" if not (os.path.exists(source_dir)): os.makedirs(source_dir) for i in range(len(model_plys)): target_dir = source_dir + "/{:06d}".format(model_ids[i]) if not (os.path.exists(target_dir)): os.makedirs(target_dir) if not (os.path.exists(target_dir + "/rgb")): os.makedirs(target_dir + "/rgb") if not (os.path.exists(target_dir + "/depth")): os.makedirs(target_dir + "/depth") if not (os.path.exists(target_dir + "/mask")): os.makedirs(target_dir + "/mask") new_gt = copy.deepcopy(ref_gt) new_camera = copy.deepcopy(ref_camera) scene_gt = os.path.join(target_dir, "scene_gt.json")
args.mesh_path = 'mesh_templates/uvsphere_16rings.obj' else: raise print('Using autodetected mesh', args.mesh_path) mesh_template = MeshTemplate(args.mesh_path, is_symmetric=args.symmetric) if args.generate_pseudogt: # Ideally, the renderer should run at a higher resolution than the input image, # or a sufficiently high resolution at the very least. renderer_res = max(1024, 2*args.pseudogt_resolution) else: # Match neural network input resolution renderer_res = args.image_resolution renderer = Renderer(renderer_res, renderer_res) class ImageDataset(torch.utils.data.Dataset): def __init__(self, cmr_dataset, img_size): self.cmr_dataset = cmr_dataset self.paths = cmr_dataset.get_paths() self.extra_img_keys = [] if isinstance(img_size, list): for res in img_size[1:]: self.extra_img_keys.append(f'img_{res}') def __len__(self): return len(self.cmr_dataset) def __getitem__(self, idx):
def __init__(self, mesh, res_h, res_w): super().__init__() self.res = (res_h, res_w) self.inverse_renderer = Renderer(res_h, res_w) self.mesh = mesh
pin_memory=True, shuffle=False) if not args.texture_only: # Load libraries needed for differentiable rendering and FID evaluation from rendering.renderer import Renderer import scipy mesh_template = MeshTemplate(args.mesh_path, is_symmetric=args.symmetric_g) # For real-time FID evaluation if not args.save_results: evaluation_res = 299 # Same as Inception input resolution else: evaluation_res = 512 # For exporting images: higher resolution renderer = Renderer(evaluation_res, evaluation_res) renderer = nn.DataParallel(renderer, gpu_ids) if not args.save_results: inception_model = nn.DataParallel(init_inception(), gpu_ids).cuda().eval() # Statistics for real images are computed only once and cached m_real_train, s_real_train = None, None m_real_val, s_real_val = None, None # Load precomputed statistics to speed up FID computation stats = np.load(os.path.join(cache_dir, f'precomputed_fid_{evaluation_res}x{evaluation_res}_train.npz'), allow_pickle=True) m_real_train = stats['stats_m'] s_real_train = stats['stats_s'] + np.triu(stats['stats_s'].T, 1) assert stats['num_images'] == len(train_ds), 'Number of images does not match' assert stats['resolution'] == evaluation_res, 'Resolution does not match'
max_trans_pert = float(args["--max_trans_pert"]) iterations = int(args["--iterations"]) bench = load_sixd(sixd_base, nr_frames=1, seq=obj) croppings = yaml.load(open('config/croppings.yaml', 'r')) if 'linemod' in network: dataset_name = 'linemod' elif 'tejani' in network: dataset_name = 'tejani' else: raise Exception('Could not determine dataset') with tf.Session() as session: architecture = Architecture(network_file=network, sess=session) ren = Renderer((640, 480), bench.cam) refiner = Refiner(architecture=architecture, ren=ren, session=session) for frame in bench.frames: col = frame.color.copy() _, gt_pose, _ = frame.gt[0] perturbed_pose = perturb_pose(gt_pose, max_rot_pert, max_trans_pert) refinable = Refinable(model=bench.models[str(int(obj))], label=0, hypo_pose=perturbed_pose, metric_crop_shape=croppings[dataset_name]['obj_{:02d}'.format(int(obj))], input_col=col) for i in range(iterations): refinable.input_col = col.copy() start = timer()
class Game(object): def __init__(self): self._SAVE_FILE_PATH = 'save.plsf' self._done = False self._event_dispatcher = UserEventDispatcher(self) self._renderer = Renderer(GameSettings.Screen.WIDTH, GameSettings.Screen.HEIGHT) self._timer = GameTimer() self._city = self.load_game() self._ui = UI(self) self._state = NormalState() def start(self) -> None: self._timer.reset() while not self._done: for user_event in pygame.event.get(): self._event_dispatcher.dispatch(user_event) self._city.simulate() self._renderer.render(self._city, self._ui) def get_city(self) -> City: return self._city def get_state(self) -> GameState: return self._state def set_state(self, state: GameState) -> None: self._state = state def toggle_grid(self) -> None: self._ui.toggle_grid() def toggle_buildings_window(self) -> None: self._ui.toggle_buildings_window() def handle_mouse_down(self, position: Tuple) -> None: if type(self._state) is NormalState: self._ui.handle_mouse_down(position) def handle_mouse_up(self, position: Tuple) -> None: if type(self._state) is NormalState: self._ui.handle_mouse_up(position) elif type(self._state) is PlacingNewBuildingState: building = self._state.building building.set_position((position[0] / GameSettings.Game.FIELD_SIZE, position[1] / GameSettings.Game.FIELD_SIZE)) if not self._city.is_rectangle_ocuppied(building.position): self._city.add_city_object(building) self._state = NormalState() def save_game(self) -> None: json_data = self._city.jsonify() with open(self._SAVE_FILE_PATH, 'w') as save_file: save_file.write(json.dumps(json_data, indent=4)) def load_game(self) -> City: city = City() if os.path.isfile(self._SAVE_FILE_PATH): with open('save.plsf') as save_file: data = json.load(save_file) try: city.load(data) except Exception: traceback.print_exc() city = City() return city def end_game(self) -> None: self.save_game() self._done = True
def __init__(self, edge_processor: EdgeProcessor, grid: Grid): Renderer.__init__(self) self.edge_processor = edge_processor self.grid = grid shader_settings: List[ShaderSetting] = [] shader_settings.extend( [ShaderSetting("sample_point", ["sample/sample.vert", "basic/discard_screen_color.frag"], ["edge_importance_threshold", "screen_width", "screen_height"]), ShaderSetting("sample_line", ["sample/sample_impostor.vert", "basic/color.frag", "sample/points_to_line.geom"], ["edge_importance_threshold"]), ShaderSetting("sample_sphere", ["sample/sample_impostor.vert", "sample/point_to_sphere_impostor_phong.frag", "sample/point_to_sphere_impostor.geom"], ["edge_object_radius", "edge_importance_threshold"]), ShaderSetting("sample_transparent_sphere", ["sample/sample_impostor.vert", "sample/point_to_sphere_impostor_transparent.frag", "sample/point_to_sphere_impostor.geom"], ["edge_object_radius", "edge_base_opacity", "edge_importance_opacity", "edge_depth_opacity", "edge_opacity_exponent", "edge_importance_threshold"]), ShaderSetting("sample_ellipsoid_transparent", ["sample/sample_impostor.vert", "sample/points_to_ellipsoid_impostor_transparent.frag", "sample/points_to_ellipsoid_impostor.geom"], ["edge_object_radius", "edge_base_opacity", "edge_importance_opacity", "edge_depth_opacity", "edge_opacity_exponent", "edge_importance_threshold"]) ]) self.set_shader(shader_settings) self.data_handler: LayeredVertexDataHandler = LayeredVertexDataHandler([[VertexDataHandler( [(self.edge_processor.sample_buffer[i][j], 0), (self.edge_processor.edge_buffer[i][j], 2)], []) for j in range(len(self.edge_processor.sample_buffer[i]))] for i in range(len(self.edge_processor.sample_buffer))]) def generate_element_count_func(ep: EdgeProcessor) -> Callable: buffered_ep: EdgeProcessor = ep def element_count_func(layer: int, buffer: int): return buffered_ep.get_buffer_points(layer, buffer) return element_count_func self.render_funcs["sample_point"] = generate_render_function(OGLRenderFunction.ARRAYS_INSTANCED, GL_POINTS, 10.0, depth_test=True) self.render_funcs["sample_line"] = generate_render_function(OGLRenderFunction.ARRAYS_INSTANCED, GL_POINTS, line_width=2.0, depth_test=True) self.render_funcs["sample_sphere"] = generate_render_function(OGLRenderFunction.ARRAYS_INSTANCED, GL_POINTS, depth_test=True) self.render_funcs["sample_transparent_sphere"] = generate_render_function(OGLRenderFunction.ARRAYS_INSTANCED, GL_POINTS, add_blending=True) self.render_funcs["sample_ellipsoid_transparent"] = generate_render_function(OGLRenderFunction.ARRAYS_INSTANCED, GL_POINTS, add_blending=True) self.element_count_funcs["sample_point"] = generate_element_count_func(edge_processor) self.element_count_funcs["sample_line"] = generate_element_count_func(edge_processor) self.element_count_funcs["sample_sphere"] = generate_element_count_func(edge_processor) self.element_count_funcs["sample_transparent_sphere"] = generate_element_count_func(edge_processor) self.element_count_funcs["sample_ellipsoid_transparent"] = generate_element_count_func(edge_processor) self.create_sets(self.data_handler) self.importance_threshold: float = 0.0