line stuff, now full hough, liberal edge selection

handcrafted_solution.py

@@ -116,39 +116,61 @@ def get_vertices_and_edges_from_segmentation(gest_seg_np, edge_th=50.0):
         cv2.circle(vertex_mask, np.round(i).astype(np.uint32), 15, (255,), 30, -1)
     vertex_mask = np.bitwise_not(vertex_mask)
 
-    for edge_class in ['eave', 'ridge', 'rake', 'valley', 'flashing']:
-        if (len(apex_pts) < 2):
+    scale = 4
+    vertex_size = np.zeros(apex_pts.shape[0])
+    for i, coords in enumerate(apex_pts):
+        coords = np.round(coords).astype(np.uint32)
+        radius = 25#np.clip(int(max_depth//2 + depth_np[coords[1], coords[0]]), 10, 30)#int(np.clip(max_depth - depth_np[coords[1], coords[0]], 10, 20))
+        vertex_size[i] = (scale*radius) ** 2 # because we are using squared distances
+        cv2.circle(vertex_mask, coords, radius - 5, (255, ), 2 * (radius - 5), -1)
+    # vertex_size *= scale
+    for edge_class in ['eave', 'ridge', 'rake', 'valley', 'flashing', 'step_flashing']:
+        if len(apex_pts) < 2:
             break
         edge_color = np.array(gestalt_color_mapping[edge_class])
 
         mask = cv2.inRange(gest_seg_np,
-                           edge_color - color_range,
-                           edge_color + color_range)
-        mask = cv2.bitwise_and(mask, vertex_mask)
+                           edge_color-color_range,
+                           edge_color+color_range)
+        # mask = cv2.bitwise_and(mask, vertex_mask)
 
         mask = cv2.morphologyEx(mask,
-                                cv2.MORPH_DILATE, np.ones((11, 11)), iterations=2)
-        if edge_class == "ridge":
-            mask = cv2.morphologyEx(mask,
-                                    cv2.MORPH_DILATE, np.ones((11, 11)), iterations=1)
+                                cv2.MORPH_DILATE, np.ones((3, 3)), iterations=1)
+        # if edge_class == "ridge":
+        #     mask = cv2.morphologyEx(mask,
+        #                             cv2.MORPH_DILATE, np.ones((11, 11)), iterations=1)
+
 
         if np.any(mask):
 
             rho = 1  # distance resolution in pixels of the Hough grid
             theta = np.pi / 180  # angular resolution in radians of the Hough grid
-            threshold = 15  # minimum number of votes (intersections in Hough grid cell)
-            min_line_length = 40  # minimum number of pixels making up a line
+            threshold = 20  # minimum number of votes (intersections in Hough grid cell)
+            min_line_length = 60  # minimum number of pixels making up a line
             max_line_gap = 40  # maximum gap in pixels between connectable line segments
 
             # Run Hough on edge detected image
             # Output "lines" is an array containing endpoints of detected line segments
+            cv2.GaussianBlur(mask, (11,11), 0, mask)
             lines = cv2.HoughLinesP(mask, rho, theta, threshold, np.array([]),
                                     min_line_length, max_line_gap)
 
             edges = []
 
             for line in lines if lines is not None else []:
-                for x1, y1, x2, y2 in line:
+                for x1,y1,x2,y2 in line:
+                    extend = 40
+                    if x1 < x2:
+                        x1, y1, x2, y2 = x2, y2, x1, y1
+                    # cv2.line(mask_copy,(x1,y1),(x2,y2),(255,),10, cv2.LINE_AA)
+                    direction = (np.array([x2 - x1, y2 - y1]))
+                    direction = extend * direction / np.linalg.norm(direction)
+
+                    # norm = extend * np.linalg.norm(np.array([y2 - y1, x1 - x2]))
+                    x1,y1 = (-direction + (x1, y1)).astype(np.int32)
+                    x2,y2 = (+ direction + (x2, y2)).astype(np.int32)
+
+
                     edges.append((x1, y1, x2, y2))
 
             edges = np.array(edges)
@@ -158,15 +180,16 @@ def get_vertices_and_edges_from_segmentation(gest_seg_np, edge_th=50.0):
             begin_distances = cdist(apex_pts, edges[:, :2], metric="sqeuclidean")
             end_distances = cdist(apex_pts, edges[:, 2:], metric="sqeuclidean")
 
-            begin_closest_points = np.argmin(begin_distances,
-                                             axis=0)  # index of the closest point for each edge end point
+            begin_closest_points = np.argmin(begin_distances, axis=0) # index of the closest point for each edge end point
             end_closest_points = np.argmin(end_distances, axis=0)
 
             begin_closest_point_distances = begin_distances[begin_closest_points, np.arange(len(begin_closest_points))]
             end_closest_point_distances = end_distances[end_closest_points, np.arange(len(end_closest_points))]
 
-            begin_in_range_mask = begin_closest_point_distances <= edge_th
-            end_in_range_mask = end_closest_point_distances <= edge_th
+
+
+            begin_in_range_mask = begin_closest_point_distances < vertex_size[begin_closest_points]
+            end_in_range_mask = end_closest_point_distances < vertex_size[end_closest_points]
 
             # where both ends are in range
             in_range_connected_mask = np.logical_and(begin_in_range_mask, end_in_range_mask)