def estimateAverageTransform(self): targets = glob.glob(self.file_path + "*left.ply") sources = glob.glob(self.file_path + "*right.ply") assert len(sources) == len(targets) transform_list = [] for i in range(len(sources)): tran = (self.estimateTransform(sources[i], targets[i])) transform_list.append(tran) if np.linalg.norm(self.base_transform - tran) < 0.1: self.base_transform = tran # estimate good average transform # avg_transformation = self.base_transform avg_transformation = np.mean(transform_list, axis=0) print(avg_transformation) # print(transform_list) # display final result for i in range(len(transform_list) - 1): source = od.read_point_cloud(sources[i]) target = od.read_point_cloud(targets[i]) self.draw_registration_result_original_color( source, target, avg_transformation) np.save(self.file_path + "transform", avg_transformation) print(avg_transformation)
def estimateTransform(self, source, target): source = od.read_point_cloud(source) target = od.read_point_cloud(target) current_transformation = self.base_transform for scale in range(len(self.voxel_radius)): iterations = self.max_iter[scale] radius = self.voxel_radius[scale] source_down = od.voxel_down_sample(source, radius) target_down = od.voxel_down_sample(target, radius) od.estimate_normals( source_down, od.KDTreeSearchParamHybrid(radius=2 * radius, max_nn=self.max_nn)) od.estimate_normals( target_down, od.KDTreeSearchParamHybrid(radius=2 * radius, max_nn=self.max_nn)) result_icp = od.registration_colored_icp( source_down, target_down, radius, current_transformation, od.ICPConvergenceCriteria( relative_fitness=self.relative_fitness, relative_rmse=self.relative_rmse, max_iteration=iterations)) current_transformation = result_icp.transformation # self.draw_registration_result_original_color( # source_down, target_down, current_transformation) return current_transformation
def NonFirstCloud(self, cloud_index): self.cloud1 = o3d.read_point_cloud( r"C:\Users\newsmart\Desktop\NSTAlgo\3D\PCL\stitch\2\2-{}_Extract.ply".format(cloud_index - 1)) self.cloud2 = o3d.read_point_cloud( r"C:\Users\newsmart\Desktop\NSTAlgo\3D\PCL\stitch\2\2-{}_Extract.ply".format(cloud_index)) # get local transformation between two lastest clouds self.posLocalTrans = self.registerLocalCloud(self.cloud1, self.cloud2) # if result is not good, drop it if self.goodResultFlag: # test for loop detection info self.detectTransLoop = np.dot(self.posLocalTrans, self.detectTransLoop) # print ("==== loop detect trans ====") # print(self.detectTransLoop) # print ("==== ==== ==== ==== ==== ====") self.posWorldTrans = np.dot(self.posWorldTrans, self.posLocalTrans) # update latest cloud self.cloud1 = copy.deepcopy(self.cloud2) self.cloud2.transform(self.posWorldTrans) o3d.write_point_cloud(r"C:\Users\newsmart\Desktop\NSTAlgo\3D\PCL\stitch\2\test.ply", self.cloud2, write_ascii=False) self.cloud_base = self.cloud_base + self.cloud2 # Down Sampling self.cloud_base = o3d.voxel_down_sample(self.cloud_base, 0.001) self.registrationCount += 1 # save PCD file to local o3d.write_point_cloud(r"C:\Users\newsmart\Desktop\NSTAlgo\3D\PCL\stitch\2\registerResult.ply", self.cloud_base, write_ascii=False)
def main(): argvs = sys.argv model_num = str(argvs[1]) scene_num = str(argvs[2]) cloud_dir = "/mnt/container-data/remove_plane/" model_path = cloud_dir + model_num + ".ply" model_cloud = o3.read_point_cloud(model_path) scene_path = cloud_dir + scene_num + ".ply" scene_cloud = o3.read_point_cloud(scene_path) rot_in = read_rotation(model_num) model_cloud.transform(rot_in) model_cloud = o3.voxel_down_sample(model_cloud, voxel_size=0.020) scene_cloud = o3.voxel_down_sample(scene_cloud, voxel_size=0.020) # 基準とするpointcloud, 回転させたいpointcloud の順番 cbs = [callbacks.Open3dVisualizerCallback(model_cloud, scene_cloud)] objective_type = 'pt2pt' # 基準とするpointcloud, 回転させたいpointcloud の順番 tf_param, _, _ = filterreg.registration_filterreg( model_cloud, scene_cloud, scene_cloud.normals, objective_type=objective_type, sigma2=sig, callbacks=cbs, maxiter=ter, tol=ol) write_rotation(tf_param, scene_num)
def rabbit_dataset(): A1 = o3d.read_point_cloud("./bunny/data/bun000.ply") A2 = o3d.read_point_cloud("./bunny/data/bun045.ply") A3 = o3d.read_point_cloud("./bunny/data/bun090.ply") A4 = o3d.read_point_cloud("./bunny/data/bun180.ply") A5 = o3d.read_point_cloud("./bunny/data/bun270.ply") A6 = o3d.read_point_cloud("./bunny/data/bun315.ply") A7 = o3d.read_point_cloud("./bunny/data/chin.ply") A8 = o3d.read_point_cloud("./bunny/data/ear_back.ply") A9 = o3d.read_point_cloud("./bunny/data/top2.ply") A10 = o3d.read_point_cloud("./bunny/data/top3.ply") return [A1, A2, A3, A4, A5, A6, A7, A8, A9]
def point_cloud_txt_to_pcd(raw_dir, file_prefix): # File names txt_file = os.path.join(raw_dir, file_prefix + ".txt") pts_file = os.path.join(raw_dir, file_prefix + ".pts") pcd_file = os.path.join(raw_dir, file_prefix + ".pcd") # Skip if already done if os.path.isfile(pcd_file): print("pcd {} exists, skipped".format(pcd_file)) return # .txt to .pts # We could just prepend the line count, however, there are some intensity value # which are non-integers. print("[txt->pts]") print("txt: {}".format(txt_file)) print("pts: {}".format(pts_file)) with open(txt_file, "r") as txt_f, open(pts_file, "w") as pts_f: for line in txt_f: # x, y, z, i, r, g, b tokens = line.split() tokens[3] = str(int(float(tokens[3]))) line = " ".join(tokens) pts_f.write(line + "\n") prepend_line(pts_file, str(wc(txt_file))) # .pts -> .pcd print("[pts->pcd]") print("pts: {}".format(pts_file)) print("pcd: {}".format(pcd_file)) point_cloud = open3d.read_point_cloud(pts_file) open3d.write_point_cloud(pcd_file, point_cloud)
def _calculate_num_points_in_gt(data_path, infos, remove_outside=True, num_features=4): for info in infos: pc_info = info["point_cloud"] v_path = pc_info["velodyne_path"] if True: pcd = open3d.read_point_cloud(v_path) points_v = np.asarray(pcd.points).astype(np.float32) #points_v = np.fromfile( # v_path, dtype=np.float32, count=-1).reshape([-1, num_features]) # points_v = points_v[points_v[:, 0] > 0] annos = info['annos'] num_obj = len( annos['name']) #len([n for n in annos['name'] if n != 'DontCare']) # annos = kitti.filter_kitti_anno(annos, ['DontCare']) gt_boxes = np.array(annos['boxes'], dtype=np.float32) #gt_boxes_camera = np.concatenate([loc, dims, rots[..., np.newaxis]], # axis=1) #gt_boxes_lidar = box_np_ops.box_camera_to_lidar( # gt_boxes_camera, rect, Trv2c) indices = box_np_ops.points_in_rbbox(points_v, gt_boxes) num_points_in_gt = indices.sum(0) #num_ignored = len(annos['dimensions']) - num_obj #num_points_in_gt = np.concatenate( # [num_points_in_gt, -np.ones([num_ignored])]) annos["num_points_in_gt"] = num_points_in_gt.astype(np.int32) pass
def run_static_pointcloud_visualization(): import open3d, os vis_path = os.path.dirname(__file__) cloud_path = os.path.join(vis_path, 'data/bunny.pcd') pcd = open3d.read_point_cloud(cloud_path) pcd_np = np.asarray(pcd.points) MeshCatVisualizer.draw_pointcloud(pcd_np)
def down_sample(dense_pcd_path, dense_label_path, sparse_pcd_path, sparse_label_path, voxel_size): # Skip if done if os.path.isfile(sparse_pcd_path) and ( not os.path.isfile(dense_label_path) or os.path.isfile(sparse_label_path)): print("Skipped:", file_prefix) return else: print("Processing:", file_prefix) # Inputs dense_pcd = open3d.read_point_cloud(dense_pcd_path) try: dense_labels = load_labels(dense_label_path) except: dense_labels = None # Skip label 0, we use explicit frees to reduce memory usage print("Num points:", np.asarray(dense_pcd.points).shape[0]) if dense_labels is not None: non_zero_indexes = dense_labels != 0 dense_points = np.asarray(dense_pcd.points)[non_zero_indexes] dense_pcd.points = open3d.Vector3dVector() dense_pcd.points = open3d.Vector3dVector(dense_points) del dense_points dense_colors = np.asarray(dense_pcd.colors)[non_zero_indexes] dense_pcd.colors = open3d.Vector3dVector() dense_pcd.colors = open3d.Vector3dVector(dense_colors) del dense_colors dense_labels = dense_labels[non_zero_indexes] print("Num points after 0-skip:", np.asarray(dense_pcd.points).shape[0]) # Downsample points min_bound = dense_pcd.get_min_bound() - voxel_size * 0.5 max_bound = dense_pcd.get_max_bound() + voxel_size * 0.5 sparse_pcd, cubics_ids = open3d.voxel_down_sample_and_trace( dense_pcd, voxel_size, min_bound, max_bound, False) print("Num points after down sampling:", np.asarray(sparse_pcd.points).shape[0]) open3d.write_point_cloud(sparse_pcd_path, sparse_pcd) print("Point cloud written to:", sparse_pcd_path) # Downsample labels if dense_labels is not None: sparse_labels = [] for cubic_ids in cubics_ids: cubic_ids = cubic_ids[cubic_ids != -1] cubic_labels = dense_labels[cubic_ids] sparse_labels.append(np.bincount(cubic_labels).argmax()) sparse_labels = np.array(sparse_labels) write_labels(sparse_label_path, sparse_labels) print("Labels written to:", sparse_label_path)
def load_ply(self, data_dir, ind, downsample, aligned=True): pcd = open3d.read_point_cloud(join(data_dir, f'{ind}.ply')) pcd = open3d.voxel_down_sample(pcd, voxel_size=downsample) if aligned is True: matrix = np.load(join(data_dir, f'{ind}.pose.npy')) pcd.transform(matrix) return pcd
def read_point_cloud(): """ Read Open3d point clouds and covnert to Houdini geometry Based on http://www.open3d.org/docs/tutorial/Basic/working_with_numpy.html """ node = hou.pwd() node_geo = node.geometry() path = node.parm("path").eval() pcd_load = open3d.read_point_cloud(path) if not pcd_load.has_points(): raise hou.NodeWarning("Geometry does not contain any points.") # create numpy arrays np_pos = np.asarray(pcd_load.points) np_n = np.asarray(pcd_load.normals) np_cd = np.asarray(pcd_load.colors) # position node_geo.createPoints(np_pos) # normals if pcd_load.has_normals(): node_geo.addAttrib(hou.attribType.Point, "N", default_value=(0.0, 0.0, 0.0), transform_as_normal=True, create_local_variable=False) node_geo.setPointFloatAttribValuesFromString("N", np_n, float_type=hou.numericData.Float64) # colors if pcd_load.has_colors(): node_geo.addAttrib(hou.attribType.Point, "Cd", default_value=(0.0, 0.0, 0.0), transform_as_normal=False, create_local_variable=False) node_geo.setPointFloatAttribValuesFromString("Cd", np_cd, float_type=hou.numericData.Float64)
def __init__(self, root, intance_num, trans_by_pose=None): # trans_by_pose: <Bx3> pose self.root = os.path.expanduser(root) self._trans_by_pose = trans_by_pose file_list = glob.glob(os.path.join(self.root, '*pcd')) self.file_list = sorted(file_list) #[:intance_num] self.pcds = [] # a list of open3d pcd objects point_clouds = [] #a list of tensor <Lx2> for file in self.file_list: pcd = read_point_cloud(file) self.pcds.append(pcd) current_point_cloud = np.asarray(pcd.points, dtype=np.float32)[:, 0:2] point_clouds.append(current_point_cloud) point_clouds = np.asarray(point_clouds) self.point_clouds = torch.from_numpy(point_clouds) # <NxLx2> self.valid_points = find_valid_points(self.point_clouds) # <NxL> # number of points in each point cloud self.n_obs = 256 self.indeces = range(256)
def create_object_masks(self, object_name, session_name, dilate_size=15, show=False): logger = logging.getLogger(__name__) # DEPRECATED: use generate_object_masks.py instead # TODO: Bug: no mask for excluded views, because their segmented object # is not saved base_dir = osp.join(self.data_dir, session_name, object_name) pc_dir = osp.join(base_dir, 'pointclouds') # thermal camera info thermal_dir = osp.join(base_dir, 'thermal_images') thermal_im_size, thermal_K = self._load_thermal_cinfo(thermal_dir) _, _, pc_filenames = os.walk(pc_dir).next() done = True for pc_filename in pc_filenames: if 'segmented_object' not in pc_filename: continue view_id = pc_filename.split('_')[0] pc_filename = osp.join(pc_dir, pc_filename) xyz_kinect = open3d.read_point_cloud(pc_filename) xyz_kinect = np.asarray(xyz_kinect.points).T xyz_thermal = np.dot( np.linalg.inv(self.T_rgb_t), np.vstack((xyz_kinect, np.ones(xyz_kinect.shape[1])))) uv_thermal = np.dot(thermal_K, xyz_thermal[:3]) uv_thermal = uv_thermal[:2] / uv_thermal[2] uv_thermal = np.round(uv_thermal).astype(np.int) idx = np.logical_and( uv_thermal >= 0, uv_thermal < np.asarray( [thermal_im_size[0], thermal_im_size[1]])[:, np.newaxis]) idx = np.logical_and(*idx) uv_thermal = uv_thermal[:, idx] mask = np.zeros((thermal_im_size[1], thermal_im_size[0])) mask[uv_thermal[1], uv_thermal[0]] = 1 if show: plt.figure() plt.imshow(mask) plt.show() mask_filename = '{:s}_mask.png'.format(view_id) mask_filename = osp.join(thermal_dir, mask_filename) mask = (mask * 255).astype(np.uint8) kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (dilate_size, dilate_size)) mask = cv2.dilate(mask, kernel) done = done and cv2.imwrite(mask_filename, mask) if not done: logger.error( '### WARN: Could not write {:s}'.format(mask_filename)) return done
def __init__(self, file_path_without_ext, has_label, use_color, box_size_x, box_size_y): """ Loads file data """ self.file_path_without_ext = file_path_without_ext self.box_size_x = box_size_x self.box_size_y = box_size_y # Load points pcd = open3d.read_point_cloud(file_path_without_ext + ".pcd") self.points = np.asarray(pcd.points) # Load label. In pure test set, fill with zeros. if has_label: self.labels = load_labels(file_path_without_ext + ".labels") else: self.labels = np.zeros(len(self.points)).astype(bool) # Load colors. If not use_color, fill with zeros. if use_color: self.colors = np.asarray(pcd.colors) else: self.colors = np.zeros_like(self.points) # Sort according to x to speed up computation of boxes and z-boxes sort_idx = np.argsort(self.points[:, 0]) self.points = self.points[sort_idx] self.labels = self.labels[sort_idx] self.colors = self.colors[sort_idx]
def visualize_scene_keypoint(annotation_dict, keypoint_name_list: List[str]): # Get all the keypoint keypoint_3d_position: List[List[float]] = [] annotation_keypoints_dict = annotation_dict['keypoints'] for keypoint_name in keypoint_name_list: assert keypoint_name in annotation_keypoints_dict keypoint_pos = annotation_keypoints_dict[keypoint_name]['position'] keypoint_3d_position.append([ float(keypoint_pos[0]), float(keypoint_pos[1]), float(keypoint_pos[2]) ]) # Get the scene root and ply file assert 'scene_name' in annotation_dict scene_name: str = annotation_dict['scene_name'] scene_root_path = os.path.join(args.log_root_path, scene_name) scene_processed_path = os.path.join(scene_root_path, 'processed') fusion_mesh_path: str = os.path.join(scene_processed_path, 'fusion_mesh.ply') assert os.path.exists(fusion_mesh_path) # Get the open3d point cloud and draw it point_cloud = open3d.read_point_cloud(fusion_mesh_path) n_keypoint: int = len(keypoint_3d_position) if args.one_by_one: for i in range(n_keypoint): draw_single_keypoint(point_cloud, keypoint_3d_position[i]) else: keypoint_np = np.zeros(shape=[3, n_keypoint]) for i in range(n_keypoint): keypoint_np[0, i] = keypoint_3d_position[i][0] keypoint_np[1, i] = keypoint_3d_position[i][1] keypoint_np[2, i] = keypoint_3d_position[i][2] draw_all_keypoints(point_cloud, keypoint_np)
def cb_load(msg): global Model,tfReg #load point cloud for n,l in enumerate(Config["scenes"]): pcd=o3d.read_point_cloud(Config["path"]+"/"+l+".ply") Model[n]=np.reshape(np.asarray(pcd.points),(-1,3)) rospy.Timer(rospy.Duration(Config["tf_delay"]),cb_master,oneshot=True) tfReg=[] #load TF such as master/camera... for n,m in enumerate(Config["master_frame_id"]): path=Config["path"]+"/"+m.replace('/','_')+".yaml" try: f=open(path, "r+") except Exception: pub_msg.publish("searcher::file error "+path) else: yd=yaml.load(f) f.close() trf=tflib.dict2tf(yd) tf=TransformStamped() tf.header.stamp=rospy.Time.now() tf.header.frame_id="world" tf.child_frame_id=m tf.transform=trf print "world->",m print trf tfReg.append(tf) broadcaster.sendTransform(tfReg) Param.update(rospy.get_param("~param")) solver.learn(Model,Param) pub_msg.publish("searcher::model learning completed")
def load_full_scan(self, file_path, cfg): print('file_path', file_path) self.pc = open3d.read_point_cloud( os.path.join(file_path, "sampled_points.ply")) file_names = dict() file_names['output_tetrahedron_adj'] = (os.path.join( file_path, "output_tetrahedron_adj")) file_names['output_cell_vertex_idx'] = (os.path.join( file_path, "output_cell_vertex_idx.txt")) file_names['ref_label'] = (os.path.join(file_path, "ref_point_label.txt")) l = dict() l['ref_label'] = np.fromfile(file_names['ref_label'], dtype=np.int32, sep=' ').reshape(-1, 7) l['adj_mat'] = np.fromfile(file_names['output_tetrahedron_adj'], dtype=np.int32, sep=' ').reshape(-1, 4) l['cell_vertex_idx'] = np.fromfile( file_names['output_cell_vertex_idx'], dtype=np.int32, sep=' ').reshape(-1, 4) self.cell_vertex_idx = (l['cell_vertex_idx']) self.adj = l['adj_mat'] self.ref_label = l['ref_label'][:, 0:cfg["ref_num"]] print("loaded " + file_path.split('/')[-2])
def testing(): f = r'/home/clh/git/compile/Open3D/src/Test/TestData/fragment.ply' print("Load a ply point cloud, print it, and render it") pcd = open3d.read_point_cloud(f) print(pcd) print(np.asarray(pcd.colors).shape)
def main(): keypoint_path: str = args.keypoint_yaml_path keypoint_datamap = None with open(keypoint_path, 'r') as file: try: keypoint_datamap = yaml.load(file) except yaml.YAMLError as exc: print(exc) exit(-1) # Process the map assert keypoint_datamap is not None mesh_path: str = keypoint_datamap['mesh_path'] keypoint_index: List[int] = keypoint_datamap['keypoint_index'] keypoint_3d_position: List[ List[float]] = keypoint_datamap['keypoint_world_position'] pcd = open3d.read_point_cloud(mesh_path) # Depends on visualization type if args.one_by_one: for i in range(len(keypoint_index)): draw_single_keypoint(pcd, keypoint_3d_position[i]) else: n_keypoint = len(keypoint_3d_position) keypoint_np = np.zeros(shape=[3, n_keypoint]) for i in range(n_keypoint): keypoint_np[0, i] = keypoint_3d_position[i][0] keypoint_np[1, i] = keypoint_3d_position[i][1] keypoint_np[2, i] = keypoint_3d_position[i][2] draw_all_keypoints(pcd, keypoint_np)
def prepare_source_and_target_rigid_3d(source_filename, noise_amp=0.001, n_random=500, orientation=np.deg2rad([0.0, 0.0, 30.0]), normals=False): source = o3.read_point_cloud(source_filename) source = o3.voxel_down_sample(source, voxel_size=0.005) print(source) target = copy.deepcopy(source) tp = np.asarray(target.points) rg = 1.5 * (tp.max(axis=0) - tp.min(axis=0)) rands = (np.random.rand(n_random, 3) - 0.5) * rg + tp.mean(axis=0) target.points = o3.Vector3dVector( np.r_[tp + noise_amp * np.random.randn(*tp.shape), rands]) ans = trans.euler_matrix(*orientation) target.transform(ans) if normals: o3.estimate_normals(source, search_param=o3.geometry.KDTreeSearchParamHybrid( radius=0.1, max_nn=50)) o3.orient_normals_to_align_with_direction(source) o3.estimate_normals(target, search_param=o3.geometry.KDTreeSearchParamHybrid( radius=0.1, max_nn=50)) o3.orient_normals_to_align_with_direction(target) return source, target
def setUp(self): pcd = o3.read_point_cloud('data/horse.ply') pcd = o3.voxel_down_sample(pcd, voxel_size=0.01) self._source = np.asarray(pcd.points) rot = trans.euler_matrix(*np.random.uniform(0.0, np.pi / 4, 3)) self._tf = tf.RigidTransformation(rot[:3, :3], np.zeros(3)) self._target = self._tf.transform(self._source)
def ViewPLY(path): # 読み込み pointcloud = open3d.read_point_cloud(path) # ダウンサンプリング # 法線推定できなくなるので不採用 pointcloud = open3d.voxel_down_sample(pointcloud, 10) # 法線推定 open3d.estimate_normals(pointcloud, search_param=open3d.KDTreeSearchParamHybrid( radius=20, max_nn=30)) # 法線の方向を視点ベースでそろえる open3d.orient_normals_towards_camera_location(pointcloud, camera_location=np.array( [0., 10., 10.], dtype="float64")) # 可視化 open3d.draw_geometries([pointcloud]) # numpyに変換 points = np.asarray(pointcloud.points) normals = np.asarray(pointcloud.normals) print("points:{}".format(points.shape[0])) X, Y, Z = Disassemble(points) # OBB生成 _, _, length = buildOBB(points) print("OBB_length: {}".format(length)) return points, X, Y, Z, normals, length
def test_ball_query(): pc = torch.from_numpy( np.asarray(opend.read_point_cloud("test_pc.ply").points)).unsqueeze( 0).float().cuda() centroids = torch.from_numpy(np.load('centroids.npy')).cuda() new_xyz = index_points(pc, centroids) ball_query(0.1, 32, pc, new_xyz)
def load_cloud(cloud_loc: os.path): if os.path.isfile(cloud_loc): point_cloud = open3d.read_point_cloud(cloud_loc) points = np.asarray(point_cloud.points) points = np.reshape(points, (240, 320, 3)).astype(np.float32) return points else: return np.zeros((240, 320, 3), dtype=np.float32)
def compare_with_room(self): pc_room = o3.read_point_cloud('static_data/room_A.ply') pcd = self.get_pcd() P = np.loadtxt('static_data/T.csv', delimiter=',') pcd.transform(P) o3.draw_geometries([pc_room, pcd])
def cb_step1(ev): global sceneDat print "Step1/take a scene" sceneDat=solver.toNumpy(o3d.read_point_cloud(Args["scene"])) P=copy.deepcopy(sceneDat) pub_scene.publish(np2F(P)) pub_model.publish(np2F(P0())) rospy.Timer(rospy.Duration(5), cb_step2, oneshot=True)
def cb_load_ply(msg): global outPn pcd = o3d.read_point_cloud(Args["wd"] + "/sample.ply") outPn = np.reshape(np.asarray(pcd.points), (-1, 3)) pub.publish(np2F(outPn)) f = Bool() f.data = True pub_ld.publish(f)
def readFiles(args): pc = open3d.read_point_cloud(args.pcfile1) v1 = np.asarray(pc.points) pc = open3d.read_point_cloud(args.pcfile2) v2 = np.asarray(pc.points) vertices = [v1, v2] if args.labelfile1 != "" and args.labelfile2 != "": l1 = np.loadtxt(args.labelfile1, dtype=int) l2 = np.loadtxt(args.labelfile2, dtype=int) else: l1 = np.zeros(v1.shape[0]) l2 = np.zeros(v2.shape[0]) # shift labels: l1 -= l1.min() l2 -= l2.min() labels = [l1, l2] return vertices, labels
def load_ply_as_pc(file_path: Union[str, Path]) -> op3.PointCloud: """ Load a point cloud from a .ply file :param file_path: a string, path to the .ply file :return: a point cloud object of Open3D """ point_cloud = op3.read_point_cloud(filename=path2str(file_path)) return point_cloud
def parse_pcd_open3d(filename): """ Parses a pcd file using Open3D :param filename: the file to be parsed :return: an open3d PointCloud class """ pcd = open3d.read_point_cloud(filename) return pcd