scale_estimation_coefficient=4.5, added hip, reordered operations to remove loops

handcrafted_solution.py

@@ -101,7 +101,7 @@ def infer_vertices(image_gestalt, *, color_range=4.):
     return inferred_centroids[1:], intersection_mask
 
 
-def get_missed_vertices(vertices, inferred_centroids, *,  min_missing_distance=200.0, **kwargs):
+def get_missed_vertices(vertices, inferred_centroids, *, min_missing_distance=200.0, **kwargs):
     vertices = KDTree(vertices)
     closest = vertices.query(inferred_centroids, k=1, distance_upper_bound=min_missing_distance)
     missed_points = inferred_centroids[closest[1] == len(vertices.data)]
@@ -153,9 +153,19 @@ def get_vertices_and_edges_from_segmentation(gest_seg_np, *, color_range=4., poi
     #     radius = point_radius  # 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
 
-    for edge_class in ['eave', 'ridge', 'rake', 'valley', 'flashing', 'step_flashing']:
-        if len(vertices.data) < 2:
-            break
+    if len(vertices.data) < 2:
+        return [], []
+    edges = []
+    line_directions = []
+
+    rho = 1  # distance resolution in pixels of the Hough grid
+    theta = np.pi / 180  # angular resolution in radians of the Hough grid
+    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
+
+    for edge_class in ['eave', 'ridge', 'rake', 'valley', 'flashing', 'step_flashing', 'hip']:
+
         edge_color = np.array(gestalt_color_mapping[edge_class])
 
         mask = cv2.inRange(gest_seg_np,
@@ -167,31 +177,22 @@ def get_vertices_and_edges_from_segmentation(gest_seg_np, *, color_range=4., poi
         if not np.any(mask):
             continue
 
-        rho = 1  # distance resolution in pixels of the Hough grid
-        theta = np.pi / 180  # angular resolution in radians of the Hough grid
-        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 = []
-
         if lines is None:
             continue
 
-        line_directions = np.zeros((len(lines), 2))
         for line_idx, line in enumerate(lines):
             for x1, y1, x2, y2 in line:
                 if x1 < x2:
                     x1, y1, x2, y2 = x2, y2, x1, y1
                 direction = (np.array([x2 - x1, y2 - y1]))
                 direction = direction / np.linalg.norm(direction)
-                line_directions[line_idx] = direction
+                line_directions.append(direction)
 
                 direction = extend * direction
 
@@ -200,64 +201,67 @@ def get_vertices_and_edges_from_segmentation(gest_seg_np, *, color_range=4., poi
 
                 edges.append((x1, y1, x2, y2))
 
-        edges = np.array(edges).astype(np.float64)
-        if len(edges) < 1:
-            continue
-        # calculate the distances between the vertices and the edge ends
+    edges = np.array(edges).astype(np.float64)
+    line_directions = np.array(line_directions).astype(np.float64)
+    if len(edges) < 1:
+        return [], []
+    # calculate the distances between the vertices and the edge ends
 
-        begin_edges = KDTree(edges[:, :2])
-        end_edges = KDTree(edges[:, 2:])
+    begin_edges = KDTree(edges[:, :2])
+    end_edges = KDTree(edges[:, 2:])
 
-        begin_indices = begin_edges.query_ball_tree(vertices, point_radius)
-        end_indices = end_edges.query_ball_tree(vertices, point_radius)
+    begin_indices = begin_edges.query_ball_tree(vertices, point_radius)
+    end_indices = end_edges.query_ball_tree(vertices, point_radius)
 
-        line_indices = np.where(np.array([len(i) and len(j) for i, j in zip(begin_indices, end_indices)]))[0]
+    line_indices = np.where(np.array([len(i) and len(j) for i, j in zip(begin_indices, end_indices)]))[0]
 
-        # create all possible connections between begin and end candidates that correspond to a line
-        begin_vertex_list = []
-        end_vertex_list = []
-        line_idx_list = []
-        for line_idx in line_indices:
-            begin_vertex, end_vertex = begin_indices[line_idx], end_indices[line_idx]
-            begin_vertex, end_vertex = np.meshgrid(begin_vertex, end_vertex)
-            begin_vertex_list.extend(begin_vertex.flatten())
-            end_vertex_list.extend(end_vertex.flatten())
+    # create all possible connections between begin and end candidates that correspond to a line
+    begin_vertex_list = []
+    end_vertex_list = []
+    line_idx_list = []
+    for line_idx in line_indices:
+        begin_vertex, end_vertex = begin_indices[line_idx], end_indices[line_idx]
+        begin_vertex, end_vertex = np.meshgrid(begin_vertex, end_vertex)
+        begin_vertex_list.extend(begin_vertex.flatten())
+        end_vertex_list.extend(end_vertex.flatten())
 
-            line_idx_list.extend([line_idx] * len(begin_vertex.flatten()))
+        line_idx_list.extend([line_idx] * len(begin_vertex.flatten()))
 
-        line_idx_list = np.array(line_idx_list)
-        all_connections = np.array([begin_vertex_list, end_vertex_list])
+    line_idx_list = np.array(line_idx_list)
+    all_connections = np.array([begin_vertex_list, end_vertex_list])
 
-        # decrease the number of possible connections to reduce number of calculations
-        possible_connections = np.unique(all_connections, axis=1)
-        possible_connections = np.sort(possible_connections, axis=0)
-        possible_connections = np.unique(possible_connections, axis=1)
-        possible_connections = possible_connections[:, possible_connections[0, :] != possible_connections[1, :]]
+    # decrease the number of possible connections to reduce number of calculations
+    possible_connections = np.unique(all_connections, axis=1)
+    possible_connections = np.sort(possible_connections, axis=0)
+    possible_connections = np.unique(possible_connections, axis=1)
+    possible_connections = possible_connections[:, possible_connections[0, :] != possible_connections[1, :]]
 
-        if possible_connections.shape[1] < 1:
-            continue
+    if possible_connections.shape[1] < 1:
+        return [], []
+
+    # precalculate the possible direction vectors
+    possible_direction_vectors = vertices.data[possible_connections[0]] - vertices.data[possible_connections[1]]
+    possible_direction_vectors = possible_direction_vectors / np.linalg.norm(possible_direction_vectors, axis=1)[:,
+                                                              np.newaxis]
 
-        # precalculate the possible direction vectors
-        possible_direction_vectors = vertices.data[possible_connections[0]] - vertices.data[possible_connections[1]]
-        possible_direction_vectors = possible_direction_vectors / np.linalg.norm(possible_direction_vectors, axis=1)[:, np.newaxis]
-
-        owned_lines_per_possible_connections = [list() for i in range(possible_connections.shape[1])]
-
-        # assign lines to possible connections
-        for line_idx, i,j in zip(line_idx_list, begin_vertex_list, end_vertex_list):
-            if i == j:
-                continue
-            i, j = min(i, j), max(i, j)
-            for connection_idx, connection in enumerate(possible_connections.T):
-                if np.all((i, j) == connection):
-                    owned_lines_per_possible_connections[connection_idx].append(line_idx)
-                    break
-
-        # check if the lines are in the same direction as the possible connection
-        for fitted_line_idx, owned_lines_per_possible_connection in enumerate(owned_lines_per_possible_connections):
-            line_deviations = np.abs(np.dot(line_directions[owned_lines_per_possible_connection], possible_direction_vectors[fitted_line_idx]))
-            if np.any(line_deviations > deviation_threshold):
-                connections.append(possible_connections[:, fitted_line_idx])
+    owned_lines_per_possible_connections = [list() for i in range(possible_connections.shape[1])]
+
+    # assign lines to possible connections
+    for line_idx, i, j in zip(line_idx_list, begin_vertex_list, end_vertex_list):
+        if i == j:
+            continue
+        i, j = min(i, j), max(i, j)
+        for connection_idx, connection in enumerate(possible_connections.T):
+            if np.all((i, j) == connection):
+                owned_lines_per_possible_connections[connection_idx].append(line_idx)
+                break
+
+    # check if the lines are in the same direction as the possible connection
+    for fitted_line_idx, owned_lines_per_possible_connection in enumerate(owned_lines_per_possible_connections):
+        line_deviations = np.abs(
+            np.dot(line_directions[owned_lines_per_possible_connection], possible_direction_vectors[fitted_line_idx]))
+        if np.any(line_deviations > deviation_threshold):
+            connections.append(possible_connections[:, fitted_line_idx])
 
     vertices = [{"xy": v, "type": "apex"} for v in apex_centroids]
     # vertices += [{"xy": v, "type": "apex"} for v in missed_vertices]

script.py

@@ -127,7 +127,13 @@ if __name__ == "__main__":
     with ProcessPoolExecutor(max_workers=8) as pool:
         results = []
         for i, sample in enumerate(tqdm(dataset)):
-            results.append(pool.submit(predict, sample, visualize=False, point_radius=25, max_angle=15, extend=30, merge_th=3.0,  min_missing_distance=1000000.0, scale_estimation_coefficient=4))
+            results.append(pool.submit(predict, sample, visualize=False,
+                                       point_radius=25,
+                                       max_angle=15,
+                                       extend=30,
+                                       merge_th=3.0,
+                                       min_missing_distance=1000000.0,
+                                       scale_estimation_coefficient=4.5))
         
         for i, result in enumerate(tqdm(results)):
             key, pred_vertices, pred_edges = result.result()

test_solution.ipynb

@@ -6,8 +6,8 @@
    "metadata": {
     "collapsed": true,
     "ExecuteTime": {
-     "end_time": "2024-05-30T19:40:29.917386Z",
-     "start_time": "2024-05-30T19:40:26.483885Z"
+     "end_time": "2024-05-30T20:07:32.989151Z",
+     "start_time": "2024-05-30T20:07:28.709056Z"
     }
    },
    "source": [
@@ -44,8 +44,8 @@
   {
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2024-05-30T19:40:29.922957Z",
-     "start_time": "2024-05-30T19:40:29.918391Z"
+     "end_time": "2024-05-30T20:07:32.997502Z",
+     "start_time": "2024-05-30T20:07:32.991160Z"
     }
    },
    "cell_type": "code",
@@ -64,8 +64,8 @@
   {
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2024-05-30T19:40:29.927010Z",
-     "start_time": "2024-05-30T19:40:29.923961Z"
+     "end_time": "2024-05-30T20:07:33.002189Z",
+     "start_time": "2024-05-30T20:07:32.998509Z"
     }
    },
    "cell_type": "code",
@@ -83,8 +83,8 @@
   {
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2024-05-30T19:46:53.539149Z",
-     "start_time": "2024-05-30T19:45:17.379935Z"
+     "end_time": "2024-05-30T20:09:14.932688Z",
+     "start_time": "2024-05-30T20:07:33.003197Z"
     }
    },
    "cell_type": "code",
@@ -93,7 +93,7 @@
     "\n",
     "solution = []\n",
     "from concurrent.futures import ProcessPoolExecutor\n",
-    "with ProcessPoolExecutor(max_workers=10) as pool:\n",
+    "with ProcessPoolExecutor(max_workers=11) as pool:\n",
     "    results = []\n",
     "    for i, sample in enumerate(tqdm(dataset)):\n",
     "        results.append(pool.submit(predict, sample,\n",
@@ -102,7 +102,7 @@
     "                                   extend=30, \n",
     "                                   merge_th=3.0, \n",
     "                                   min_missing_distance=10000.0, \n",
-    "                                   scale_estimation_coefficient=4))\n",
+    "                                   scale_estimation_coefficient=4.5))\n",
     "\n",
     "    for i, result in enumerate(tqdm(results)):\n",
     "        key, pred_vertices, pred_edges = result.result()\n",
@@ -122,18 +122,18 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "346it [00:11, 29.44it/s] \n",
-      "100%|██████████| 346/346 [01:23<00:00,  4.15it/s]\n"
+      "346it [00:11, 29.46it/s] \n",
+      "100%|██████████| 346/346 [01:28<00:00,  3.89it/s]\n"
      ]
     }
    ],
-   "execution_count": 7
+   "execution_count": 4
   },
   {
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2024-05-30T19:42:15.830560Z",
-     "start_time": "2024-05-30T19:42:15.185713Z"
+     "end_time": "2024-05-30T20:09:16.762781Z",
+     "start_time": "2024-05-30T20:09:14.933694Z"
     }
    },
    "cell_type": "code",
@@ -163,7 +163,7 @@
     {
      "data": {
       "text/plain": [
-       "DescribeResult(nobs=173, minmax=(1.3699674819647794, 3.507189015362208), mean=2.159528576281002, variance=0.19517651860816773, skewness=0.5493231777924736, kurtosis=-0.14096706768318912)"
+       "DescribeResult(nobs=173, minmax=(1.017917771309308, 3.4203176014390544), mean=2.1252280986193086, variance=0.18178457466035677, skewness=0.3534767409028922, kurtosis=-0.13765543977621153)"
       ]
      },
      "execution_count": 5,
@@ -176,7 +176,7 @@
   {
    "metadata": {},
    "cell_type": "markdown",
-   "source": "best mean=2.159528576281002",
+   "source": "best mean=2.123433669870156",
    "id": "1d3cde94dcfc4c56"
   },
   {