def find_wall_ids_for_windows(windows, walls): #if DEBUG: # windows = windows[15:17,:] # Bbox3D.draw_points_bboxes(windows[:,0:3], walls, 'Z', False) win_in_walls = Bbox3D.points_in_bbox(windows[:, 0:3], walls) wall_nums_per_win = win_in_walls.sum(1) if wall_nums_per_win.max() > 1: #win_mw_ids, wall_ids_ = np.where(win_in_walls) win_mw_ids = np.where(wall_nums_per_win > 1)[0] windows_thickness_multi = windows[win_mw_ids, 4] windows_thickness_rate_multi = windows[win_mw_ids, 4] / windows[win_mw_ids, 3] thickness_small = windows_thickness_multi.max() < 0.25 thickness_rate_small = windows_thickness_rate_multi.max() < 0.25 if not (thickness_small or thickness_rate_small): show_high(windows, walls, win_mw_ids, []) print(f'windows_missed:\n{windows[win_mw_ids]}') print( "There is some windows, find multiple responding walls and thickness is not small." ) assert False import pdb pdb.set_trace() # XXX BREAKPOINT pass if wall_nums_per_win.min() == 0: # a window centroid is inside of no wall missed_win_ids = np.where(wall_nums_per_win == 0)[0] windows_thickness_missed = windows[missed_win_ids, 4] windows_thickness_rate_missed = windows[missed_win_ids, 4] / windows[missed_win_ids, 3] thickness_small = windows_thickness_missed.max() < 0.25 thickness_rate_small = windows_thickness_rate_missed.max() < 0.25 if not (thickness_small or thickness_rate_small): #show_high(windows, walls, missed_win_ids, []) print(f'windows_missed:\n{windows[missed_win_ids]}') print( "There is some windows, cannot find responding wall and thickness is not small." ) assert False import pdb pdb.set_trace() # XXX BREAKPOINT pass #cen_lines_wall = Bbox3D.bboxes_centroid_lines(walls, 'X', 'Z') #cen_lines_wall[:,:,2] = 0 #for i in missed_win_ids: # point_i = windows[i,0:3] # point_i[2] = 0 # dis_i = vertical_dis_1point_lines(point_i, cen_lines_wall) # #show_high(windows, walls, [i], []) # pass win_bad_ids0, wall_ids0 = np.where(win_in_walls) wall_yaws0 = walls[wall_ids0, -1] # when responding wall yaw is not vertical or horizonal, the window is bad yaw_bad0 = (np.abs(wall_yaws0) / (np.pi * 0.5)) % 1 > 0.01 win_bad_ids1 = np.where(yaw_bad0)[0] win_bad_ids = win_bad_ids0[win_bad_ids1] wall_ids_for_bad_win = wall_ids0[win_bad_ids1] if DEBUG and False: for i in range(win_bad_ids.shape[0]): print(f'bad window {i}/{win_bad_ids.shape[0]}') show_high(windows, walls, win_bad_ids[i], wall_ids_for_bad_win[i]) return win_bad_ids, wall_ids_for_bad_win
def preprocess_cfr(ceilings_org, walls_org, obj): ''' Z is up, Y is thickness A ceiling is good: (1) not contains multiple rooms: cover no other ceilings (2) >= 3 edge walls A edge wall of a ceiling: In three points of the wall cenline: two corners and centroid at least two are on an edge of ceiling ''' assert ceilings_org.ndim == walls_org.ndim == 2 dis_threshold = 0.07 if ceilings_org.shape[0] == 0: return ceilings_org if walls_org.shape[0] == 0: return np.zeros(shape=[0, 7], dtype=np.float32) #Bbox3D.draw_bboxes(walls_org, 'Z', False) #Bbox3D.draw_bboxes(ceilings_org, 'Z', False) ceilings = ceilings_org.copy() ceilings, keep_ids0 = clean_repeat(ceilings) walls = walls_org.copy() cn = ceilings.shape[0] ceilings[:, 2] = 0 walls[:, 2] = 0 walls[:, 5] = 0 ceil_corners0 = Bbox3D.bboxes_corners(ceilings, 'Z') ceil_corners = np.take(ceil_corners0, Bbox3D._zpos_vs, axis=1) ceil_corners[:, :, 2] = 0 ceiling_cens = ceilings[:, 0:3] wall_cenlines = Bbox3D.bboxes_centroid_lines(walls, 'X', 'Z') good_ceiling_ids0 = [] bad_small_ids = [] for c in range(cn): # (1) #print(f'c:{c}') ceil_c = ceilings[c:c + 1].copy() ceil_c[:, 3:6] += 0.2 mask_overlap = Bbox3D.points_in_bbox(ceil_corners.reshape([-1, 3]), ceil_c).reshape([cn, 4]) mask_overlap = mask_overlap.all(1) num_overlap = mask_overlap.sum() - 1 ol_ids = np.where(mask_overlap)[0] ol_ids = [i for i in ol_ids if i != c] #if any_overlap: # area_ol = np.product(tmp[ol_ids,3:5], axis=1).sum() # area_c = np.product(ceilings[c,3:5]) # area_ol_rate = area_ol / area_c # import pdb; pdb.set_trace() # XXX BREAKPOINT # pass if Debug and 0: print(f'ceiling, contain {num_overlap} other celings') box_show = np.concatenate([walls_org, ceilings_org[c:c + 1]], 0) Bbox3D.draw_bboxes_mesh(box_show, 'Z', False) if num_overlap > 1: continue #if num_overlap >0: # bad_small_ids += ol_ids # (2) edge_wall_num, winc_state = is_edge_wall_of_ceiling( wall_cenlines, ceilings[c], walls_org) if edge_wall_num >= 3 or (edge_wall_num == 2 and (winc_state == 3).all()): good_ceiling_ids0.append(c) #good_ceiling_ids1 = [i for i in good_ceiling_ids0 if i not in bad_small_ids] good_ceiling_ids1 = keep_ids0[good_ceiling_ids0] good_ceiling_ids1 = np.array(good_ceiling_ids1).astype(np.int) rm_num = cn - good_ceiling_ids1.shape[0] bad_ceiling_ids = np.array( [i for i in range(cn) if i not in good_ceiling_ids1]).astype(np.int32) new_ceilings = ceilings_org[good_ceiling_ids1] if Debug and rm_num > 0: print(f'{cn} -> {good_ceiling_ids1.shape[0]}') box_show = np.concatenate([walls_org, ceilings_org[good_ceiling_ids1]], 0) Bbox3D.draw_bboxes_mesh(box_show, 'Z', False) if rm_num > 0: box_show = np.concatenate( [walls_org, ceilings_org[bad_ceiling_ids]], 0) Bbox3D.draw_bboxes_mesh(box_show, 'Z', False) import pdb pdb.set_trace() # XXX BREAKPOINT #show_walls_1by1(new_ceilings) pass return new_ceilings
def split_bbox(bbox_fn, points_splited): ''' bbox in file bbox_fn: up_axis='Y' with always x_size > z_size transform with cam2world_box: up_axis == 'Z' always: x_size > y_size ''' obj = os.path.basename(bbox_fn).split('.')[0] min_point_num_per1sm = 10 # thickness_aug for cropping x thickness_aug = 0.3 assert IndoorData._block_size0[-1] == -1 # do not crop box along z bboxes = np.loadtxt(bbox_fn).reshape([-1,7]) #if DEBUG: # #show_walls_1by1(bboxes) # bboxes = bboxes[3:4] areas = bboxes[:,3] * bboxes[:,5] min_point_num = np.minimum( min_point_num_per1sm * areas, 200 ) bboxes_aug = bboxes.copy() #bboxes_aug[:,4] += thickness_aug bboxes_aug[:,3:6] = np.clip(bboxes_aug[:,3:6],a_min= thickness_aug, a_max=None ) bn = bboxes.shape[0] sn = len(points_splited) bboxes_splited = [] for i in range(0, sn): # Use to constrain size_x size_z point_masks_aug_i = Bbox3D.points_in_bbox(points_splited[i][:,0:3].copy(), bboxes_aug.copy()) # Use to constrain size_y (the thickness) bboxes_tc = IndoorData.adjust_box_for_thickness_crop(bboxes) point_masks_i = Bbox3D.points_in_bbox(points_splited[i][:,0:3].copy(), bboxes_tc) pn_in_box_aug_i = np.sum(point_masks_aug_i, 0) pn_in_box_i = np.sum(point_masks_i, 0) #print(f'no aug:{pn_in_box_i}\n auged:{pn_in_box_aug_i}') # (1) The bboxes with no points with thickness_aug will be removed firstly keep_box_aug_i = pn_in_box_aug_i > min_point_num bboxes_i = bboxes[keep_box_aug_i] if DEBUG and obj=='ceiling' and 0: rm_box_aug_i = pn_in_box_aug_i <= min_point_num print(rm_box_aug_i) bboxes_no_points_i = bboxes[rm_box_aug_i].copy() bboxes_no_points_i[:,0] += 30 bboxes_show = np.concatenate([bboxes_i, bboxes_no_points_i],0) Bbox3D.draw_points_bboxes(points_splited[i], bboxes_show, up_axis='Z', is_yx_zb=False) points_aug_i = [points_splited[i][point_masks_aug_i[:,j]] for j in range(bn)] points_aug_i = [points_aug_i[j] for j in range(bn) if keep_box_aug_i[j]] points_i = [points_splited[i][point_masks_i[:,j]] for j in range(bn)] points_i = [points_i[j] for j in range(bn) if keep_box_aug_i[j]] # (2) Crop all the boxes by points and intersec_corners seperately bn_i = bboxes_i.shape[0] croped_bboxes_i = [] keep_unseen_intersection = False if keep_unseen_intersection: intersec_corners_idx_i, intersec_corners_i = Bbox3D.detect_all_intersection_corners(bboxes_i, 'Z') else: intersec_corners_idx_i = [None]*bn_i invalid_bn = 0 for k in range(bn_i): croped_box_k = Bbox3D.crop_bbox_by_points( bboxes_i[k], points_i[k], points_aug_i[k], 'Z', intersec_corners_idx_i[k]) if croped_box_k is not None: croped_bboxes_i.append( croped_box_k ) else: invalid_bn += 1 #Bbox3D.draw_points_bboxes(points_splited[i], bboxes_i[k:k+1], up_axis='Z', is_yx_zb=False, points_keep_rate=1.0) pass if len(croped_bboxes_i) > 0: croped_bboxes_i = np.concatenate(croped_bboxes_i, 0) else: croped_bboxes_i = np.array([]).reshape([-1,7]) # (3) Refine x size of each bbox by thickness croped of intersected bbox #croped_size = bboxes_i[:,3:6] - croped_bboxes_i[:,3:6] refine_x_by_intersection = False # not correct yet if refine_x_by_intersection: for k in range(bn_i): itsc0, itsc1 = intersec_corners_idx_i[k] crop_value = [0,0] if itsc0 >= 0: crop_value[0] = Bbox3D.refine_intersection_x(croped_bboxes_i[k], 'neg', croped_bboxes_i[itsc0], 'Z') if itsc1 >= 0: crop_value[1] = Bbox3D.refine_intersection_x(croped_bboxes_i[k], 'pos', croped_bboxes_i[itsc1], 'Z') if itsc0 >= 0 or itsc1 > 0: croped_bboxes_i[k] = Bbox3D.crop_bbox_size(croped_bboxes_i[k], 'X', crop_value) #crop_ysize_neg = croped_size[itsc0,1] if itsc0 >= 0 else 0 #crop_ysize_pos = croped_size[itsc1,1] if itsc1 >= 0 else 0 #croped_bboxes_i[k] = Bbox3D.crop_bbox_size(croped_bboxes_i[k], 'X', [crop_ysize_neg, crop_ysize_pos]) # (4) remove too small wall min_wall_size_x = 0.2 sizex_mask = croped_bboxes_i[:,3] > min_wall_size_x croped_bboxes_i = croped_bboxes_i[sizex_mask] bboxes_splited.append(croped_bboxes_i) show = False if show and DEBUG and len(points_i) > 0 and obj=='ceiling': print(croped_bboxes_i[:,3]) points = np.concatenate(points_i,0) points = points_splited[i] points1 = points.copy() points1[:,0] += 30 points = np.concatenate([points, points1], 0) bboxes_i[:,0] += 30 bboxes_i = np.concatenate([bboxes_i, croped_bboxes_i], 0) #Bbox3D.draw_points_bboxes(points, bboxes_i, up_axis='Z', is_yx_zb=False) Bbox3D.draw_points_bboxes_mesh(points, bboxes_i, up_axis='Z', is_yx_zb=False) import pdb; pdb.set_trace() # XXX BREAKPOINT pass return bboxes_splited
def preprocess_doors(doors0, walls, door_thickness=0.18): ''' doors0:[d,7] walls:[w,7] ''' door_n = doors0.shape[0] if door_n == 0: return doors0 wall_n = walls.shape[0] walls_1 = walls.copy() # (1) Find the coresponding wall of each door # (1.1) Get the four top lines of each door door_corners = Bbox3D.bboxes_corners(doors0, 'Z')[:, 0:4, :] # [d,4,3] door_lines0 = np.take(door_corners, Bbox3D._lines_z0_vids, axis=1) # [d,4,2,3] door_lines1 = door_lines0.reshape(-1, 2, 3) # (1.2) Get the centroid lines of each wall wall_cen_lines = Bbox3D.bboxes_centroid_lines(walls_1, 'X', 'Z') # (1.3) Get the intersections_2d between lines and walls # A door matches a wall means: there are two top lines of the door, which are # intersected with the wall centroid line. dw_ints = lines_intersection_2d(door_lines1[:, :, 0:2], wall_cen_lines[:, :, 0:2], True, True) dw_ints = dw_ints.reshape(door_n, 4, wall_n, 2) # [d,4,w,2] tmp0 = (1 - np.isnan(dw_ints)).sum(3) # [d,4,w] door_mask0 = tmp0.sum(1) == 4 door_matched0 = door_mask0.sum(1).reshape(-1, 1) # (1.4) Sometimes on door can match two walls. Remove the confused one by: # The right wall should not contain any corners dc_in_wall_mask = Bbox3D.points_in_bbox(door_corners.reshape(-1, 3), walls).reshape(door_n, 4, wall_n) dc_in_wall_mask = np.any(dc_in_wall_mask, axis=1) bad_match = (door_matched0 > 1) * dc_in_wall_mask door_mask = door_mask0 * (1 - bad_match) door_ids, wall_ids = np.where(door_mask) success_num = door_ids.shape[0] # (2) Pick the failed door ids wall_num_each_door = door_mask.sum(1) fail_match_door_ids = np.where(wall_num_each_door != 1)[0] walls_good = walls[wall_ids] yaws = limit_period(walls_good[:, -1], 0, np.pi / 2) intersections_2d = [] for i in range(success_num): door_idx = door_ids[i] cids = np.where(tmp0[door_idx, :, wall_ids[i]])[0] ints_i = dw_ints[door_idx, cids, wall_ids[i]] intersections_2d.append(ints_i.reshape(1, 2, 2)) if len(intersections_2d) == 0: return np.empty([0, 7]) intersections_2d = np.concatenate(intersections_2d, 0) doors_centroids_2d = np.mean(intersections_2d, 1) doors_length = np.linalg.norm(intersections_2d[:, 0] - intersections_2d[:, 1], axis=1) doors_length -= door_thickness * np.sin(yaws * 2) doors_new = doors0[door_ids].copy() doors_new[:, 0:2] = doors_centroids_2d doors_new[:, 3] = doors_length doors_new[:, 4] = door_thickness doors_new[:, 6] = walls_good[:, -1] if DEBUG and fail_match_door_ids.shape[0] > 0: print(f"fail_match_door_ids:{fail_match_door_ids}") show_all([doors0[fail_match_door_ids], walls]) #for dids in fail_d_ids: # fail_w_ids = np.where(door_mask[dids])[0] # show_all([doors0[dids].reshape(-1,7), walls[fail_w_ids].reshape(-1,7)]) import pdb pdb.set_trace() # XXX BREAKPOINT pass if DEBUG: show_all([doors0, doors_new, walls]) return doors_new
def gen_pcl(house_fn): always_gen_pcl = False check_points_out_of_house = False parsed_dir = get_pcl_path(house_fn) pcl_fn = os.path.join(parsed_dir, 'pcl_camref.ply') pcl_intact = check_pcl_intact(parsed_dir) if pcl_intact and (not always_gen_pcl): print(f'{pcl_fn} intact') return True # read house scope, abandon images with points out of house scope images_intact = check_images_intact(parsed_dir) if not images_intact: print(f'images not intact, abort generating pcl') return house_fn = os.path.join(parsed_dir, 'object_bbox/house.txt') house_box = np.loadtxt(house_fn) base_dir = os.path.dirname(house_fn) cam_fn = os.path.join(base_dir, parsed_dir + '/cam') #if not os.path.exists(cam_fn): # print(f'{cam_fn} does not exist, abort gen_pcl') # return False cam_pos = read_cam_pos(cam_fn) depth_fns = glob.glob( os.path.join(base_dir, parsed_dir + '/images/*_depth.png')) #if cam_pos.shape[0] < MIN_CAM_NUM or len(depth_fns) != cam_pos.shape[0]: # print(f'{cam_pos.shape[0]} cams, but {len(depth_fns)} images') # return False depth_fns.sort() print(f'start gen pcl {pcl_fn}\n with {len(depth_fns)} images') gen_ply_each_image = False if gen_ply_each_image: pcl_path = parsed_dir + '/pcls' if not os.path.exists(pcl_path): os.makedirs(pcl_path) pcls_all = [] max_point_num = 2e7 cam_num = cam_pos.shape[0] * 1.0 pre_downsample_num = max(2e5, int(max_point_num / cam_num)) print(f'pre_downsample_num: {pre_downsample_num}') for i, depth_fn in enumerate(depth_fns): pcl_i = depth_2_pcl(depth_fn, cam_pos[i]) if check_points_out_of_house: # check if the points are out of house scope # do not know why this happens sometims, just use this ineligant way to # solve it temperally if pcl_i.shape[0] > 1000: ids = np.sort(np.random.choice(pcl_i.shape[0], 1000, False)) else: ids = np.arange(pcl_i.shape[0]) mask = Bbox3D.points_in_bbox(pcl_i[ids, 0:3], house_box.reshape([1, 7])) if not mask.all(): print(f'some points are out of box in image {i}') continue if pre_downsample_num < pcl_i.shape[0]: pcl_i = random_sample_pcl(pcl_i, pre_downsample_num) pcls_all.append(pcl_i) if gen_ply_each_image: pcd = open3d.PointCloud() pcd.points = open3d.Vector3dVector(pcl_i) base_name = os.path.basename(depth_fns[i]).replace( 'depth.png', 'pcl.ply') pcl_fn = os.path.join(pcl_path, base_name) open3d.write_point_cloud(pcl_fn, pcd) open3d.draw_geometries([pcd]) import pdb pdb.set_trace() # XXX BREAKPOINT pass pcls_all = np.concatenate(pcls_all, 0) if pcls_all.shape[0] > 5e6: print(f'{pcls_all.shape[0]} random to 5e6') pcls_all = random_sample_pcl(pcls_all, int(5e6)) org_num = pcls_all.shape[0] print(f'org point num: {pcls_all.shape[0]/1000} K') if org_num < MIN_POINT_NUM: print( f'only {org_num} points, del cams and re-generate later\n del {parsed_dir}' ) import shutil shutil.rmtree(parsed_dir) return False #if org_num > 1e7: # pcls_all = random_sample_pcl(pcls_all, int(max(1e7, org_num/10)) ) # print(f'random sampling to point num: {pcls_all.shape[0]/1000} K') pcd = open3d.PointCloud() pcd.points = open3d.Vector3dVector(pcls_all[:, 0:3]) pcd.colors = open3d.Vector3dVector(pcls_all[:, 3:6]) pcd = open3d.voxel_down_sample(pcd, voxel_size=0.02) new_num = np.asarray(pcd.points).shape[0] print(f'new point num: {new_num/1000.0} K') open3d.write_point_cloud(pcl_fn, pcd) #open3d.draw_geometries([pcd]) write_summary(parsed_dir, 'points_num', new_num, 'a') pcl_size, xyarea = get_pcl_size(pcls_all[:, 0:3]) write_summary(parsed_dir, 'scene_size', pcl_size, 'a') write_summary(parsed_dir, 'xyarea', xyarea, 'a') #open3d.draw_geometries([pcd]) return True
def preprocess_cfr(ceilings_org, walls_org, obj): ''' Z is up, Y is thickness ''' #Bbox3D.draw_bboxes(walls, 'Z', False) ceilings = ceilings_org.copy() walls = walls_org.copy() walls = replace_slant_walls(walls) dis_threshold = 0.07 ceiling_cens = ceilings[:, 0:3] ceiling_cens[:, 2] = 0 ceil_cenlines_x = Bbox3D.bboxes_centroid_lines(ceilings, 'X', 'Z') ceil_cenlines_x[:, :, 2] = 0 #ceil_cenlines_y = Bbox3D.bboxes_centroid_lines(ceilings, 'Y', 'Z') wall_cenlines = Bbox3D.bboxes_centroid_lines(walls, 'X', 'Z') wall_cenlines[:, :, 2] = 0 ceilings_shrink = ceilings.copy() ceilings_shrink[:, 3:5] -= 0.3 cn = ceilings.shape[0] ## Find edge wall nums good_ceiling_ids = [] for c in range(cn): # (0.1) If no any other overlap ceiling, try to keep it # Otherwise, delete it when >3 wall inside ceiling tmp = np.delete(ceiling_cens.copy(), c, axis=0) any_overlap = Bbox3D.points_in_bbox(tmp, ceilings[c:c + 1]).any() if any_overlap: wall_corner0_in_ceil = Bbox3D.points_in_bbox( wall_cenlines[:, 0, :], ceilings_shrink[c:c + 1]) wall_corner1_in_ceil = Bbox3D.points_in_bbox( wall_cenlines[:, 1, :], ceilings_shrink[c:c + 1]) wall_inside_ceil = wall_corner0_in_ceil + wall_corner1_in_ceil wall_inside_ceil_ids = np.where(wall_inside_ceil)[0] nwic = wall_inside_ceil_ids.shape[0] if nwic > 3: if Debug and 1: print(f'bad ceiling, contain {nwic} walls inside') box_show = np.concatenate( [walls_org, ceilings_org[c:c + 1]], 0) Bbox3D.draw_bboxes_mesh(box_show, 'Z', False) box_show = np.concatenate([ walls_org[wall_inside_ceil_ids], ceilings_org[c:c + 1] ], 0) Bbox3D.draw_bboxes_mesh(box_show, 'Z', False) import pdb pdb.set_trace() # XXX BREAKPOINT continue # (1) the central corners of wall are inside of ceiling wall_cenlines_auged = line_aug(wall_cenlines) cw_cen_dis = ceiling_cens[c].reshape([1, 1, -1]) - wall_cenlines_auged cw_cen_dis = np.linalg.norm(cw_cen_dis, axis=2) ceil_diag_size = np.linalg.norm(ceilings[c, 3:5]) on_inside_ceil = (cw_cen_dis - ceil_diag_size / 2 < dis_threshold).sum(1) >= 2 if Debug and 0: #Bbox3D.draw_points_bboxes(wall_cenlines_auged.reshape([-1,3]), walls, 'Z', False) inside_ids = np.where(on_inside_ceil)[0] box_show = np.concatenate( [walls_org[inside_ids], ceilings_org[c:c + 1]], 0) Bbox3D.draw_bboxes_mesh(box_show, 'Z', False) # (2) along x: wall central line is on x boundaries of ceiling dis_cw = vertical_dis_points_lines(ceil_cenlines_x[c], wall_cenlines) ceil_y_thickness = ceilings[c, 4] mask_x0 = np.abs(dis_cw[0] - dis_cw[1]) < dis_threshold mask_x1 = (np.abs(dis_cw - ceil_y_thickness / 2) < dis_threshold).all(0) mask_x = mask_x0 * mask_x1 * on_inside_ceil wall_on_ceil_boundary_parall_x = np.where(mask_x)[0] num_edgew_x = clean_edge_wall_same_side( wall_cenlines[wall_on_ceil_boundary_parall_x]) # (3) along x: wall central line is on x boundaries of ceiling ceil_x_thickness = ceilings[c, 3] mask_y0 = dis_cw < dis_threshold mask_y1 = np.abs(dis_cw - ceil_x_thickness) < dis_threshold mask_y = (mask_y0 + mask_y1).all(0) mask_y = mask_y * on_inside_ceil wall_on_ceil_boundary_parall_y = np.where(mask_y)[0] num_edgew_y = clean_edge_wall_same_side( wall_cenlines[wall_on_ceil_boundary_parall_y]) #Bbox3D.point_in_box(wall_cenlines, ceilings[]) edge_wall_num = num_edgew_x + num_edgew_y if edge_wall_num >= 3: good_ceiling_ids.append(c) if Debug and edge_wall_num < 3 and 0: print(f'edge_wall_num: {edge_wall_num}') box_show = np.concatenate([walls_org, ceilings_org[c:c + 1]], 0) Bbox3D.draw_bboxes_mesh(box_show, 'Z', False) #Bbox3D.draw_points_bboxes(ceil_cenlines_x[c], box_show, 'Z', False) #Bbox3D.draw_points_bboxes(ceil_cenlines_x[c], ceilings[c:c+1], 'Z', False) edge_walls_x = walls_org[wall_on_ceil_boundary_parall_x] box_x = np.concatenate([edge_walls_x, ceilings_org[c:c + 1]], 0) #Bbox3D.draw_bboxes_mesh(box_x, 'Z', False) edge_walls_y = walls_org[wall_on_ceil_boundary_parall_y] box_y = np.concatenate([edge_walls_y, ceilings_org[c:c + 1]], 0) #Bbox3D.draw_bboxes_mesh(box_y, 'Z', False) walls_inside = walls_org[wall_inside_ceil_ids] box_ins = np.concatenate([walls_inside, ceilings_org[c:c + 1]], 0) #Bbox3D.draw_bboxes_mesh(box_ins, 'Z', False) import pdb pdb.set_trace() # XXX BREAKPOINT pass good_ceiling_ids = np.array(good_ceiling_ids).reshape([-1]) new_cn = good_ceiling_ids.shape[0] print(f'\n\n{obj} {cn} -> {new_cn}') if new_cn == 0: new_ceilings = ceilings_org[0:0] else: new_ceilings = ceilings_org[good_ceiling_ids] if Debug and new_cn < cn: print(good_ceiling_ids) box_show = np.concatenate([walls_org, new_ceilings], 0) Bbox3D.draw_bboxes_mesh(box_show, 'Z', False) bad_ceil_ids = np.array([ i for i in range(cn) if i not in good_ceiling_ids ]).astype(np.int32) if bad_ceil_ids.shape[0] > 0: box_show = np.concatenate([walls_org, ceilings_org[bad_ceil_ids]], 0) Bbox3D.draw_bboxes_mesh(box_show, 'Z', False) import pdb pdb.set_trace() # XXX BREAKPOINT return ceilings