Fixing mask and bezier curve write

Author: cindygr

Image_based/BaseStatsImage.py

@@ -181,8 +181,8 @@ def debug_image(self, in_image):
 
 
 if __name__ == '__main__':
-    path_bpd = "./data/trunk_segmentation_names.json"
-    #path_bpd = "./data/forcindy_fnames.json"
+    #path_bpd = "./data/trunk_segmentation_names.json"
+    path_bpd = "./data/forcindy_fnames.json"
     all_files = HandleFileNames.read_filenames(path_bpd)
 
     b_do_debug = True

Image_based/bezier_cyl_2d.py

@@ -34,7 +34,7 @@ def __init__(self, start_pt=None, end_pt=None, radius=1, mid_pt=None):
         @param radius - width in the image
         @param mid_pt - optional mid point (otherwise set to halfway between start_pt and end_pt)"""
 
-        if not start_pt or not end_pt:
+        if start_pt is None or end_pt is None:
             self.p0 = np.array([0, 0])
             self.p2 = np.array([1, 0])
             self.orientation = "Horizontal"
@@ -441,8 +441,10 @@ def read_json(fname, bezier_crv=None):
                 bezier_crv = BezierCyl2D([0, 0], [1, 1], 1)
             for k, v in my_data.items():
                 try:
-                    if len(v) > 1:
+                    if len(v) == 2:
                         setattr(bezier_crv, k, np.array(v))
+                    else:
+                        setattr(bezier_crv, k, v)
                 except TypeError:
                     setattr(bezier_crv, k, v)
 

Image_based/fit_bezier_cyl_2d.py

@@ -29,7 +29,7 @@ def __init__(self, bezier_crv_start=None):
         else:
             super(BezierCyl2D, self).__init__()
 
-    def _setup_least_squares(self, ts):
+    def setup_least_squares(self, ts):
         """Setup the least squares approximation - ts is the number of constraints to add, also
            puts in a copule constraints to keep end points where they are
         @param ts - t values to use
@@ -49,7 +49,7 @@ def _setup_least_squares(self, ts):
             b_rhs[i, :] = self.pt_axis(ts_constraints[i])
         return a_constraints, b_rhs
 
-    def _extract_least_squares(self, a_constraints, b_rhs):
+    def extract_least_squares(self, a_constraints, b_rhs):
         """ Do the actual Ax = b and keep horizontal/vertical end points
         @param a_constraints the A of Ax = b
         @param b_rhs the b of Ax = b
@@ -91,15 +91,15 @@ def set_end_pts(self, pt0, pt2):
 
         ts_mid = np.array([0.25, 0.75])
         # Set up the matrix - include the 3 current points plus the centers of the mask
-        a_constraints, b_rhs = self._setup_least_squares(ts_mid)
+        a_constraints, b_rhs = self.setup_least_squares(ts_mid)
         b_rhs[-3, :] = pt0.transpose()
         b_rhs[-2, :] = self.pt_axis(0.5 * (t0 + t2))
         b_rhs[-1, :] = pt2.transpose()
         for i, t in enumerate(ts_mid):
             t_map = (1-t) * t0 + t * t2
             b_rhs[i, :] = self.pt_axis(t_map)
 
-        return self._extract_least_squares(a_constraints, b_rhs)
+        return self.extract_least_squares(a_constraints, b_rhs)
 
 
 if __name__ == '__main__':

Image_based/fit_bezier_cyl_2d_edge.py

@@ -591,3 +591,77 @@ def debug_image_quad_fit(self, image_debug):
     cv2.imwrite('data/forcindy/0_quad.png', im_orig)
 
     print("foo")
+
+    from branchpointdetection import BranchPointDetection
+
+    # Compute all the branch points/approximate lines for branches
+    bp = BranchPointDetection("data/forcindy/", "0")
+
+    # Read in/compute the additional images we need for debugging
+    #   Original image, convert to canny edge
+    #   Mask image
+    #   Depth image
+    im_orig = cv2.imread('data/forcindy/0.png')
+    im_depth = cv2.imread('data/forcindy/0_depth.png')
+    im_mask_color = cv2.imread('data/forcindy/0_trunk_0.png')
+    im_mask = cv2.cvtColor(im_mask_color, cv2.COLOR_BGR2GRAY)
+    im_gray = cv2.cvtColor(im_orig, cv2.COLOR_BGR2GRAY)
+    im_edge = cv2.Canny(im_gray, 50, 150, apertureSize=3)
+    im_depth_color = cv2.cvtColor(im_depth, cv2.COLOR_BGR2RGB)
+    im_covert_back = cv2.cvtColor(im_edge, cv2.COLOR_GRAY2RGB)
+
+    # Write out edge image
+    cv2.imwrite('data/forcindy/0_edges.png', im_edge)
+
+    # For the vertical leader...
+    trunk_pts = bp.trunks[0]["stats"]
+    # Fit a quad to the trunk
+    quad = BezierCyl2D(trunk_pts['lower_left'], trunk_pts['upper_right'], 0.5 * trunk_pts['width'])
+
+    # Current parameters for the vertical leader
+    step_size_to_use = int(quad.radius_2d * 1.5)  # Go along the edge at 1.5 * the estimated radius
+    perc_width_to_use = 0.3  # How "fat" to make the edge rectangles
+    perc_width_to_use_mask = 1.4  # How "fat" a rectangle to cover the mask
+
+    # Debugging image - draw the interior rects
+    quad.draw_interior_rects(im_mask_color, step_size=step_size_to_use, perc_width=perc_width_to_use_mask)
+    cv2.imwrite('data/forcindy/0_mask.png', im_mask_color)
+
+    # For debugging images
+    fig, axs = plt.subplots(2, 2)
+    axs[0, 0].imshow(im_orig)
+    axs[0, 1].imshow(im_mask_color)
+    plt.tight_layout()
+
+    # Iteratively move the quad to the center of the mask
+    for i in range(0, 5):
+        res = quad.adjust_quad_by_mask(im_mask,
+                                       step_size=step_size_to_use, perc_width=perc_width_to_use_mask,
+                                       axs=axs[1, 0])
+        print(f"Res {res}")
+
+    # Draw the original, the edges, and the depth mask with the fitted quad
+    quad.draw_bezier(im_orig)
+    quad.draw_boundary(im_orig, 10)
+    quad.draw_bezier(im_covert_back)
+
+    quad.draw_edge_rects(im_orig, step_size=step_size_to_use, perc_width=perc_width_to_use)
+    quad.draw_edge_rects(im_covert_back, step_size=step_size_to_use, perc_width=perc_width_to_use)
+    #quad.draw_edge_rects_markers(im_edge, step_size=step_size_to_use, perc_width=perc_width_to_use)
+    quad.draw_interior_rects(im_depth_color, step_size=step_size_to_use, perc_width=perc_width_to_use)
+
+    im_both = np.hstack([im_orig, im_covert_back, im_depth_color])
+    cv2.imshow("Original and edge and depth", im_both)
+    cv2.imwrite('data/forcindy/0_rects.png', im_both)
+
+    # Now do the hough transform - first draw the hough transform edges
+    for i in range(0, 5):
+        ret = quad.adjust_quad_by_hough_edges(im_edge, step_size=step_size_to_use, perc_width=perc_width_to_use, axs=axs[1, 1])
+        print(f"Res Hough {ret}")
+
+    im_orig = cv2.imread('data/forcindy/0.png')
+    quad.draw_bezier(im_orig)
+    quad.draw_boundary(im_orig, 10)
+    cv2.imwrite('data/forcindy/0_quad.png', im_orig)
+
+    print("foo")