Upload handcrafted_solution.py

handcrafted_solution.py

@@ -18,7 +18,7 @@ if DUMP_IMG:
   from scipy.sparse import random
 
 def empty_solution():
-    '''Return a minimal valid solution, i.e. 2 vertices and 1 edge.'''
+    '''Return a minimal valid solution, i.e. 2 vertices and 0 edge.'''
     return np.zeros((2,3)), []
     
 
@@ -43,77 +43,6 @@ def convert_entry_to_human_readable(entry):
     return out
 
 
-def get_vertices_and_edges_from_segmentation(gest_seg_np, edge_th = 50.0):
-    '''Get the vertices and edges from the gestalt segmentation mask of the house'''
-    vertices = []
-    connections = []
-    # Apex
-    apex_color = np.array(gestalt_color_mapping['apex'])
-    apex_mask = cv2.inRange(gest_seg_np,  apex_color-0.5, apex_color+0.5)
-    if apex_mask.sum() > 0:
-        output = cv2.connectedComponentsWithStats(apex_mask, 8, cv2.CV_32S)
-        (numLabels, labels, stats, centroids) = output
-        stats, centroids = stats[1:], centroids[1:]
-        
-        for i in range(numLabels-1):
-            vert = {"xy": centroids[i], "type": "apex"}
-            vertices.append(vert)
-    
-    eave_end_color = np.array(gestalt_color_mapping['eave_end_point'])
-    eave_end_mask = cv2.inRange(gest_seg_np,  eave_end_color-0.5, eave_end_color+0.5)
-    if eave_end_mask.sum() > 0:
-        output = cv2.connectedComponentsWithStats(eave_end_mask, 8, cv2.CV_32S)
-        (numLabels, labels, stats, centroids) = output
-        stats, centroids = stats[1:], centroids[1:]
-        
-        for i in range(numLabels-1):
-            vert = {"xy": centroids[i], "type": "eave_end_point"}
-            vertices.append(vert) 
-    # Connectivity
-    apex_pts = []
-    apex_pts_idxs = []
-    for j, v in enumerate(vertices):
-        apex_pts.append(v['xy'])
-        apex_pts_idxs.append(j)
-    apex_pts = np.array(apex_pts)
-            
-    # Ridge connects two apex points
-    for edge_class in ['eave', 'ridge', 'rake', 'valley']:
-        edge_color = np.array(gestalt_color_mapping[edge_class])
-        mask = cv2.morphologyEx(cv2.inRange(gest_seg_np,
-                                            edge_color-0.5,
-                                            edge_color+0.5),
-                                cv2.MORPH_DILATE, np.ones((11, 11)))
-        line_img = np.copy(gest_seg_np) * 0
-        if mask.sum() > 0:
-            output = cv2.connectedComponentsWithStats(mask, 8, cv2.CV_32S)
-            (numLabels, labels, stats, centroids) = output
-            stats, centroids = stats[1:], centroids[1:]
-            edges = []
-            for i in range(1, numLabels):
-                y,x = np.where(labels == i)
-                xleft_idx = np.argmin(x)
-                x_left = x[xleft_idx]
-                y_left = y[xleft_idx]
-                xright_idx = np.argmax(x)
-                x_right = x[xright_idx]
-                y_right = y[xright_idx]
-                edges.append((x_left, y_left, x_right, y_right))
-                cv2.line(line_img, (x_left, y_left), (x_right, y_right), (255, 255, 255), 2)
-            edges = np.array(edges)
-            if (len(apex_pts) < 2) or len(edges) <1:
-                continue
-            pts_to_edges_dist = np.minimum(cdist(apex_pts, edges[:,:2]), cdist(apex_pts, edges[:,2:]))
-            connectivity_mask = pts_to_edges_dist <= edge_th
-            edge_connects = connectivity_mask.sum(axis=0)
-            for edge_idx, edgesum in enumerate(edge_connects):
-                if edgesum>=2:
-                    connected_verts = np.where(connectivity_mask[:,edge_idx])[0]
-                    for a_i, a in enumerate(connected_verts):
-                        for b in connected_verts[a_i+1:]:
-                            connections.append((a, b))
-    return vertices, connections
-
 def get_uv_depth(vertices, depth):
     '''Get the depth of the vertices from the depth image'''
     uv = []
@@ -129,7 +58,6 @@ def get_uv_depth(vertices, depth):
 
 def get_smooth_uv_depth(vertices, depth, gest_seg_np, sfm_depth_np, r=5):
     '''Get the depth of the vertices from the depth image'''
-    #print(f'max depth = {np.max(depth)}')
     uv = []
     for v in vertices:
         uv.append(v['xy'])
@@ -157,9 +85,6 @@ def get_smooth_uv_depth(vertices, depth, gest_seg_np, sfm_depth_np, r=5):
     def get_local_min(x,y, H, W, depth, sfm_depth_np, r=r, PRINT=False):
       '''return a smooth version of detph in radius r'''      
       local_min = 9999999
-      #PRINT = False
-      #if np.isclose(x, 90.13846154, atol=10) and np.isclose(y, 1175.46495726, atol=10):
-      #  PRINT = True
       i_range = range(max(0, x - r), min(W, x + r))
       j_range = range(max(0, y - r), min(H, y + r))
       for i in i_range:
@@ -167,18 +92,16 @@ def get_smooth_uv_depth(vertices, depth, gest_seg_np, sfm_depth_np, r=5):
               if sfm_depth_np is not None:
                 if sfm_depth_np[j, i] != 0:
                   local_min = min(sfm_depth_np[j, i], local_min)
-                  #if PRINT: print(sfm_depth_np[j, i])
                   if PRINT: print(f'({j},{i})sfm:', sfm_depth_np[j, i])
                 else:
                   local_min = min(depth[j, i], local_min)
-                  #if PRINT: print(f'({j},{i})dm:', depth[j, i])
               else:
                 local_min = min(depth[j, i], local_min)
-                #if PRINT: print(f'({j},{i})dm:', depth[j, i])    
       return local_min
 
     def get_priotity_local_min(x,y, H, W, depth, sfm_depth_np, r=r):
-      '''Search on sfm depth first. Search on depthmap only if no sfm depth 
+      '''
+      Search on sfm depth first. Search on depthmap only if no sfm depth 
       exists at all in the local region.
       '''
       PRINT = False 
@@ -188,11 +111,8 @@ def get_smooth_uv_depth(vertices, depth, gest_seg_np, sfm_depth_np, r=5):
         xslice = slice(max(0, x - r), min(W, x + r))      
         local_area = sfm_depth_np[yslice, xslice]
         reduced_local_area = local_area[local_area!=0]
-        #if np.isclose(x, 2574.81093605, atol=10) and np.isclose(y, 1063.7265987, atol=10):
-        #  PRINT = True
         if reduced_local_area.size > 0:
           break              
-      #print('r=', r)
       if reduced_local_area.size > 0:
         #print('use sfm')
         if PRINT: print(reduced_local_area)
@@ -203,23 +123,18 @@ def get_smooth_uv_depth(vertices, depth, gest_seg_np, sfm_depth_np, r=5):
         return get_local_min(x,y, H, W, depth, sfm_depth_np, r, PRINT)
 
     def get_local_min_progressive(x,y, H, W, depth, sfm_depth_np, r=r):
-      '''If sfm is available in small local region, use it. 
-      Otherwise, search in large region with combined depth'''      
-      #PRINT = False
-      #if np.isclose(x, 2145.91971831, atol=10) and np.isclose(y, 960.9056338, atol=10):
-      #  PRINT = True
+      '''
+      If sfm is available in small local region, use it. 
+      Otherwise, search in large region with combined depth
+      '''      
       small_r, large_r = 5, 75
       PRINT= False
-      #if np.isclose(x, 1799.44303797, atol=10) and np.isclose(y, 622.37721519, atol=10):
-      #  PRINT= True
       r = small_r
       yslice = slice(max(0, y - r), min(H, y + r))
       xslice = slice(max(0, x - r), min(W, x + r))
       if np.any(sfm_depth_np[yslice, xslice] != 0):
-        #print(f'{x}, {y}, has local sfm')
         return get_local_min(x,y, H, W, depth, sfm_depth_np, r)
       else:
-        #print(f'{x}, {y}, has local sfm')        
         r = large_r
         local_min = 9999999
         i_range = range(max(0, x - r), min(W, x + r))
@@ -252,7 +167,7 @@ def get_smooth_uv_depth(vertices, depth, gest_seg_np, sfm_depth_np, r=5):
     vertex_depth = np.array(vertex_depth)
     return uv, vertex_depth
 
-'''
+''' Turn on this to speed up if you have numba
 from numba import njit, prange
 @njit(parallel=True)
 def fill_range(u, v, z, dilate_r, c, sfm_depth_np, sfm_color_np, H, W):
@@ -273,29 +188,20 @@ def get_SfM_depth(XYZ, rgb, depth_np, gest_seg_np, K, R, t, dilate_r = 5):
   H, W = depth_np.shape[:2]
   sfm_depth_np = np.zeros(depth_np.shape)
   sfm_color_np = np.zeros(gest_seg_np.shape)
-  #XYZ1 = np.stack([(p.xyz, 1) for p in points3D.values()])    
-  #XYZ = np.stack([p.xyz for p in points3D.values()])
-  #rgb = np.stack([p.rgb for p in points3D.values()])
-  #print('XYZ is ', XYZ.shape)
   XYZ1 = np.concatenate((XYZ, np.ones((len(XYZ), 1))), axis=1)
-  #print('XYZ1 is ', XYZ1.shape)
   Rt = np.concatenate( (R, t.reshape((3,1))), axis=1)
   world_to_cam = K @ Rt
   xyz = world_to_cam @ XYZ1.transpose()
   xyz = np.transpose(xyz)  
-  #print('shape of xyz: ', xyz.shape)
   valid_idx = ~np.isclose(xyz[:,2], 0, atol=1e-2) & ~np.isnan(xyz[:,0]) & ~np.isnan(xyz[:,1]) & ~np.isnan(xyz[:,2]) 
   xyz = xyz[valid_idx, :]
   us, vs, zs = xyz[:,0]/xyz[:,2], xyz[:,1]/xyz[:,2], xyz[:,2]
-  #print('dim of us uv zs rgb:', len(us), len(vs), len(zs), len(rgb))  
   us = us[~np.isnan(us)]
   vs = vs[~np.isnan(vs)]
   us = us.astype(np.int32)    
   vs = vs.astype(np.int32)
-  #checked = 0  
-  #print('dim of us uv zs rgb:', len(us), len(vs), len(zs), len(rgb))
   for u,v,z,c in zip(us,vs,zs, rgb):
-    '''
+    ''' Use this insead if you have numba
     sfm_depth_np, sfm_color_np = fill_range(u, v, z, dilate_r, c, sfm_depth_np, sfm_color_np, H, W)
     '''
     i_range = range(max(0, u - dilate_r), min(W, u + dilate_r))
@@ -309,11 +215,7 @@ def get_SfM_depth(XYZ, rgb, depth_np, gest_seg_np, K, R, t, dilate_r = 5):
             sfm_depth_np[j, i] = z
             if DUMP_IMG: 
               sfm_color_np[j, i] = c
-    
-         
-              
-  #print(f'checked {checked} pts')
-
+           
   if DUMP_IMG:
     filename_sfm_depth = 'sfm_depth.png'
     cv2.imwrite(filename_sfm_depth, sfm_depth_np/100)
@@ -328,12 +230,11 @@ def get_vertices_and_edges_from_two_segmentations(ade_seg_np, gest_seg_np, edge_
     '''Get the vertices and edges from the gestalt segmentation mask of the house'''
     vertices = []
     connections = []
-    color_th =  10.0 # Cost ->2.6
+    color_th =  10.0
 
     #-------------------------    
     # combined map from ade
     if DUMP_IMG:
-      #print(gest_seg_np.shape, ade_seg_np.shape)
       ade_color0 = np.array([0,0,0]) 
       ade_mask0 = cv2.inRange(ade_seg_np,  ade_color0-0.5, ade_color0+0.5)
       ade_color1 = np.array([120,120,120]) 
@@ -344,26 +245,21 @@ def get_vertices_and_edges_from_two_segmentations(ade_seg_np, gest_seg_np, edge_
       ade_mask3 = cv2.inRange(ade_seg_np,  ade_color3-0.5, ade_color3+0.5)
       ade_mask = cv2.bitwise_or(ade_mask3, ade_mask2)
       ade_mask = cv2.bitwise_or(ade_mask1, ade_mask)
-      #print(ade_mask.any())
     apex_map = np.zeros(ade_seg_np.shape)
     apex_map_on_ade = ade_seg_np 
     apex_map_on_gest = gest_seg_np
     # Apex
     apex_color = np.array(gestalt_color_mapping['apex'])
-    #print(f'apex_color= {apex_color}')
-    #apex_mask = cv2.inRange(gest_seg_np,  apex_color-0.5, apex_color+0.5) 
     apex_mask = cv2.inRange(gest_seg_np,  apex_color-color_th, apex_color+color_th) # include more pts
     #apex_mask = cv2.bitwise_and(apex_mask, ade_mask) # remove pts
     if apex_mask.sum() > 0:
         output = cv2.connectedComponentsWithStats(apex_mask, 8, cv2.CV_32S)
         (numLabels, labels, stats, centroids) = output
-        stats, centroids = stats[1:], centroids[1:]
-        
+        stats, centroids = stats[1:], centroids[1:]        
         for i in range(numLabels-1):
             vert = {"xy": centroids[i], "type": "apex"}
             vertices.append(vert)
             if DUMP_IMG:
-              #print(f'centroids[i]={centroids[i]}')
               uu = int(centroids[i][1])
               vv = int(centroids[i][0])
               # plot a cross
@@ -376,11 +272,8 @@ def get_vertices_and_edges_from_two_segmentations(ade_seg_np, gest_seg_np, edge_
                   apex_map_on_ade[uu+ss[0], vv+ss[1]] = (255,255,255)
                   apex_map_on_gest[uu+ss[0], vv+ss[1]] = (255,255,255)
     
-
     eave_end_color = np.array(gestalt_color_mapping['eave_end_point'])
-    #eave_end_mask = cv2.inRange(gest_seg_np,  eave_end_color-0.5, eave_end_color+0.5)
     eave_end_mask = cv2.inRange(gest_seg_np,  eave_end_color-color_th, eave_end_color+color_th)
-    #eave_end_mask = cv2.bitwise_and(eave_end_mask, ade_mask)
     if eave_end_mask.sum() > 0:
         output = cv2.connectedComponentsWithStats(eave_end_mask, 8, cv2.CV_32S)
         (numLabels, labels, stats, centroids) = output
@@ -435,7 +328,6 @@ def get_vertices_and_edges_from_two_segmentations(ade_seg_np, gest_seg_np, edge_
       filename_apex_map = f'apex_map_{rid}.jpg'
       cv2.imwrite(filename_apex_map, apex_map)
 
-    #print(f'{len(vertices)} vertices detected')
     # Connectivity
     apex_pts = []
     apex_pts_idxs = []
@@ -443,6 +335,7 @@ def get_vertices_and_edges_from_two_segmentations(ade_seg_np, gest_seg_np, edge_
         apex_pts.append(v['xy'])
         apex_pts_idxs.append(j)
     apex_pts = np.array(apex_pts)
+    # Turns out connection is not a priority
     '''       
     # Ridge connects two apex points
     def Ridge_connects_two_apex_points(gest_seg_np, color_th, apex_pts, edge_th):
@@ -556,7 +449,6 @@ def merge_vertices_3d(vert_edge_per_image, th=0.1):
         connections_3d+=[(x+cur_start,y+cur_start) for (x,y) in connections]
         cur_start+=len(vertices_3d)
     all_3d_vertices = np.concatenate(all_3d_vertices, axis=0)
-    #print (connections_3d)
     distmat = cdist(all_3d_vertices, all_3d_vertices)
     types = np.array(types).reshape(-1,1)
     same_types = cdist(types, types)
@@ -586,16 +478,13 @@ def merge_vertices_3d(vert_edge_per_image, th=0.1):
         for idx in idxs:
             old_idx_to_new[idx] = count
         count +=1
-    #print (connections_3d)
     new_vertices=np.array(new_vertices)
-    #print (connections_3d)
     for conn in connections_3d:
         new_con = sorted((old_idx_to_new[conn[0]], old_idx_to_new[conn[1]]))
         if new_con[0] == new_con[1]:
             continue
         if new_con not in new_connections:
             new_connections.append(new_con)
-    #print (f'{len(new_vertices)} left after merging {len(all_3d_vertices)} with {th=}')
     return new_vertices, new_connections
 
 def prune_not_connected(all_3d_vertices, connections_3d):
@@ -636,15 +525,12 @@ def uv_to_v3d(uv, depth_vert, K, R, t):
 
 def delete_one_vert(vertices, vertices_3d, connections, vert_to_del):
   i = np.where(np.all(abs(vertices_3d - vert_to_del) < 0.01, axis=1))
-  #print(i)
-  #print(len(i[0]))
   if len(i[0])==0:
     if vertices:
       return vertices, vertices_3d, connections
     else:
         return vertices, vertices_3d, connections
 
-  #print('to del idx=', i[0])
   idx = i[0]#[0]
   if vertices:
     vertices = np.delete(vertices, idx)
@@ -659,18 +545,15 @@ def delete_one_vert(vertices, vertices_3d, connections, vert_to_del):
       connections[ic] = (connections[ic][0]-1, connections[ic][1])
     if c[1] >= idx:      
       connections[ic] = (connections[ic][0], connections[ic][1]-1)
-  
-  #print(f'del {len(conn_to_del)} connections')  
-  
+    
   connections = connections.tolist()
-  #print(vertices, vertices_3d, connections)
   if vertices:
     return vertices, vertices_3d, connections
   else:
     return vertices_3d, connections
 
 def prune_far(all_3d_vertices, connections_3d, prune_dist_thr=3000):
-    '''Prune vertices that are far away from any the other vertices'''
+    '''Prune vertices that are far away from any other vertices'''
     if (len(all_3d_vertices) < 3) or len(connections_3d) < 1:
       return all_3d_vertices, connections_3d
     
@@ -678,11 +561,8 @@ def prune_far(all_3d_vertices, connections_3d, prune_dist_thr=3000):
     distmat = cdist(all_3d_vertices, all_3d_vertices)    
     for i, v in enumerate(distmat):
       exclude_self = np.array([x for idx,x in enumerate(v) if idx!=i])
-      #print('excluded:', exclude_self)
-      #if np.any(exclude_self > prune_dist_thr):
       exclude_self = abs(exclude_self)
       if min(exclude_self) > prune_dist_thr:
-        #print('del a pt w/ dist = ', min(exclude_self))
         isolated.append(i)
         break
 
@@ -733,6 +613,9 @@ def prune_tall_short(all_3d_vertices, connections_3d, lowest_z, prune_tall_thr=1
     return all_3d_vertices, connections_3d
 
 def clean_gest(gest_seg_np):
+  '''
+  Remove all blobs that are not conencted to the largest blob
+  '''
   bg_color = np.array(gestalt_color_mapping['unclassified'])
   bg_mask = cv2.inRange(gest_seg_np,  bg_color-10, bg_color+10)
   if bg_mask.sum() == 0 or bg_mask.sum() == gest_seg_np.shape[0]*gest_seg_np.shape[1]:
@@ -750,6 +633,9 @@ def clean_gest(gest_seg_np):
   return gest_seg_np
 
 def clean_PCD(XYZ, rgb):
+  '''
+  Remove all points that do not belong to the largest cluster
+  '''
   lowest_z = 0
   center_thr = 500
   largest_blob_size = 0
@@ -761,8 +647,6 @@ def clean_PCD(XYZ, rgb):
   clust = OPTICS(min_samples=20, max_eps=150, metric='euclidean', cluster_method='dbscan', algorithm='kd_tree').fit(XYZ)
   labels = clust.labels_
   unique_labels = set(labels)
-  #print('uni label:', len(unique_labels))
-  #core_samples_mask = np.zeros_like(labels, dtype=bool)  
   retain_class_mask = labels == -2       
   if len(unique_labels) > 40 or len(unique_labels) == 1:
     return XYZ, rgb, lowest_z
@@ -774,9 +658,9 @@ def clean_PCD(XYZ, rgb):
       largest_blob_size = blob_size
       largest_blob = k
   
-  for k in unique_labels:
-    
+  for k in unique_labels:    
     '''
+    # -1 is the noise cluster
     if k == -1:
       retain_class_mask = retain_class_mask | class_member_mask
       continue    
@@ -816,16 +700,12 @@ def predict(entry, visualize=False, prune_dist_thr=600, depth_scale=2.5, ) -> Tu
                                                 good_entry['R'],
                                                 good_entry['t'] 
                                                 )):                                              
-        ''' entry 0 suggests:
-        depth_scale = 1
-        if i==1: 
-          depth_scale = 2.5
-        elif i==2: # only visualize view 0,1
-          continue 
-        
+        '''
+        debug per view 
         if i!=3:
           continue
         '''
+        # (1) 2D processing
         ade_seg = ade.resize(depth.size)
         ade_seg_np = np.array(ade_seg).astype(np.uint8)
         gest_seg = gest.resize(depth.size)
@@ -833,45 +713,23 @@ def predict(entry, visualize=False, prune_dist_thr=600, depth_scale=2.5, ) -> Tu
         gest_seg_np = clean_gest(gest_seg_np)
         
         # Metric3D
-        depth_np = np.array(depth) / depth_scale # / 2.5 # 2.5 is the scale estimation coefficient # don't use 2.5...
-        #vertices, connections = get_vertices_and_edges_from_segmentation(gest_seg_np, edge_th = 20.)
-        #vertices, connections = get_vertices_and_edges_from_two_segmentations(ade_seg_np, gest_seg_np, edge_th = 20.)
-        vertices, connections = get_vertices_and_edges_from_two_segmentations(ade_seg_np, gest_seg_np, edge_th = 50.)
-        
-        '''
-        if (len(vertices) < 2) or (len(connections) < 1):
-            print (f'Not enough vertices ({len(vertices)}) or connections ({len(connections)}) in image {i}')
-            vert_edge_per_image[i] = np.empty((0, 2)), [], np.empty((0, 3))
-            continue
-        '''
+        depth_np = np.array(depth) / depth_scale        
+        vertices, connections = get_vertices_and_edges_from_two_segmentations(ade_seg_np, gest_seg_np, edge_th = 50.)                
         if (len(vertices) < 1):
           vert_edge_per_image[i] = np.empty((0, 2)), [], np.empty((0, 3))
           continue
-
-        #uv, depth_vert = get_uv_depth(vertices, depth_np)         
-        sfm_depth_np = get_SfM_depth(XYZ, rgb, depth_np, gest_seg_np, K, R, t, 5) # Sensitive. 10 is worse than 0 in testset
-        uv, depth_vert = get_smooth_uv_depth(vertices, depth_np, gest_seg_np, sfm_depth_np, 75)
-        #uv, depth_vert = get_smooth_uv_depth(vertices, depth_np, gest_seg_np, None)        
-        #print('uv:', uv, ' d:', depth_vert)
-        vertices_3d = uv_to_v3d(uv, depth_vert, K, R, t)        
         
-        '''
-        print('before del, ', len(vertices), len(vertices_3d), len(connections))
-        vert_to_del = np.array([-2807.275, -4999.645, 1284.803])
-        vertices, vertices_3d, connections = delete_one_vert(vertices, vertices_3d, connections, vert_to_del)        
-        print('after del, ', len(vertices), len(vertices_3d), len(connections))
-        '''             
+        # (2) Use depth
+        sfm_depth_np = get_SfM_depth(XYZ, rgb, depth_np, gest_seg_np, K, R, t, 5)
+        uv, depth_vert = get_smooth_uv_depth(vertices, depth_np, gest_seg_np, sfm_depth_np, 75)
+        vertices_3d = uv_to_v3d(uv, depth_vert, K, R, t)
         vert_edge_per_image[i] = vertices, connections, vertices_3d
-        #print(f'detect {len(vertices)} v and {len(connections)} e in view {i}')
-    #print('before merge, vertices=', vertices, ' connections=', connections, ' vertices_3d=', vertices_3d)
-    #all_3d_vertices, connections_3d = merge_vertices_3d(vert_edge_per_image, 3.0) # TODO: 3cm looks too small       
+        
+
+    # (3) aggregate info collected from all views:
     all_3d_vertices, connections_3d = merge_vertices_3d(vert_edge_per_image, 150)
-    #print(f'after merge, {len(all_3d_vertices)} 3d vertices and {len(connections_3d)} 3d connections')
-    #print(f'after merge, 3d vertices: {all_3d_vertices} and 3d connections: {connections_3d}')
-    #all_3d_vertices_clean, connections_3d_clean  = prune_not_connected(all_3d_vertices, connections_3d)    
     #all_3d_vertices, connections_3d  = prune_tall_short(all_3d_vertices, connections_3d, lowest_z, 1000, 0)
-    
-    '''
+    ''' This didn't help the final solution
     if len(all_3d_vertices)>35:
       all_3d_vertices, connections_3d  = prune_not_connected(all_3d_vertices, connections_3d)    
     '''
@@ -881,19 +739,7 @@ def predict(entry, visualize=False, prune_dist_thr=600, depth_scale=2.5, ) -> Tu
       all_3d_vertices_clean, connections_3d_clean = all_3d_vertices, connections_3d
 
     connections_3d_clean = []
-    '''    
-    if len(connections_3d_clean):
-      if i%2:    
-        connections_3d_clean = [connections_3d_clean[-1], connections_3d_clean[0]]
-      else:
-        connections_3d_clean = [connections_3d_clean[0]]
-    else:
-      print(i, ' has no conn!')      
-    #print('connections_3d_clean=', connections_3d_clean)
-    '''
-    #all_3d_vertices_clean, connections_3d_clean  = all_3d_vertices, connections_3d # don't prune -> cost:2.0
-    #print(f'after pruning, {len(all_3d_vertices_clean)} 3d clean vertices and {len(connections_3d_clean)} 3d clean connections')    
-    if (len(all_3d_vertices_clean) < 2): # or len(connections_3d_clean) < 1:
+    if (len(all_3d_vertices_clean) < 2):
         print (f'Not enough vertices or connections in the 3D vertices')
         return (good_entry['__key__'], *empty_solution())
     if visualize: