def visualizeResults(self, points, normals, seeds, seeds_normals, scores, Y_real, num_of_points): num_of_samples = points.__len__() # Unscale the predictions: scores_unscaled = getUnscaledArray(scaled_points=scores, mins=np.asarray(self.mins), maxs=np.asarray(self.maxs), high=1.0, low=0.0) #new_shape = (num_of_samples, v.NUM_OF_POINTS, 2) #scores_unscaled = np.reshape(scores_unscaled, new_shape) Y_real_unscaled = getUnscaledArray(scaled_points=Y_real, mins=np.asarray(self.mins), maxs=np.asarray(self.maxs), high=1.0, low=0.0) #Y_real_unscaled = np.reshape(Y_real_unscaled, new_shape) for it in range(num_of_samples): score = scores_unscaled[it] score_real = Y_real_unscaled[it] sample_points = points[it] sample_normals = normals[it] seed_point = seeds[it] seed_normal = seeds_normals[it] sample_points = [p + seed_point for p in sample_points] sample = fromNumpyArray(sample_points, sample_normals) rsv_predicted = rsv(sample) q = rsv_predicted.computeRadialPoint_i(seed_point, seed_normal, delta=score[0]) r_prima = rsv_predicted.computeRadialVectorPrima_i(seed_normal, l=score[1]) rsv_real = rsv(sample) q_real = rsv_real.computeRadialPoint_i(seed_point, seed_normal, delta=score_real[0]) r_prima_real = rsv_real.computeRadialVectorPrima_i(seed_normal, l=score_real[1]) vis = visualizer() vis.addPointcloud(sample) vis.addSphere(center = seed_point, color=[0,0,0]) vis.addSphere(center = q, color=[0,1,0]) vis.addSphere(center = q_real, color=[0,0,1]) vis.addLine(q, q_real) vis.addLine(seed_point, q_real, color=[1,0,0]) vis.show() vis = visualizer() vis.addPointcloud(sample) vis.addSphere(center = seed_point, color=[0,0,0]) vis.addSphere(center = q, color=[0,0,0]) vis.addSphere(center = q + r_prima, color=[0,1,0]) vis.addSphere(center = q + r_prima_real, color=[0,0,1]) vis.addLine(q, q + r_prima_real) vis.addLine(q, q + r_prima) vis.addLine(seed_point, q, color=[1,0,0]) vis.show()
def graph(amr_table, output_path, curt=False): import visualizer graph_path = output_path + 'graphs/' try: os.mkdir(graph_path) except OSError: pass for docid in sorted(amr_table): for senid in sorted(amr_table[docid]): sen = amr_table[docid][senid] if curt: visualizer.visualizer_curt(sen, graph_path) else: visualizer.visualizer(sen, graph_path)
def visualizeRadialVector_withFrame(self, q, r_prima, R, num_of_samples): # Initialize visualizer vis = visualizer() vis.addPointcloud(cloud=self.cloud, color=CLOUD_COLOR) vis.addSphere(self.c, CENTER_COLOR, CENTER_RADIUS) # Randomly select a subsample of points indices = range(self.num_of_points) for index in np.random.choice(indices, num_of_samples): # Sphere to visualize the reference point vis.addSphere(self.points[index], P_PRIMA_COLOR, P_PRIMA_RADIUS) # Sphere to visualize the radial point vis.addSphere(q[index], RADIAL_POINT_COLOR, RADIAL_POINT_RADIUS) # Sphere to visualize the vote generated by r_prima vote = q[index] + r_prima[index] vis.addSphere(vote, VOTE_COLOR, VOTE_RADIUS) # Line from the vote to the radial point vis.addLine(vote, q[index]) # Line from the p_prima to the radial point vis.addLine(self.points[index], q[index]) # Add reference frame vis.addFrame(center=self.points[index], size=FRAME_SIZE, R=R[index]) # Show results vis.show()
def generate(self): ''' main function that generate the report and call the functions of the report sections ''' self.doc.packages.append( Package('geometry', options=['tmargin=1cm', 'lmargin=0.5cm'])) # cover page # self.doc.preamble.append(Command( 'title', 'Experiemts Report', )) self.doc.preamble.append(Command('author', 'ATOM')) self.doc.append(NoEscape(r'\maketitle')) self.doc.append(NoEscape(r'\pagebreak')) # summary # self.gen_summary(self.experiments.iloc[0][1]) self.doc.append(NoEscape(r'\pagebreak')) #start new page # Top N Models # self.draw_top_models(4) self.doc.append(NoEscape(r'\pagebreak')) #start new page # Graphs # visu = visualizer(save_dir=self.path) self.gen_graphs(visu) # generate pdf file # self.doc.generate_pdf('example') print 'Finished Report Generation'
def visualizePrediction(self, points, scores): """ Visualization for the segments classified as object. Parameters ---------- points: N x num_of_points x num_of_dimensions array Point data for the set. scores: N x NUM_OF_CATEGORIES array Scores for the set. """ # Create visualizer object. vis = visualizer() # Loop through all the samples in order to assign the correct color # depending on their score num_of_samples = points.__len__() for i in range(num_of_samples): # Get the predicted class for the segment predicted_class = self.getPredictedClass(scores[i]) # Get the segment as a point cloud segment = fromNumpyArray(points[i]) if predicted_class == "object": vis.addPointcloud(segment, color=CANDIDATE_COLOR) vis.show()
def visualizeVote(self, votes, R, q, num_of_votes: int): # Initialize visualizer vis = visualizer() vis.addPointcloud(self.cloud, CLOUD_COLOR) vis.addSphere(self.c, CENTER_COLOR, CENTER_RADIUS) vis.addFrame(self.c, FRAME_SIZE * 2) vis.addFrame([0.0, 0.0, 0.0], FRAME_SIZE * 2) # Add visualization aid to as many votes as requested for i in range(num_of_votes): # Select a random vote index = random.randint(0, self.num_of_points) # Sphere to visualize p_prima vis.addSphere(self.points[index], P_PRIMA_COLOR, P_PRIMA_RADIUS) # Line from p_prima to the radial point vis.addLine(self.points[index], q[index]) # Sphere to visualize the radial point vis.addSphere(q[index], RADIAL_POINT_COLOR, RADIAL_POINT_RADIUS) # Get the vote data t_i = votes[index] R_i = R[index] # Get the tesallation_level [_, tesallation_level, _] = votes.shape # Loop through all the votes generated for the reference point # p_prima for j in range(tesallation_level): # Sphere to visualize the vote vis.addSphere(t_i[j], VOTE_COLOR, VOTE_RADIUS) # Reference frame for the vote vis.addFrame(t_i[j], FRAME_SIZE, t=None, R=R_i[j]) # Line from the vote to the radial point vis.addLine(t_i[j], q[index]) # Show results vis.show()
def html(amr_table, filename, output_path): output = open(output_path + '%s.html' % filename, 'w') import visualizer graph_path = output_path + 'graphs/' try: os.mkdir(graph_path) except OSError: pass # head = '<meta charset=\'utf-8\'>\n' head = os.path.dirname(os.path.abspath(__file__)) + '/html_head' output.write(open(head, 'r').read()) for docid in sorted(amr_table): for senid in sorted(amr_table[docid]): sen = amr_table[docid][senid] visualizer.visualizer(sen, graph_path) get_sentence(sen, output)
def visualizeSegment(self, visualize, seed_points, s_neighboring_idx, index): vis = visualizer() # Color the point cloud and the subset self.scene.paint_uniform_color([0, 1, 0]) vis.addSphere(center=seed_points[index], color=[1, 0, 0], radius=3) np.asarray(self.scene.colors)[s_neighboring_idx[index], :] = [0, 0, 1] vis.addPointcloud(self.scene) vis.show()
def evaluateOneSample(self, sample, scene_file_path, object, method='ADD', diagonal=0.0, visualize=False): # Load the corresponding scene pointcloud scene = o3d.io.read_point_cloud(scene_file_path) # Load the sample transformations T_gt = self.getData(sample, 'T_ground_truth') T = self.getData(sample, 'T') T_icp_ptpoint = self.getData(sample, 'T_icp_ptpoint') T_icp_ptplane = self.getData(sample, 'T_icp_ptplane') if T_gt is None or T_icp_ptpoint is None or T_icp_ptplane is None or T is None: return 'None' T_gt = np.asarray(T_gt) T = np.asarray(T) T_icp_ptplane = np.asarray(T_icp_ptplane) T_icp_ptpoint = np.asarray(T_icp_ptpoint) # Apply transformations to the object object_gt = applyGroundTruthPoseToObject(object, T_gt) object_T = applyPoseToObject(object, T) object_icp_ptplane = applyPoseToObject(object, T_icp_ptplane) object_icp_ptpoint = applyPoseToObject(object, T_icp_ptpoint) # Compute evaluation metric if method == 'ADD': m_value_T, m_valid_T = self.computeADD(object_gt, object_T, diagonal) m_value_icp_ptplane, m_valid_icp_ptplane = self.computeADD(object_gt, object_icp_ptplane, diagonal) m_value_icp_ptpoint, m_valid_icp_ptpoint = self.computeADD(object_gt, object_icp_ptpoint, diagonal) elif method == 'CD': m_value_T, m_valid_T = self.computeCD(object_gt, object_T) m_value_icp_ptplane, m_valid_icp_ptplane = self.computeCD(object_gt, object_icp_ptplane) m_value_icp_ptpoint, m_valid_icp_ptpoint = self.computeCD(object_gt, object_icp_ptpoint) elif method == 'RD': max_angle = 5 m_value_T, m_valid_T = self.computeRadialDistance(T_gt, T, 'z', Threshold=max_angle) m_value_icp_ptplane, m_valid_icp_ptplane = self.computeRadialDistance(T_gt, T_icp_ptplane, 'z', Threshold=max_angle) m_value_icp_ptpoint, m_valid_icp_ptpoint = self.computeRadialDistance(T_gt, T_icp_ptpoint, 'z', Threshold=max_angle) msg = 'Sample data: ' + sample + ' Result: | ' + str(m_valid_T) + ' , ' + str(m_valid_icp_ptplane) + ' , ' + str(m_valid_icp_ptpoint) + ' | ' print(msg) if visualize is True: vis = visualizer() #vis.addPointcloud(object_T, color=[1, 0.706, 0]) vis.addPointcloud(object_icp_ptplane, color=[0, 1, 0]) #vis.addPointcloud(object_icp_ptpoint, color=[0, 0.706, 0]) scene = cropScene(object_gt, scene, radius = 200) vis.addPointcloud(scene) vis.show() return [m_valid_T, m_valid_icp_ptplane, m_valid_icp_ptpoint]
def choose_model(self, tag): self.model = self.store.recognize(tag) if not (self.model is None): self.visual = visualizer(self.model, (self.leng, self.leng), self.samples.rang(), self.samples.rang()) self.tab_parent.tab(1, state="normal") self.tab_parent.tab(2, state="disabled") self.tab_parent.tab(3, state="disabled") self.tab_parent.select(1) self.stop_process()
def visualizeCloudCenter(self): """ Visualize the input point cloud with its center """ # Initialize visualizer vis = visualizer() vis.addPointcloud(self.cloud, CLOUD_COLOR) vis.addSphere(self.c, CENTER_COLOR, CENTER_RADIUS) # Show results vis.show()
def html(amr_table, filename, output_path, curt=False): output = open(output_path + '%s.html' % filename, 'w') import visualizer graph_path = output_path + 'graphs/' try: os.mkdir(graph_path) except OSError: pass # head = '<meta charset=\'utf-8\'>\n' head = os.path.dirname(os.path.abspath(__file__)) + '/html_head' output.write(open(head, 'r').read()) for docid in sorted(amr_table): for senid in sorted(amr_table[docid]): sen = amr_table[docid][senid] if curt: visualizer.visualizer_curt(sen, graph_path) else: visualizer.visualizer(sen, graph_path) get_sentence(sen, output)
def visualizeSeedsRotationFrames(object, seeds, R_seeds): vis = visualizer() vis.addPointcloud(seeds) vis.addFrame(center=[0, 0, 0], size=10) vis.addSphere(center=object.get_center(), radius=2) seed_points = np.asarray(seeds.points) for i in range(len(R_seeds)): vis.addFrame(center=seed_points[i], size=9, R=R_seeds[i]) vis.show()
def visualizePrediction(self, seeds, scene, scene_indices, predicted_categories, num_of_segments=10): """ Visualize the predicted categories for different points. Parameters ---------- seeds: scene: scene_indices: Indices of the points from the original scene point cloud which were used to generate each segment when splitting the scene. predicted_categories: num_of_segments: """ # Visualize the predicted results vis = visualizer() for s in np.asarray(seeds.points): vis.addSphere(s, color=[0, 0, 0], radius=2) # Add point clouds to the visualization vis.addPointcloud(cloud=seeds) vis.addPointcloud(cloud=scene) # Get the points of both point clouds as numpy array seeds_points = np.asarray(seeds.points) scene_points = np.asarray(scene.points) # Add lines to visualize the correspondences for i in np.random.uniform(low=0, high=(len(scene_indices) - 1), size=num_of_segments): p1 = scene_points[scene_indices[int(i)]] c = predicted_categories[int(i)] p2 = seeds_points[c] if c is not -1: color = [0, 0, 1] else: color = [1, 0, 0] vis.addSphere(center=p1, color=color, radius=2) vis.addSphere(center=p2, color=color, radius=2) vis.addLine(p1, p2, color=color) vis.show()
def __init__(self, logger=None): super().__init__() if conf()['compile_pyx_on_startup']: os.system("python setup.py build_ext --inplace") self.frame = 0 self.logger = logger # Initialize all needed modules shapedetector() shapetracker() touchedshapetracker() handdetector() handtracker() visualizer() ui() shapepicker() shaperegionpicker() # Put the wires together handtracker().subscribe('hand_exit', shapetracker().clear_lost_shapes) handtracker().subscribe('finger_up', touchedshapetracker().on_finger_up) handtracker().subscribe('finger_pressing', ui().on_finger_pressing) handtracker().subscribe('finger_up', ui().on_finger_up) handtracker().subscribe('finger_down', ui().on_finger_down) handtracker().subscribe('finger_pressing', shapepicker().on_finger_pressing) handtracker().subscribe('finger_up', shapepicker().on_finger_up) handtracker().subscribe('hand_exit', handdetector().on_hand_exit) handtracker().subscribe('finger_pressing', shaperegionpicker().on_finger_pressing) handtracker().subscribe('finger_up', shaperegionpicker().on_finger_up) handtracker().subscribe('hand_exit', shaperegionpicker().on_hand_exit) handtracker().subscribe('hand_exit', shapepositionpicker().on_hand_exit)
def next_frame(self): self.frame += 1 self.publish('frame_begins', {'frame': self.frame}) if not realsensecam().acquire_frames(): return None handdetector().determine_hand_cnt() if handtracker().update() and not ui().menu_active: detected_shapes = shapedetector().detect_shapes() shapetracker().process_detected_shapes(detected_shapes) touchedshapetracker().update() if self.logger is not None: self.logger.logAll() return visualizer().visualize()
def visualizeSceneAndSeeds(self, seeds): """ Visualize the scene pointcloud with the generated seeds. Parameters ---------- seeds: o3d.geometry.PointCloud Pointcloud containing the seeds. """ vis = visualizer() vis.addPointcloud(self.scene) # Add a sphere in order to visualize each seed for s in np.asarray(seeds.points): vis.addSphere(center=s, color=SEED_COLOR, radius=SEED_RADIUS) vis.show()
def visualizeMatches(self, seeds, scene, segments_categories, scene_indices, num_of_points): vis = visualizer() vis.addPointcloud(scene) for p in np.asarray(seeds.points): vis.addSphere(center=p, color=[0, 0, 0], radius=2) idx = np.random.uniform(low=0, high=(len(scene_indices) - 1), size=num_of_points) for i in idx: s = np.asarray(scene.points)[scene_indices[int(i)]] o = np.asarray(seeds.points)[segments_categories[int(i)]] vis.addSphere(center=s, color=[0, 0, 1], radius=2) vis.addSphere(center=o, color=[0, 1, 0], radius=3) vis.addLine(o, s) vis.show()
def visualizeVotes(self, votes): """ Visualize the input point cloud with the generated votes """ # Initialize visualizer vis = visualizer() vis.addPointcloud(self.cloud, color=CLOUD_COLOR) # Get the number of votes [_, tesallation_level, _] = votes.shape number_of_votes = tesallation_level * self.num_of_points # Reshape the votes container votes_r = np.reshape(votes, (number_of_votes, 3)) # Convert the votes into a point cloud votes_cloud = fromNumpyArray(votes_r) vis.addPointcloud(votes_cloud, color=VOTE_COLOR) # Show results vis.show()
def computeDiagonal(self, object, vis=False): points = np.asarray(object.points) c = (object.get_center()) p1 = getFurthestPoint(object, c) p2 = getFurthestPoint(object, p1) diagonal = getEuclidianDistance(p1, p2) if vis is True: vis = visualizer() vis.addPointcloud(object) vis.addSphere(center=p1, color=[0,1,0], radius=2) vis.addSphere(center=p2, color=[0,0,1], radius=2) vis.addLine(p1,p2) vis.show() return diagonal
def visualizeDensity(self, votes_r, density, t_candidates, R_candidates, model): """ Visualize the vote density Parameters ---------- votes R density model:o3d.geometry.PointCloud num_of_candidates: int Number of candidates to be shown. """ # Initialize visualizer vis = visualizer() vis.addPointcloud(self.cloud, CLOUD_COLOR) # Convert the votes into a point cloud votes_cloud = fromNumpyArray(votes_r) # Scale the density values to be within [0,1] color_code, _, _ = getScaledArray(density, high=1, low=0) # Color Coding the votes: First, Paint the cloud uniformly in order for # the points to have a color attribute votes_cloud.paint_uniform_color([1, 1, 1]) # Color Coding the votes: Second, Assign a color to each point # depending on its density value votes_color_coded = np.array([[c, 0, 0] for c in color_code]) votes_cloud.colors = o3d.utility.Vector3dVector(votes_color_coded) vis.addPointcloud(votes_cloud) # Run until the number of candidates is satisfied for i in range(len(t_candidates)): t_c = t_candidates[i] R_c = R_candidates[i] # Sphere to visualize the candidate vis.addSphere(t_c, CANDIDATE_COLOR, CANDIDATE_RADIUS) vis.addFrame(t_c, FRAME_SIZE, R=R_c) # Candidate object point cloud vis.addPointcloud(copy.deepcopy(model), t=t_c, R=R_c) # Show results vis.show()
def visualizeSegments(self, seeds, segments, seeds_indices): # Generate a color code in order to have a different color for each # seed seeds = np.asarray(seeds.points) [num_of_seeds, _] = seeds.shape np.random.seed(10) color_code = np.random.rand(num_of_seeds, 3) # Initialize visualizer vis = visualizer() # Add a sphere in order to visualize each seed for s in seeds: vis.addSphere(center=s, color=SEED_COLOR, radius=SEED_RADIUS) # Loop through all the segments, add a point cloud for each one and # color it depending on the category. [num_of_segments, _, _] = segments.shape for i in range(1): #range(num_of_segments): segment_color = color_code[int(seeds_indices[i]), :] vis.addPointcloud(fromNumpyArray(segments[i]), color=segment_color) vis.show()
def visualizeBestCandidates(self, points): """ Visualization for the selected candidates. Parameters ---------- points: N x num_of_points x num_of_dimensions array Point data for the candidates. """ # Create visualizer object. vis = visualizer() # Loop through all the candidates for c in points: # Add cloud with the candidate points candidate = fromNumpyArray(c) vis.addPointcloud(candidate, color=CANDIDATE_COLOR) # Add sphere to visualize the cloud center vis.addSphere(candidate.get_center(), CENTER_COLOR, CENTER_RADIUS) vis.show()
def __init__(self, num_class = 14, limit = None): self.num_class = num_class self.iteration = 0 # data self.data = loadData.loadData(limit = limit).getDataArray() print "number of training data:", len(self.data) # model parameters # for each pixel in each class, there are: # 1. pi representing probability of the class # 2. alpha representing probability of being foreground # 3. mu and sigma representing gaussian of observation vs fg/bg data self.param_pi = np.array([1.0/self.num_class] * self.num_class) self.param_alpha = np.zeros((self.num_class, len(self.data[0]))) + 0.5 self.param_mu = np.random.random((self.num_class, len(self.data[0]))) self.param_sigma = np.ones((self.num_class, len(self.data[0]))) * 10 # visualizer self.visualizer = visualizer.visualizer()
def visualizeData(self, data_points, num_of_samples: int): """ Visualization for the PointNet data. Visualize an specified number of samples. Parameters ---------- data_points: N x num_of_points x num_of_dimensions array Point data for the set. num_of_samples: int Number of samples to be visualized. """ # Create visualizer object. vis = visualizer() for d in range(num_of_samples): offset = d * 2 sample = data_points[d, :, 0:num_of_dimensions] / 100 sample[:, 0] = sample[:, 0] + offset vis.addPointcloud(fromNumpyArray(sample)) vis.show()
def visualizeBestCandidates(self, scene, object, t_candidates, R_candidates): vis = visualizer() vis.addPointcloud(scene) for i in range(len(t_candidates)): vis.addPointcloud(copy.deepcopy(object), t=t_candidates[i], R=R_candidates[i]) vis.show()
def __init__(self, game): self.vision = vision() self.visualizer = visualizer() self.current_tile = (0, 0) self.game = game
def getMatches(self, object:o3d.geometry.PointCloud, scene:o3d.geometry.PointCloud, distance_threshold:float, radial_vector_length, scalar_projection): visualize = False # Container to save the sample data sample_data = np.array([]) # Construct kd-tree in order to search through the object points object_tree = o3d.geometry.KDTreeFlann(object) # Compute normals of the scene point cloud scene = computeNormals(cloud=scene, orient_normals=True) scene_points = np.asarray(scene.points) scene_normals = np.asarray(scene.normals) [number_of_points_scene,_]=scene_points.shape scene_points_indices = np.array([], dtype=int) # Loop through all the points in the scene point cloud for i in range(number_of_points_scene): # Find the closest point of the object to the scene point [k, idx, _] = object_tree.search_knn_vector_3d(scene_points[i], 1) object_point = np.asarray(object.points)[idx] # Compute the euclidian distance between the object and scene point dist = getEuclidianDistance(scene_points[i],object_point) # If the points are close enough, save the data if dist < distance_threshold: scene_points_indices = np.append(scene_points_indices, i) # Storing the sample data: # [scene_point(x,y,z), # radial_vector_length, # scalar_projection, # normal] point_data = np.hstack([scene_points[i], radial_vector_length[idx], scalar_projection[idx], scene_normals[i]]) if sample_data.size == 0: sample_data = point_data else: sample_data = np.row_stack([sample_data, point_data]) if visualize is True: vis = visualizer() scene.paint_uniform_color([0,1,0]) np.asarray(scene.colors)[scene_points_indices[1:], :] = [0,0,1] vis.addPointcloud(scene) vis.show() scene_tree = o3d.geometry.KDTreeFlann(scene) indices = np.random.uniform(low=0, high=(sample_data.__len__()-1), size=50) for it in indices: it = int(it) seed = sample_data[it, 0:3] [k, idx, _] = scene_tree.search_radius_vector_3d(seed, v.SEGMENT_RADIUS) if visualize is True: vis = visualizer() scene.paint_uniform_color([0,1,0]) np.asarray(scene.colors)[idx[1:], :] = [0,0,1] vis.addPointcloud(scene) vis.addSphere(center=seed, color=[1,0,0], radius=2) vis.show() idx = np.asarray(idx) np.random.shuffle(idx) idx = idx[0:v.NUM_OF_POINTS] points = copy.deepcopy(np.asarray(scene.points)[idx]) points = np.asarray([[p - seed for p in points]]) normals = [copy.deepcopy(np.asarray(scene.normals)[idx])] if visualize is True: vis = visualizer() scene.paint_uniform_color([0,1,0]) np.asarray(scene.colors)[idx[1:], :] = [0,0,1] vis.addPointcloud(scene) vis.addSphere(center=seed, color=[1,0,0], radius=2) vis.show() [_, m, _] = points.shape if m == v.NUM_OF_POINTS: gf_vector = self.getGlobalFeatureVectors([points]) else: return None if self.dataset.size == 0: self.dataset = np.asarray([sample_data[it, :]]) self.dataset_out = np.asarray(gf_vector) self.dataset_cloud = np.asarray(points) self.dataset_normals = np.asarray(normals) else: self.dataset = np.row_stack([self.dataset, [sample_data[it, :]]]) self.dataset_out = np.row_stack([self.dataset_out, gf_vector]) self.dataset_cloud = np.row_stack([self.dataset_cloud, points]) self.dataset_normals = np.row_stack([self.dataset_normals, normals]) return sample_data
from config import gen_args from data import KnittedVestDataset from utils import to_np, set_seed, get_lr from models import CNNCali args = gen_args() print(args) use_gpu = torch.cuda.is_available() set_seed(42) ''' visualizer ''' if args.knit_name in ['kuka_calibration']: vis_glove = visualizer('glove', 'right') vis_kuka = visualizer('kuka') ''' model ''' model_glove = CNNCali(args, vis_glove.mask, scale_factor=1.0, position_bias=True) model_kuka = CNNCali(args, vis_kuka.mask) # load pretrained glove network model_name = 'net_glove_pretrained.pth' model_path = os.path.join(args.ckp_path, model_name) print("Loading pretrained glove network from %s" % model_path) model_glove.load_state_dict(torch.load(model_path))
from utils import to_np, set_seed, get_lr from models import CNNCali args = gen_args() print(args) use_gpu = torch.cuda.is_available() set_seed(42) ''' visualizer ''' side = 'left' vis = visualizer('sock', side) ''' model ''' model = CNNCali(args, vis.mask) if args.eval == 0: if args.resume == 1: model_name = 'net_epoch_%d_iter_%d.pth' % (args.epoch, args.iter) model_path = os.path.join(args.ckp_path, model_name) print("Loading network from %s" % model_path) model.load_state_dict(torch.load(model_path)) else:
from utils import to_np, set_seed, get_lr from models import CNNCali args = gen_args() print(args) use_gpu = torch.cuda.is_available() set_seed(42) ''' visualizer ''' if args.knit_name in ['glove_calibration']: vis = visualizer(sensor_type='glove', side='right') ''' model ''' model = CNNCali(args, vis.mask) if args.eval == 0: if args.resume == 1: model_name = 'net_epoch_%d_iter_%d.pth' % (args.epoch, args.iter) model_path = os.path.join(args.ckp_path, model_name) print("Loading network from %s" % model_path) model.load_state_dict(torch.load(model_path)) else: print("Randomly initialize the network")
# -*- coding: utf-8 -*- """ Visualisazion of the shot prediction """ ############################ VISUALISATION OF PREDICTION ##################### from visualizer import visualizer video = 'test_data/final.mp4' csv = 'test_data/final.csv' """ Instructions: k: stop or resume panel video n: next frame q: quit video """ #compare prediction from the Conv3D model and cineast comp = visualizer(10, video, csv) comp.compare_prediction('test_data/predict.csv', 'test_data/cineast.csv') #prediction from model # conv = visualizer(10,video, 'test_data/predict.csv') # conv.eval_csv() # #prediction from cineast # cin = visualizer(10,video, 'test_data/cineast.csv') # cin.eval_csv() # #true cuts as reference # ref = visualizer(10,video, csv) # ref.eval_csv()
# Center the cloud in the origin scene = downsample(scene, leaf_size) scene.translate([100, 100, 100]) scene.paint_uniform_color([0, 1, 0]) o3d.visualization.draw_geometries([scene]) # Split the scene cloud in segments with the correct size for the pointnet # module. We use all the scene points as seed since we want a segment per point cs = cloud_splitter(scene, oc.INPUT_SHAPE) segments_data = cs.getSegments(scene, oc.SEGMENT_RADIUS) # If no segments are found, stopt the execution of the script. if segments_data is None: sys.exit() # Unpack the segments data [X_test, X_test_u, X_normals, X_indices, _] = segments_data # Visualize the segments vis = visualizer() num_of_segments = 3 for i in np.random.uniform(low=0, high=(len(X_test_u) - 1), size=num_of_segments): c = np.random.uniform(low=0, high=1, size=(3, )) vis.addPointcloud(cloud=fromNumpyArray(X_test_u[int(i)]), color=c) vis.show() # Declare the PointNet model object_class = object_classifier(oc.INPUT_SHAPE, oc.NUM_OF_CATEGORIES) # Load the pretrained model object_class.loadModel(f.OBJ_CLASS_POINTNET_LOAD) # Run the pointnet in order to classify the segments into the different parts # of the object scores = object_class.predict(X_test) predicted_categories = object_class.getPredictedCategory(scores,