point_radius=45,

max_angle=15,
extend=25,
merge_th=100.0,
min_missing_distance=1000.0,
scale_estimation_coefficient=2.54,
clustering_eps=150,
interpolation_radius=10000,
point_radius_scale=0.5,
# dist_coeff=0,
pointcloud_depth_coeff=1.005,

handcrafted_solution.py

@@ -105,7 +105,7 @@ def clean_image(image_gestalt) -> np.ndarray:
     return image_gestalt
 
 
-def get_vertices(image_gestalt, *, color_range=4., dialations=3, erosions=1, kernel_size=13):
+def get_vertices(image_gestalt, *, color_range=3.5, dialations=2, erosions=1, kernel_size=11):
     ### detects the apex and eave end and flashing end points
     apex_mask = cv2.inRange(image_gestalt, apex_color - color_range, apex_color + color_range)
     eave_end_point_mask = cv2.inRange(image_gestalt, eave_end_point - color_range, eave_end_point + color_range)
@@ -172,7 +172,7 @@ def get_lines_and_directions(gest_seg_np, edge_class, *, color_range=4., rho, th
 
     # Run Hough on edge detected image
     # Output "lines" is an array containing endpoints of detected line segments
-    cv2.GaussianBlur(mask, (11, 11), 0, mask)
+    # cv2.GaussianBlur(mask, (11, 11), 0, mask)
     lines = cv2.HoughLinesP(mask, rho, theta, threshold, np.array([]),
                             min_line_length, max_line_gap)
 
@@ -205,7 +205,7 @@ def infer_missing_vertices(ridge_edges, rake_edges):
     rake_ends = np.concatenate([rake_edges[:, 2:], rake_edges[:, :2]])
     ridge_ends = KDTree(ridge_ends)
     rake_ends = KDTree(rake_ends)
-    missing_candidates = rake_ends.query_ball_tree(ridge_ends, 5)
+    missing_candidates = rake_ends.query_ball_tree(ridge_ends, 10)
     missing_candidates = np.concatenate([*missing_candidates])
     missing_candidates = np.unique(missing_candidates).astype(np.int32)
 
@@ -231,9 +231,6 @@ def get_vertices_and_edges_from_segmentation(gest_seg_np, *,
     # missed_vertices = get_missed_vertices(vertices, inferred_vertices, **kwargs)
     # vertices = np.concatenate([vertices, missed_vertices])
 
-    if len(vertices) < 2:
-        return [], []
-
 
     edges = []
     line_directions = []
@@ -272,6 +269,8 @@ def get_vertices_and_edges_from_segmentation(gest_seg_np, *,
         inferred_vertices = infer_missing_vertices(ridge_edges, rake_edges)
         missed_vertices = get_missed_vertices(vertices, inferred_vertices, **kwargs)
         vertices = np.concatenate([vertices, missed_vertices])
+    if len(vertices) < 2:
+        return [], []
 
     vertex_size = np.full(len(vertices), point_radius/2)
     apex_radii *= point_radius_scale
@@ -294,7 +293,9 @@ def get_vertices_and_edges_from_segmentation(gest_seg_np, *,
                        # 'post',
                        'valley',
                        'hip',
-                       'transition_line']:
+                       'transition_line',
+                       'fascia',
+                       'soffit',]:
         class_edges, class_directions = get_lines_and_directions(gest_seg_np, edge_class,
                                                                  rho=rho,
                                                                  theta=theta,
@@ -308,9 +309,10 @@ def get_vertices_and_edges_from_segmentation(gest_seg_np, *,
             line_directions.append(class_directions)
 
     edges = np.concatenate(edges).astype(np.float64)
-    line_directions = np.concatenate(line_directions).astype(np.float64)
     if len(edges) < 1:
         return [], []
+    line_directions = np.concatenate(line_directions).astype(np.float64)
+
     # calculate the distances between the vertices and the edge ends
 
     begin_edges = KDTree(edges[:, :2])
@@ -395,7 +397,7 @@ def get_vertices_and_edges_from_segmentation(gest_seg_np, *,
 def get_uv_depth(vertices, depth):
     '''Get the depth of the vertices from the depth image'''
 
-    # depth[depth > 5000] = np.inf
+    depth[depth > 3000] = np.nan
     uv = np.array([v['xy'] for v in vertices])
     uv_int = uv.astype(np.int32)
     H, W = depth.shape[:2]
@@ -440,10 +442,6 @@ def merge_vertices_3d(vert_edge_per_image, merge_th=0.1, **kwargs):
 
     all_3d_vertices = np.concatenate(all_3d_vertices, axis=0)
 
-    # dbscan = DBSCAN(eps=merge_th, min_samples=1).fit(all_3d_vertices)
-    # print(dbscan.core_sample_indices_)
-    # print(dbscan.labels_[dbscan.core_sample_indices_])
-    # print (connections_3d)
     distmat = cdist(all_3d_vertices, all_3d_vertices)
     types = np.array(types).reshape(-1, 1)
     same_types = cdist(types, types)
@@ -471,16 +469,13 @@ def merge_vertices_3d(vert_edge_per_image, merge_th=0.1, **kwargs):
         new_vertices.append(all_3d_vertices[idxs].mean(axis=0))
         for idx in idxs:
             old_idx_to_new[idx] = count
-    # 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
 
 
@@ -515,9 +510,7 @@ def clean_points3d(entry, clustering_eps):
     point_keys = [k for k, v in entry["points3d"].items()]
     point_keys = np.array(point_keys)
     
-    # print(len(points))
-    
-    clustered = DBSCAN(eps=clustering_eps, min_samples=10).fit(points).labels_
+    clustered = DBSCAN(eps=clustering_eps, min_samples=5).fit(points).labels_
     clustered_indices = np.argsort(clustered)
     
     points = points[clustered_indices]
@@ -601,6 +594,8 @@ def predict(entry, visualize=False,
             vert_edge_per_image[i] = np.empty((0, 2)), [], np.empty((0, 3))
             continue
         depth_np = np.array(depthcm) / scale_estimation_coefficient
+        # kernel = np.array([[-1,-1,-1], [-1,9,-1], [-1,-1,-1]])
+        # depth_np = cv2.filter2D(depth_np, -1, kernel)
         uv, depth_vert_from_depth_map = get_uv_depth(vertices, depth_np)
         try:
             image = image_dict[imagekey]
@@ -624,7 +619,7 @@ def predict(entry, visualize=False,
             #Revert to the depthmap
             depthmap_used = True
 
-            # Normalize the uv to the camera intrinsics
+        # Normalize the uv to the camera intrinsics
 
         xy_local = np.ones((len(uv), 3))
         xy_local[:, 0] = (uv[:, 0] - K[0, 2]) / K[0, 0]
@@ -657,7 +652,6 @@ def predict(entry, visualize=False,
             vertices_3d_local[depth_vert_nan_idxs] /= norm_factor_max
             vertices_3d_local[~np.isin(np.arange(len(vertices_3d_local)), depth_vert_nan_idxs)] /= norm_factor_min
 
-        # vertices_3d_local = depth_vert[..., None] * (xy_local / norm_factor)
         world_to_cam = np.eye(4)
         world_to_cam[:3, :3] = R
         world_to_cam[:3, 3] = t
@@ -674,6 +668,7 @@ def predict(entry, visualize=False,
         vert_edge_per_image[i] = vertices, connections, vertices_3d
     all_3d_vertices, connections_3d = merge_vertices_3d(vert_edge_per_image, **kwargs)
     all_3d_vertices_clean, connections_3d_clean = all_3d_vertices, connections_3d
+    # all_3d_vertices_clean, connections_3d_clean = prune_not_connected(all_3d_vertices, connections_3d)
     # highest_edges = np.argpartition(all_3d_vertices_clean[:, 1], 4)[:4].tolist()
     #
     # connections_3d_clean.append(highest_edges[:2])

script.py

@@ -142,13 +142,13 @@ if __name__ == "__main__":
             results = []
             for i, sample in enumerate(batch):
                 results.append(pool.submit(predict, sample,
-                                           point_radius=40,
+                                           point_radius=45,
                                            max_angle=15,
                                            extend=25,
-                                           merge_th=80.0,
-                                           min_missing_distance=359.0,
+                                           merge_th=100.0,
+                                           min_missing_distance=1000.0,
                                            scale_estimation_coefficient=2.54,
-                                           clustering_eps=100,
+                                           clustering_eps=150,
                                            interpolation_radius=10000,
                                            point_radius_scale=0.5,
                                            # dist_coeff=0,